mountd.c revision 172827
1/* 2 * Copyright (c) 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Herb Hasler and Rick Macklem at The University of Guelph. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 4. Neither the name of the University nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33#ifndef lint 34static const char copyright[] = 35"@(#) Copyright (c) 1989, 1993\n\ 36 The Regents of the University of California. All rights reserved.\n"; 37#endif /*not lint*/ 38 39#if 0 40#ifndef lint 41static char sccsid[] = "@(#)mountd.c 8.15 (Berkeley) 5/1/95"; 42#endif /*not lint*/ 43#endif 44 45#include <sys/cdefs.h> 46__FBSDID("$FreeBSD: head/usr.sbin/mountd/mountd.c 172827 2007-10-20 11:25:34Z matteo $"); 47 48#include <sys/param.h> 49#include <sys/mount.h> 50#include <sys/fcntl.h> 51#include <sys/stat.h> 52#include <sys/syslog.h> 53#include <sys/sysctl.h> 54#include <sys/linker.h> 55#include <sys/module.h> 56 57#include <rpc/rpc.h> 58#include <rpc/rpc_com.h> 59#include <rpc/pmap_clnt.h> 60#include <rpc/pmap_prot.h> 61#include <rpcsvc/mount.h> 62#include <nfs/rpcv2.h> 63#include <nfs/nfsproto.h> 64#include <nfsserver/nfs.h> 65 66#include <arpa/inet.h> 67 68#include <ctype.h> 69#include <err.h> 70#include <errno.h> 71#include <grp.h> 72#include <libutil.h> 73#include <limits.h> 74#include <netdb.h> 75#include <pwd.h> 76#include <signal.h> 77#include <stdio.h> 78#include <stdlib.h> 79#include <string.h> 80#include <unistd.h> 81#include "pathnames.h" 82#include "mntopts.h" 83 84#ifdef DEBUG 85#include <stdarg.h> 86#endif 87 88/* 89 * Structures for keeping the mount list and export list 90 */ 91struct mountlist { 92 struct mountlist *ml_next; 93 char ml_host[RPCMNT_NAMELEN+1]; 94 char ml_dirp[RPCMNT_PATHLEN+1]; 95}; 96 97struct dirlist { 98 struct dirlist *dp_left; 99 struct dirlist *dp_right; 100 int dp_flag; 101 struct hostlist *dp_hosts; /* List of hosts this dir exported to */ 102 char dp_dirp[1]; /* Actually malloc'd to size of dir */ 103}; 104/* dp_flag bits */ 105#define DP_DEFSET 0x1 106#define DP_HOSTSET 0x2 107 108struct exportlist { 109 struct exportlist *ex_next; 110 struct dirlist *ex_dirl; 111 struct dirlist *ex_defdir; 112 int ex_flag; 113 fsid_t ex_fs; 114 char *ex_fsdir; 115 char *ex_indexfile; 116}; 117/* ex_flag bits */ 118#define EX_LINKED 0x1 119 120struct netmsk { 121 struct sockaddr_storage nt_net; 122 struct sockaddr_storage nt_mask; 123 char *nt_name; 124}; 125 126union grouptypes { 127 struct addrinfo *gt_addrinfo; 128 struct netmsk gt_net; 129}; 130 131struct grouplist { 132 int gr_type; 133 union grouptypes gr_ptr; 134 struct grouplist *gr_next; 135}; 136/* Group types */ 137#define GT_NULL 0x0 138#define GT_HOST 0x1 139#define GT_NET 0x2 140#define GT_DEFAULT 0x3 141#define GT_IGNORE 0x5 142 143struct hostlist { 144 int ht_flag; /* Uses DP_xx bits */ 145 struct grouplist *ht_grp; 146 struct hostlist *ht_next; 147}; 148 149struct fhreturn { 150 int fhr_flag; 151 int fhr_vers; 152 nfsfh_t fhr_fh; 153}; 154 155/* Global defs */ 156char *add_expdir(struct dirlist **, char *, int); 157void add_dlist(struct dirlist **, struct dirlist *, 158 struct grouplist *, int); 159void add_mlist(char *, char *); 160int check_dirpath(char *); 161int check_options(struct dirlist *); 162int checkmask(struct sockaddr *sa); 163int chk_host(struct dirlist *, struct sockaddr *, int *, int *); 164void create_service(struct netconfig *nconf); 165void del_mlist(char *hostp, char *dirp); 166struct dirlist *dirp_search(struct dirlist *, char *); 167int do_mount(struct exportlist *, struct grouplist *, int, 168 struct xucred *, char *, int, struct statfs *); 169int do_opt(char **, char **, struct exportlist *, struct grouplist *, 170 int *, int *, struct xucred *); 171struct exportlist *ex_search(fsid_t *); 172struct exportlist *get_exp(void); 173void free_dir(struct dirlist *); 174void free_exp(struct exportlist *); 175void free_grp(struct grouplist *); 176void free_host(struct hostlist *); 177void get_exportlist(void); 178int get_host(char *, struct grouplist *, struct grouplist *); 179struct hostlist *get_ht(void); 180int get_line(void); 181void get_mountlist(void); 182int get_net(char *, struct netmsk *, int); 183void getexp_err(struct exportlist *, struct grouplist *); 184struct grouplist *get_grp(void); 185void hang_dirp(struct dirlist *, struct grouplist *, 186 struct exportlist *, int); 187void huphandler(int sig); 188int makemask(struct sockaddr_storage *ssp, int bitlen); 189void mntsrv(struct svc_req *, SVCXPRT *); 190void nextfield(char **, char **); 191void out_of_mem(void); 192void parsecred(char *, struct xucred *); 193int put_exlist(struct dirlist *, XDR *, struct dirlist *, int *, int); 194void *sa_rawaddr(struct sockaddr *sa, int *nbytes); 195int sacmp(struct sockaddr *sa1, struct sockaddr *sa2, 196 struct sockaddr *samask); 197int scan_tree(struct dirlist *, struct sockaddr *); 198static void usage(void); 199int xdr_dir(XDR *, char *); 200int xdr_explist(XDR *, caddr_t); 201int xdr_explist_brief(XDR *, caddr_t); 202int xdr_fhs(XDR *, caddr_t); 203int xdr_mlist(XDR *, caddr_t); 204void terminate(int); 205 206struct exportlist *exphead; 207struct mountlist *mlhead; 208struct grouplist *grphead; 209char *exnames_default[2] = { _PATH_EXPORTS, NULL }; 210char **exnames; 211char **hosts = NULL; 212struct xucred def_anon = { 213 XUCRED_VERSION, 214 (uid_t)-2, 215 1, 216 { (gid_t)-2 }, 217 NULL 218}; 219int force_v2 = 0; 220int resvport_only = 1; 221int nhosts = 0; 222int dir_only = 1; 223int dolog = 0; 224int got_sighup = 0; 225int xcreated = 0; 226 227char *svcport_str = NULL; 228 229int opt_flags; 230static int have_v6 = 1; 231 232struct pidfh *pfh = NULL; 233/* Bits for opt_flags above */ 234#define OP_MAPROOT 0x01 235#define OP_MAPALL 0x02 236/* 0x4 free */ 237#define OP_MASK 0x08 238#define OP_NET 0x10 239#define OP_ALLDIRS 0x40 240#define OP_HAVEMASK 0x80 /* A mask was specified or inferred. */ 241#define OP_QUIET 0x100 242#define OP_MASKLEN 0x200 243 244#ifdef DEBUG 245int debug = 1; 246void SYSLOG(int, const char *, ...) __printflike(2, 3); 247#define syslog SYSLOG 248#else 249int debug = 0; 250#endif 251 252/* 253 * Mountd server for NFS mount protocol as described in: 254 * NFS: Network File System Protocol Specification, RFC1094, Appendix A 255 * The optional arguments are the exports file name 256 * default: _PATH_EXPORTS 257 * and "-n" to allow nonroot mount. 258 */ 259int 260main(argc, argv) 261 int argc; 262 char **argv; 263{ 264 fd_set readfds; 265 struct netconfig *nconf; 266 char *endptr, **hosts_bak; 267 void *nc_handle; 268 pid_t otherpid; 269 in_port_t svcport; 270 int c, k, s; 271 int maxrec = RPC_MAXDATASIZE; 272 273 /* Check that another mountd isn't already running. */ 274 pfh = pidfile_open(_PATH_MOUNTDPID, 0600, &otherpid); 275 if (pfh == NULL) { 276 if (errno == EEXIST) 277 errx(1, "mountd already running, pid: %d.", otherpid); 278 warn("cannot open or create pidfile"); 279 } 280 281 s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); 282 if (s < 0) 283 have_v6 = 0; 284 else 285 close(s); 286 if (modfind("nfsserver") < 0) { 287 /* Not present in kernel, try loading it */ 288 if (kldload("nfsserver") < 0 || modfind("nfsserver") < 0) 289 errx(1, "NFS server is not available or loadable"); 290 } 291 292 while ((c = getopt(argc, argv, "2dh:lnp:r")) != -1) 293 switch (c) { 294 case '2': 295 force_v2 = 1; 296 break; 297 case 'n': 298 resvport_only = 0; 299 break; 300 case 'r': 301 dir_only = 0; 302 break; 303 case 'd': 304 debug = debug ? 0 : 1; 305 break; 306 case 'l': 307 dolog = 1; 308 break; 309 case 'p': 310 endptr = NULL; 311 svcport = (in_port_t)strtoul(optarg, &endptr, 10); 312 if (endptr == NULL || *endptr != '\0' || 313 svcport == 0 || svcport >= IPPORT_MAX) 314 usage(); 315 svcport_str = strdup(optarg); 316 break; 317 case 'h': 318 ++nhosts; 319 hosts_bak = hosts; 320 hosts_bak = realloc(hosts, nhosts * sizeof(char *)); 321 if (hosts_bak == NULL) { 322 if (hosts != NULL) { 323 for (k = 0; k < nhosts; k++) 324 free(hosts[k]); 325 free(hosts); 326 out_of_mem(); 327 } 328 } 329 hosts = hosts_bak; 330 hosts[nhosts - 1] = strdup(optarg); 331 if (hosts[nhosts - 1] == NULL) { 332 for (k = 0; k < (nhosts - 1); k++) 333 free(hosts[k]); 334 free(hosts); 335 out_of_mem(); 336 } 337 break; 338 default: 339 usage(); 340 }; 341 argc -= optind; 342 argv += optind; 343 grphead = (struct grouplist *)NULL; 344 exphead = (struct exportlist *)NULL; 345 mlhead = (struct mountlist *)NULL; 346 if (argc > 0) 347 exnames = argv; 348 else 349 exnames = exnames_default; 350 openlog("mountd", LOG_PID, LOG_DAEMON); 351 if (debug) 352 warnx("getting export list"); 353 get_exportlist(); 354 if (debug) 355 warnx("getting mount list"); 356 get_mountlist(); 357 if (debug) 358 warnx("here we go"); 359 if (debug == 0) { 360 daemon(0, 0); 361 signal(SIGINT, SIG_IGN); 362 signal(SIGQUIT, SIG_IGN); 363 } 364 signal(SIGHUP, huphandler); 365 signal(SIGTERM, terminate); 366 signal(SIGPIPE, SIG_IGN); 367 368 pidfile_write(pfh); 369 370 rpcb_unset(RPCPROG_MNT, RPCMNT_VER1, NULL); 371 rpcb_unset(RPCPROG_MNT, RPCMNT_VER3, NULL); 372 rpc_control(RPC_SVC_CONNMAXREC_SET, &maxrec); 373 374 if (!resvport_only) { 375 if (sysctlbyname("vfs.nfsrv.nfs_privport", NULL, NULL, 376 &resvport_only, sizeof(resvport_only)) != 0 && 377 errno != ENOENT) { 378 syslog(LOG_ERR, "sysctl: %m"); 379 exit(1); 380 } 381 } 382 383 /* 384 * If no hosts were specified, add a wildcard entry to bind to 385 * INADDR_ANY. Otherwise make sure 127.0.0.1 and ::1 are added to the 386 * list. 387 */ 388 if (nhosts == 0) { 389 hosts = malloc(sizeof(char**)); 390 if (hosts == NULL) 391 out_of_mem(); 392 hosts[0] = "*"; 393 nhosts = 1; 394 } else { 395 hosts_bak = hosts; 396 if (have_v6) { 397 hosts_bak = realloc(hosts, (nhosts + 2) * 398 sizeof(char *)); 399 if (hosts_bak == NULL) { 400 for (k = 0; k < nhosts; k++) 401 free(hosts[k]); 402 free(hosts); 403 out_of_mem(); 404 } else 405 hosts = hosts_bak; 406 nhosts += 2; 407 hosts[nhosts - 2] = "::1"; 408 } else { 409 hosts_bak = realloc(hosts, (nhosts + 1) * sizeof(char *)); 410 if (hosts_bak == NULL) { 411 for (k = 0; k < nhosts; k++) 412 free(hosts[k]); 413 free(hosts); 414 out_of_mem(); 415 } else { 416 nhosts += 1; 417 hosts = hosts_bak; 418 } 419 } 420 421 hosts[nhosts - 1] = "127.0.0.1"; 422 } 423 424 nc_handle = setnetconfig(); 425 while ((nconf = getnetconfig(nc_handle))) { 426 if (nconf->nc_flag & NC_VISIBLE) { 427 if (have_v6 == 0 && strcmp(nconf->nc_protofmly, 428 "inet6") == 0) { 429 /* DO NOTHING */ 430 } else 431 create_service(nconf); 432 } 433 } 434 endnetconfig(nc_handle); 435 436 if (xcreated == 0) { 437 syslog(LOG_ERR, "could not create any services"); 438 exit(1); 439 } 440 441 /* Expand svc_run() here so that we can call get_exportlist(). */ 442 for (;;) { 443 if (got_sighup) { 444 get_exportlist(); 445 got_sighup = 0; 446 } 447 readfds = svc_fdset; 448 switch (select(svc_maxfd + 1, &readfds, NULL, NULL, NULL)) { 449 case -1: 450 if (errno == EINTR) 451 continue; 452 syslog(LOG_ERR, "mountd died: select: %m"); 453 exit(1); 454 case 0: 455 continue; 456 default: 457 svc_getreqset(&readfds); 458 } 459 } 460} 461 462/* 463 * This routine creates and binds sockets on the appropriate 464 * addresses. It gets called one time for each transport and 465 * registrates the service with rpcbind on that trasport. 466 */ 467void 468create_service(struct netconfig *nconf) 469{ 470 struct addrinfo hints, *res = NULL; 471 struct sockaddr_in *sin; 472 struct sockaddr_in6 *sin6; 473 struct __rpc_sockinfo si; 474 struct netbuf servaddr; 475 SVCXPRT *transp = NULL; 476 int aicode; 477 int fd; 478 int nhostsbak; 479 int one = 1; 480 int r; 481 int registered = 0; 482 u_int32_t host_addr[4]; /* IPv4 or IPv6 */ 483 484 if ((nconf->nc_semantics != NC_TPI_CLTS) && 485 (nconf->nc_semantics != NC_TPI_COTS) && 486 (nconf->nc_semantics != NC_TPI_COTS_ORD)) 487 return; /* not my type */ 488 489 /* 490 * XXX - using RPC library internal functions. 491 */ 492 if (!__rpc_nconf2sockinfo(nconf, &si)) { 493 syslog(LOG_ERR, "cannot get information for %s", 494 nconf->nc_netid); 495 return; 496 } 497 498 /* Get mountd's address on this transport */ 499 memset(&hints, 0, sizeof hints); 500 hints.ai_flags = AI_PASSIVE; 501 hints.ai_family = si.si_af; 502 hints.ai_socktype = si.si_socktype; 503 hints.ai_protocol = si.si_proto; 504 505 /* 506 * Bind to specific IPs if asked to 507 */ 508 nhostsbak = nhosts; 509 while (nhostsbak > 0) { 510 --nhostsbak; 511 /* 512 * XXX - using RPC library internal functions. 513 */ 514 if ((fd = __rpc_nconf2fd(nconf)) < 0) { 515 int non_fatal = 0; 516 if (errno == EPROTONOSUPPORT && 517 nconf->nc_semantics != NC_TPI_CLTS) 518 non_fatal = 1; 519 520 syslog(non_fatal ? LOG_DEBUG : LOG_ERR, 521 "cannot create socket for %s", nconf->nc_netid); 522 return; 523 } 524 525 switch (hints.ai_family) { 526 case AF_INET: 527 if (inet_pton(AF_INET, hosts[nhostsbak], 528 host_addr) == 1) { 529 hints.ai_flags &= AI_NUMERICHOST; 530 } else { 531 /* 532 * Skip if we have an AF_INET6 address. 533 */ 534 if (inet_pton(AF_INET6, hosts[nhostsbak], 535 host_addr) == 1) { 536 close(fd); 537 continue; 538 } 539 } 540 break; 541 case AF_INET6: 542 if (inet_pton(AF_INET6, hosts[nhostsbak], 543 host_addr) == 1) { 544 hints.ai_flags &= AI_NUMERICHOST; 545 } else { 546 /* 547 * Skip if we have an AF_INET address. 548 */ 549 if (inet_pton(AF_INET, hosts[nhostsbak], 550 host_addr) == 1) { 551 close(fd); 552 continue; 553 } 554 } 555 556 /* 557 * We're doing host-based access checks here, so don't 558 * allow v4-in-v6 to confuse things. The kernel will 559 * disable it by default on NFS sockets too. 560 */ 561 if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, 562 sizeof one) < 0) { 563 syslog(LOG_ERR, 564 "can't disable v4-in-v6 on IPv6 socket"); 565 exit(1); 566 } 567 break; 568 default: 569 break; 570 } 571 572 /* 573 * If no hosts were specified, just bind to INADDR_ANY 574 */ 575 if (strcmp("*", hosts[nhostsbak]) == 0) { 576 if (svcport_str == NULL) { 577 res = malloc(sizeof(struct addrinfo)); 578 if (res == NULL) 579 out_of_mem(); 580 res->ai_flags = hints.ai_flags; 581 res->ai_family = hints.ai_family; 582 res->ai_protocol = hints.ai_protocol; 583 switch (res->ai_family) { 584 case AF_INET: 585 sin = malloc(sizeof(struct sockaddr_in)); 586 if (sin == NULL) 587 out_of_mem(); 588 sin->sin_family = AF_INET; 589 sin->sin_port = htons(0); 590 sin->sin_addr.s_addr = htonl(INADDR_ANY); 591 res->ai_addr = (struct sockaddr*) sin; 592 res->ai_addrlen = (socklen_t) 593 sizeof(res->ai_addr); 594 break; 595 case AF_INET6: 596 sin6 = malloc(sizeof(struct sockaddr_in6)); 597 if (res->ai_addr == NULL) 598 out_of_mem(); 599 sin6->sin6_family = AF_INET6; 600 sin6->sin6_port = htons(0); 601 sin6->sin6_addr = in6addr_any; 602 res->ai_addr = (struct sockaddr*) sin6; 603 res->ai_addrlen = (socklen_t) 604 sizeof(res->ai_addr); 605 break; 606 default: 607 break; 608 } 609 } else { 610 if ((aicode = getaddrinfo(NULL, svcport_str, 611 &hints, &res)) != 0) { 612 syslog(LOG_ERR, 613 "cannot get local address for %s: %s", 614 nconf->nc_netid, 615 gai_strerror(aicode)); 616 continue; 617 } 618 } 619 } else { 620 if ((aicode = getaddrinfo(hosts[nhostsbak], svcport_str, 621 &hints, &res)) != 0) { 622 syslog(LOG_ERR, 623 "cannot get local address for %s: %s", 624 nconf->nc_netid, gai_strerror(aicode)); 625 continue; 626 } 627 } 628 629 r = bindresvport_sa(fd, res->ai_addr); 630 if (r != 0) { 631 syslog(LOG_ERR, "bindresvport_sa: %m"); 632 exit(1); 633 } 634 635 if (nconf->nc_semantics != NC_TPI_CLTS) 636 listen(fd, SOMAXCONN); 637 638 if (nconf->nc_semantics == NC_TPI_CLTS ) 639 transp = svc_dg_create(fd, 0, 0); 640 else 641 transp = svc_vc_create(fd, RPC_MAXDATASIZE, 642 RPC_MAXDATASIZE); 643 644 if (transp != (SVCXPRT *) NULL) { 645 if (!svc_reg(transp, RPCPROG_MNT, RPCMNT_VER1, mntsrv, 646 NULL)) 647 syslog(LOG_ERR, 648 "can't register %s RPCMNT_VER1 service", 649 nconf->nc_netid); 650 if (!force_v2) { 651 if (!svc_reg(transp, RPCPROG_MNT, RPCMNT_VER3, 652 mntsrv, NULL)) 653 syslog(LOG_ERR, 654 "can't register %s RPCMNT_VER3 service", 655 nconf->nc_netid); 656 } 657 } else 658 syslog(LOG_WARNING, "can't create %s services", 659 nconf->nc_netid); 660 661 if (registered == 0) { 662 registered = 1; 663 memset(&hints, 0, sizeof hints); 664 hints.ai_flags = AI_PASSIVE; 665 hints.ai_family = si.si_af; 666 hints.ai_socktype = si.si_socktype; 667 hints.ai_protocol = si.si_proto; 668 669 if (svcport_str == NULL) { 670 svcport_str = malloc(NI_MAXSERV * sizeof(char)); 671 if (svcport_str == NULL) 672 out_of_mem(); 673 674 if (getnameinfo(res->ai_addr, 675 res->ai_addr->sa_len, NULL, NI_MAXHOST, 676 svcport_str, NI_MAXSERV * sizeof(char), 677 NI_NUMERICHOST | NI_NUMERICSERV)) 678 errx(1, "Cannot get port number"); 679 } 680 681 if((aicode = getaddrinfo(NULL, svcport_str, &hints, 682 &res)) != 0) { 683 syslog(LOG_ERR, "cannot get local address: %s", 684 gai_strerror(aicode)); 685 exit(1); 686 } 687 688 servaddr.buf = malloc(res->ai_addrlen); 689 memcpy(servaddr.buf, res->ai_addr, res->ai_addrlen); 690 servaddr.len = res->ai_addrlen; 691 692 rpcb_set(RPCPROG_MNT, RPCMNT_VER1, nconf, &servaddr); 693 rpcb_set(RPCPROG_MNT, RPCMNT_VER3, nconf, &servaddr); 694 695 xcreated++; 696 freeaddrinfo(res); 697 } 698 } /* end while */ 699} 700 701static void 702usage() 703{ 704 fprintf(stderr, 705 "usage: mountd [-2] [-d] [-l] [-n] [-p <port>] [-r] " 706 "[-h <bindip>] [export_file ...]\n"); 707 exit(1); 708} 709 710/* 711 * The mount rpc service 712 */ 713void 714mntsrv(rqstp, transp) 715 struct svc_req *rqstp; 716 SVCXPRT *transp; 717{ 718 struct exportlist *ep; 719 struct dirlist *dp; 720 struct fhreturn fhr; 721 struct stat stb; 722 struct statfs fsb; 723 char host[NI_MAXHOST], numerichost[NI_MAXHOST]; 724 int lookup_failed = 1; 725 struct sockaddr *saddr; 726 u_short sport; 727 char rpcpath[RPCMNT_PATHLEN + 1], dirpath[MAXPATHLEN]; 728 int bad = 0, defset, hostset; 729 sigset_t sighup_mask; 730 731 sigemptyset(&sighup_mask); 732 sigaddset(&sighup_mask, SIGHUP); 733 saddr = svc_getrpccaller(transp)->buf; 734 switch (saddr->sa_family) { 735 case AF_INET6: 736 sport = ntohs(((struct sockaddr_in6 *)saddr)->sin6_port); 737 break; 738 case AF_INET: 739 sport = ntohs(((struct sockaddr_in *)saddr)->sin_port); 740 break; 741 default: 742 syslog(LOG_ERR, "request from unknown address family"); 743 return; 744 } 745 lookup_failed = getnameinfo(saddr, saddr->sa_len, host, sizeof host, 746 NULL, 0, 0); 747 getnameinfo(saddr, saddr->sa_len, numerichost, 748 sizeof numerichost, NULL, 0, NI_NUMERICHOST); 749 switch (rqstp->rq_proc) { 750 case NULLPROC: 751 if (!svc_sendreply(transp, (xdrproc_t)xdr_void, NULL)) 752 syslog(LOG_ERR, "can't send reply"); 753 return; 754 case RPCMNT_MOUNT: 755 if (sport >= IPPORT_RESERVED && resvport_only) { 756 syslog(LOG_NOTICE, 757 "mount request from %s from unprivileged port", 758 numerichost); 759 svcerr_weakauth(transp); 760 return; 761 } 762 if (!svc_getargs(transp, (xdrproc_t)xdr_dir, rpcpath)) { 763 syslog(LOG_NOTICE, "undecodable mount request from %s", 764 numerichost); 765 svcerr_decode(transp); 766 return; 767 } 768 769 /* 770 * Get the real pathname and make sure it is a directory 771 * or a regular file if the -r option was specified 772 * and it exists. 773 */ 774 if (realpath(rpcpath, dirpath) == NULL || 775 stat(dirpath, &stb) < 0 || 776 (!S_ISDIR(stb.st_mode) && 777 (dir_only || !S_ISREG(stb.st_mode))) || 778 statfs(dirpath, &fsb) < 0) { 779 chdir("/"); /* Just in case realpath doesn't */ 780 syslog(LOG_NOTICE, 781 "mount request from %s for non existent path %s", 782 numerichost, dirpath); 783 if (debug) 784 warnx("stat failed on %s", dirpath); 785 bad = ENOENT; /* We will send error reply later */ 786 } 787 788 /* Check in the exports list */ 789 sigprocmask(SIG_BLOCK, &sighup_mask, NULL); 790 ep = ex_search(&fsb.f_fsid); 791 hostset = defset = 0; 792 if (ep && (chk_host(ep->ex_defdir, saddr, &defset, &hostset) || 793 ((dp = dirp_search(ep->ex_dirl, dirpath)) && 794 chk_host(dp, saddr, &defset, &hostset)) || 795 (defset && scan_tree(ep->ex_defdir, saddr) == 0 && 796 scan_tree(ep->ex_dirl, saddr) == 0))) { 797 if (bad) { 798 if (!svc_sendreply(transp, (xdrproc_t)xdr_long, 799 (caddr_t)&bad)) 800 syslog(LOG_ERR, "can't send reply"); 801 sigprocmask(SIG_UNBLOCK, &sighup_mask, NULL); 802 return; 803 } 804 if (hostset & DP_HOSTSET) 805 fhr.fhr_flag = hostset; 806 else 807 fhr.fhr_flag = defset; 808 fhr.fhr_vers = rqstp->rq_vers; 809 /* Get the file handle */ 810 memset(&fhr.fhr_fh, 0, sizeof(nfsfh_t)); 811 if (getfh(dirpath, (fhandle_t *)&fhr.fhr_fh) < 0) { 812 bad = errno; 813 syslog(LOG_ERR, "can't get fh for %s", dirpath); 814 if (!svc_sendreply(transp, (xdrproc_t)xdr_long, 815 (caddr_t)&bad)) 816 syslog(LOG_ERR, "can't send reply"); 817 sigprocmask(SIG_UNBLOCK, &sighup_mask, NULL); 818 return; 819 } 820 if (!svc_sendreply(transp, (xdrproc_t)xdr_fhs, 821 (caddr_t)&fhr)) 822 syslog(LOG_ERR, "can't send reply"); 823 if (!lookup_failed) 824 add_mlist(host, dirpath); 825 else 826 add_mlist(numerichost, dirpath); 827 if (debug) 828 warnx("mount successful"); 829 if (dolog) 830 syslog(LOG_NOTICE, 831 "mount request succeeded from %s for %s", 832 numerichost, dirpath); 833 } else { 834 bad = EACCES; 835 syslog(LOG_NOTICE, 836 "mount request denied from %s for %s", 837 numerichost, dirpath); 838 } 839 840 if (bad && !svc_sendreply(transp, (xdrproc_t)xdr_long, 841 (caddr_t)&bad)) 842 syslog(LOG_ERR, "can't send reply"); 843 sigprocmask(SIG_UNBLOCK, &sighup_mask, NULL); 844 return; 845 case RPCMNT_DUMP: 846 if (!svc_sendreply(transp, (xdrproc_t)xdr_mlist, (caddr_t)NULL)) 847 syslog(LOG_ERR, "can't send reply"); 848 else if (dolog) 849 syslog(LOG_NOTICE, 850 "dump request succeeded from %s", 851 numerichost); 852 return; 853 case RPCMNT_UMOUNT: 854 if (sport >= IPPORT_RESERVED && resvport_only) { 855 syslog(LOG_NOTICE, 856 "umount request from %s from unprivileged port", 857 numerichost); 858 svcerr_weakauth(transp); 859 return; 860 } 861 if (!svc_getargs(transp, (xdrproc_t)xdr_dir, rpcpath)) { 862 syslog(LOG_NOTICE, "undecodable umount request from %s", 863 numerichost); 864 svcerr_decode(transp); 865 return; 866 } 867 if (realpath(rpcpath, dirpath) == NULL) { 868 syslog(LOG_NOTICE, "umount request from %s " 869 "for non existent path %s", 870 numerichost, dirpath); 871 } 872 if (!svc_sendreply(transp, (xdrproc_t)xdr_void, (caddr_t)NULL)) 873 syslog(LOG_ERR, "can't send reply"); 874 if (!lookup_failed) 875 del_mlist(host, dirpath); 876 del_mlist(numerichost, dirpath); 877 if (dolog) 878 syslog(LOG_NOTICE, 879 "umount request succeeded from %s for %s", 880 numerichost, dirpath); 881 return; 882 case RPCMNT_UMNTALL: 883 if (sport >= IPPORT_RESERVED && resvport_only) { 884 syslog(LOG_NOTICE, 885 "umountall request from %s from unprivileged port", 886 numerichost); 887 svcerr_weakauth(transp); 888 return; 889 } 890 if (!svc_sendreply(transp, (xdrproc_t)xdr_void, (caddr_t)NULL)) 891 syslog(LOG_ERR, "can't send reply"); 892 if (!lookup_failed) 893 del_mlist(host, NULL); 894 del_mlist(numerichost, NULL); 895 if (dolog) 896 syslog(LOG_NOTICE, 897 "umountall request succeeded from %s", 898 numerichost); 899 return; 900 case RPCMNT_EXPORT: 901 if (!svc_sendreply(transp, (xdrproc_t)xdr_explist, (caddr_t)NULL)) 902 if (!svc_sendreply(transp, (xdrproc_t)xdr_explist_brief, 903 (caddr_t)NULL)) 904 syslog(LOG_ERR, "can't send reply"); 905 if (dolog) 906 syslog(LOG_NOTICE, 907 "export request succeeded from %s", 908 numerichost); 909 return; 910 default: 911 svcerr_noproc(transp); 912 return; 913 } 914} 915 916/* 917 * Xdr conversion for a dirpath string 918 */ 919int 920xdr_dir(xdrsp, dirp) 921 XDR *xdrsp; 922 char *dirp; 923{ 924 return (xdr_string(xdrsp, &dirp, RPCMNT_PATHLEN)); 925} 926 927/* 928 * Xdr routine to generate file handle reply 929 */ 930int 931xdr_fhs(xdrsp, cp) 932 XDR *xdrsp; 933 caddr_t cp; 934{ 935 struct fhreturn *fhrp = (struct fhreturn *)cp; 936 u_long ok = 0, len, auth; 937 938 if (!xdr_long(xdrsp, &ok)) 939 return (0); 940 switch (fhrp->fhr_vers) { 941 case 1: 942 return (xdr_opaque(xdrsp, (caddr_t)&fhrp->fhr_fh, NFSX_V2FH)); 943 case 3: 944 len = NFSX_V3FH; 945 if (!xdr_long(xdrsp, &len)) 946 return (0); 947 if (!xdr_opaque(xdrsp, (caddr_t)&fhrp->fhr_fh, len)) 948 return (0); 949 auth = RPCAUTH_UNIX; 950 len = 1; 951 if (!xdr_long(xdrsp, &len)) 952 return (0); 953 return (xdr_long(xdrsp, &auth)); 954 }; 955 return (0); 956} 957 958int 959xdr_mlist(xdrsp, cp) 960 XDR *xdrsp; 961 caddr_t cp; 962{ 963 struct mountlist *mlp; 964 int true = 1; 965 int false = 0; 966 char *strp; 967 968 mlp = mlhead; 969 while (mlp) { 970 if (!xdr_bool(xdrsp, &true)) 971 return (0); 972 strp = &mlp->ml_host[0]; 973 if (!xdr_string(xdrsp, &strp, RPCMNT_NAMELEN)) 974 return (0); 975 strp = &mlp->ml_dirp[0]; 976 if (!xdr_string(xdrsp, &strp, RPCMNT_PATHLEN)) 977 return (0); 978 mlp = mlp->ml_next; 979 } 980 if (!xdr_bool(xdrsp, &false)) 981 return (0); 982 return (1); 983} 984 985/* 986 * Xdr conversion for export list 987 */ 988int 989xdr_explist_common(xdrsp, cp, brief) 990 XDR *xdrsp; 991 caddr_t cp; 992 int brief; 993{ 994 struct exportlist *ep; 995 int false = 0; 996 int putdef; 997 sigset_t sighup_mask; 998 999 sigemptyset(&sighup_mask); 1000 sigaddset(&sighup_mask, SIGHUP); 1001 sigprocmask(SIG_BLOCK, &sighup_mask, NULL); 1002 ep = exphead; 1003 while (ep) { 1004 putdef = 0; 1005 if (put_exlist(ep->ex_dirl, xdrsp, ep->ex_defdir, 1006 &putdef, brief)) 1007 goto errout; 1008 if (ep->ex_defdir && putdef == 0 && 1009 put_exlist(ep->ex_defdir, xdrsp, (struct dirlist *)NULL, 1010 &putdef, brief)) 1011 goto errout; 1012 ep = ep->ex_next; 1013 } 1014 sigprocmask(SIG_UNBLOCK, &sighup_mask, NULL); 1015 if (!xdr_bool(xdrsp, &false)) 1016 return (0); 1017 return (1); 1018errout: 1019 sigprocmask(SIG_UNBLOCK, &sighup_mask, NULL); 1020 return (0); 1021} 1022 1023/* 1024 * Called from xdr_explist() to traverse the tree and export the 1025 * directory paths. 1026 */ 1027int 1028put_exlist(dp, xdrsp, adp, putdefp, brief) 1029 struct dirlist *dp; 1030 XDR *xdrsp; 1031 struct dirlist *adp; 1032 int *putdefp; 1033 int brief; 1034{ 1035 struct grouplist *grp; 1036 struct hostlist *hp; 1037 int true = 1; 1038 int false = 0; 1039 int gotalldir = 0; 1040 char *strp; 1041 1042 if (dp) { 1043 if (put_exlist(dp->dp_left, xdrsp, adp, putdefp, brief)) 1044 return (1); 1045 if (!xdr_bool(xdrsp, &true)) 1046 return (1); 1047 strp = dp->dp_dirp; 1048 if (!xdr_string(xdrsp, &strp, RPCMNT_PATHLEN)) 1049 return (1); 1050 if (adp && !strcmp(dp->dp_dirp, adp->dp_dirp)) { 1051 gotalldir = 1; 1052 *putdefp = 1; 1053 } 1054 if (brief) { 1055 if (!xdr_bool(xdrsp, &true)) 1056 return (1); 1057 strp = "(...)"; 1058 if (!xdr_string(xdrsp, &strp, RPCMNT_PATHLEN)) 1059 return (1); 1060 } else if ((dp->dp_flag & DP_DEFSET) == 0 && 1061 (gotalldir == 0 || (adp->dp_flag & DP_DEFSET) == 0)) { 1062 hp = dp->dp_hosts; 1063 while (hp) { 1064 grp = hp->ht_grp; 1065 if (grp->gr_type == GT_HOST) { 1066 if (!xdr_bool(xdrsp, &true)) 1067 return (1); 1068 strp = grp->gr_ptr.gt_addrinfo->ai_canonname; 1069 if (!xdr_string(xdrsp, &strp, 1070 RPCMNT_NAMELEN)) 1071 return (1); 1072 } else if (grp->gr_type == GT_NET) { 1073 if (!xdr_bool(xdrsp, &true)) 1074 return (1); 1075 strp = grp->gr_ptr.gt_net.nt_name; 1076 if (!xdr_string(xdrsp, &strp, 1077 RPCMNT_NAMELEN)) 1078 return (1); 1079 } 1080 hp = hp->ht_next; 1081 if (gotalldir && hp == (struct hostlist *)NULL) { 1082 hp = adp->dp_hosts; 1083 gotalldir = 0; 1084 } 1085 } 1086 } 1087 if (!xdr_bool(xdrsp, &false)) 1088 return (1); 1089 if (put_exlist(dp->dp_right, xdrsp, adp, putdefp, brief)) 1090 return (1); 1091 } 1092 return (0); 1093} 1094 1095int 1096xdr_explist(xdrsp, cp) 1097 XDR *xdrsp; 1098 caddr_t cp; 1099{ 1100 1101 return xdr_explist_common(xdrsp, cp, 0); 1102} 1103 1104int 1105xdr_explist_brief(xdrsp, cp) 1106 XDR *xdrsp; 1107 caddr_t cp; 1108{ 1109 1110 return xdr_explist_common(xdrsp, cp, 1); 1111} 1112 1113char *line; 1114int linesize; 1115FILE *exp_file; 1116 1117/* 1118 * Get the export list from one, currently open file 1119 */ 1120static void 1121get_exportlist_one() 1122{ 1123 struct exportlist *ep, *ep2; 1124 struct grouplist *grp, *tgrp; 1125 struct exportlist **epp; 1126 struct dirlist *dirhead; 1127 struct statfs fsb; 1128 struct xucred anon; 1129 char *cp, *endcp, *dirp, *hst, *usr, *dom, savedc; 1130 int len, has_host, exflags, got_nondir, dirplen, netgrp; 1131 1132 dirhead = (struct dirlist *)NULL; 1133 while (get_line()) { 1134 if (debug) 1135 warnx("got line %s", line); 1136 cp = line; 1137 nextfield(&cp, &endcp); 1138 if (*cp == '#') 1139 goto nextline; 1140 1141 /* 1142 * Set defaults. 1143 */ 1144 has_host = FALSE; 1145 anon = def_anon; 1146 exflags = MNT_EXPORTED; 1147 got_nondir = 0; 1148 opt_flags = 0; 1149 ep = (struct exportlist *)NULL; 1150 1151 /* 1152 * Create new exports list entry 1153 */ 1154 len = endcp-cp; 1155 tgrp = grp = get_grp(); 1156 while (len > 0) { 1157 if (len > RPCMNT_NAMELEN) { 1158 getexp_err(ep, tgrp); 1159 goto nextline; 1160 } 1161 if (*cp == '-') { 1162 if (ep == (struct exportlist *)NULL) { 1163 getexp_err(ep, tgrp); 1164 goto nextline; 1165 } 1166 if (debug) 1167 warnx("doing opt %s", cp); 1168 got_nondir = 1; 1169 if (do_opt(&cp, &endcp, ep, grp, &has_host, 1170 &exflags, &anon)) { 1171 getexp_err(ep, tgrp); 1172 goto nextline; 1173 } 1174 } else if (*cp == '/') { 1175 savedc = *endcp; 1176 *endcp = '\0'; 1177 if (check_dirpath(cp) && 1178 statfs(cp, &fsb) >= 0) { 1179 if (got_nondir) { 1180 syslog(LOG_ERR, "dirs must be first"); 1181 getexp_err(ep, tgrp); 1182 goto nextline; 1183 } 1184 if (ep) { 1185 if (ep->ex_fs.val[0] != fsb.f_fsid.val[0] || 1186 ep->ex_fs.val[1] != fsb.f_fsid.val[1]) { 1187 getexp_err(ep, tgrp); 1188 goto nextline; 1189 } 1190 } else { 1191 /* 1192 * See if this directory is already 1193 * in the list. 1194 */ 1195 ep = ex_search(&fsb.f_fsid); 1196 if (ep == (struct exportlist *)NULL) { 1197 ep = get_exp(); 1198 ep->ex_fs = fsb.f_fsid; 1199 ep->ex_fsdir = (char *) 1200 malloc(strlen(fsb.f_mntonname) + 1); 1201 if (ep->ex_fsdir) 1202 strcpy(ep->ex_fsdir, 1203 fsb.f_mntonname); 1204 else 1205 out_of_mem(); 1206 if (debug) 1207 warnx("making new ep fs=0x%x,0x%x", 1208 fsb.f_fsid.val[0], 1209 fsb.f_fsid.val[1]); 1210 } else if (debug) 1211 warnx("found ep fs=0x%x,0x%x", 1212 fsb.f_fsid.val[0], 1213 fsb.f_fsid.val[1]); 1214 } 1215 1216 /* 1217 * Add dirpath to export mount point. 1218 */ 1219 dirp = add_expdir(&dirhead, cp, len); 1220 dirplen = len; 1221 } else { 1222 getexp_err(ep, tgrp); 1223 goto nextline; 1224 } 1225 *endcp = savedc; 1226 } else { 1227 savedc = *endcp; 1228 *endcp = '\0'; 1229 got_nondir = 1; 1230 if (ep == (struct exportlist *)NULL) { 1231 getexp_err(ep, tgrp); 1232 goto nextline; 1233 } 1234 1235 /* 1236 * Get the host or netgroup. 1237 */ 1238 setnetgrent(cp); 1239 netgrp = getnetgrent(&hst, &usr, &dom); 1240 do { 1241 if (has_host) { 1242 grp->gr_next = get_grp(); 1243 grp = grp->gr_next; 1244 } 1245 if (netgrp) { 1246 if (hst == 0) { 1247 syslog(LOG_ERR, 1248 "null hostname in netgroup %s, skipping", cp); 1249 grp->gr_type = GT_IGNORE; 1250 } else if (get_host(hst, grp, tgrp)) { 1251 syslog(LOG_ERR, 1252 "bad host %s in netgroup %s, skipping", hst, cp); 1253 grp->gr_type = GT_IGNORE; 1254 } 1255 } else if (get_host(cp, grp, tgrp)) { 1256 syslog(LOG_ERR, "bad host %s, skipping", cp); 1257 grp->gr_type = GT_IGNORE; 1258 } 1259 has_host = TRUE; 1260 } while (netgrp && getnetgrent(&hst, &usr, &dom)); 1261 endnetgrent(); 1262 *endcp = savedc; 1263 } 1264 cp = endcp; 1265 nextfield(&cp, &endcp); 1266 len = endcp - cp; 1267 } 1268 if (check_options(dirhead)) { 1269 getexp_err(ep, tgrp); 1270 goto nextline; 1271 } 1272 if (!has_host) { 1273 grp->gr_type = GT_DEFAULT; 1274 if (debug) 1275 warnx("adding a default entry"); 1276 1277 /* 1278 * Don't allow a network export coincide with a list of 1279 * host(s) on the same line. 1280 */ 1281 } else if ((opt_flags & OP_NET) && tgrp->gr_next) { 1282 syslog(LOG_ERR, "network/host conflict"); 1283 getexp_err(ep, tgrp); 1284 goto nextline; 1285 1286 /* 1287 * If an export list was specified on this line, make sure 1288 * that we have at least one valid entry, otherwise skip it. 1289 */ 1290 } else { 1291 grp = tgrp; 1292 while (grp && grp->gr_type == GT_IGNORE) 1293 grp = grp->gr_next; 1294 if (! grp) { 1295 getexp_err(ep, tgrp); 1296 goto nextline; 1297 } 1298 } 1299 1300 /* 1301 * Loop through hosts, pushing the exports into the kernel. 1302 * After loop, tgrp points to the start of the list and 1303 * grp points to the last entry in the list. 1304 */ 1305 grp = tgrp; 1306 do { 1307 if (do_mount(ep, grp, exflags, &anon, dirp, dirplen, 1308 &fsb)) { 1309 getexp_err(ep, tgrp); 1310 goto nextline; 1311 } 1312 } while (grp->gr_next && (grp = grp->gr_next)); 1313 1314 /* 1315 * Success. Update the data structures. 1316 */ 1317 if (has_host) { 1318 hang_dirp(dirhead, tgrp, ep, opt_flags); 1319 grp->gr_next = grphead; 1320 grphead = tgrp; 1321 } else { 1322 hang_dirp(dirhead, (struct grouplist *)NULL, ep, 1323 opt_flags); 1324 free_grp(grp); 1325 } 1326 dirhead = (struct dirlist *)NULL; 1327 if ((ep->ex_flag & EX_LINKED) == 0) { 1328 ep2 = exphead; 1329 epp = &exphead; 1330 1331 /* 1332 * Insert in the list in alphabetical order. 1333 */ 1334 while (ep2 && strcmp(ep2->ex_fsdir, ep->ex_fsdir) < 0) { 1335 epp = &ep2->ex_next; 1336 ep2 = ep2->ex_next; 1337 } 1338 if (ep2) 1339 ep->ex_next = ep2; 1340 *epp = ep; 1341 ep->ex_flag |= EX_LINKED; 1342 } 1343nextline: 1344 if (dirhead) { 1345 free_dir(dirhead); 1346 dirhead = (struct dirlist *)NULL; 1347 } 1348 } 1349} 1350 1351/* 1352 * Get the export list from all specified files 1353 */ 1354void 1355get_exportlist() 1356{ 1357 struct exportlist *ep, *ep2; 1358 struct grouplist *grp, *tgrp; 1359 struct export_args export; 1360 struct iovec *iov; 1361 struct statfs *fsp, *mntbufp; 1362 struct xvfsconf vfc; 1363 char *dirp; 1364 char errmsg[255]; 1365 int dirplen, num, i; 1366 int iovlen; 1367 int done; 1368 1369 bzero(&export, sizeof(export)); 1370 export.ex_flags = MNT_DELEXPORT; 1371 dirp = NULL; 1372 dirplen = 0; 1373 iov = NULL; 1374 iovlen = 0; 1375 bzero(errmsg, sizeof(errmsg)); 1376 1377 /* 1378 * First, get rid of the old list 1379 */ 1380 ep = exphead; 1381 while (ep) { 1382 ep2 = ep; 1383 ep = ep->ex_next; 1384 free_exp(ep2); 1385 } 1386 exphead = (struct exportlist *)NULL; 1387 1388 grp = grphead; 1389 while (grp) { 1390 tgrp = grp; 1391 grp = grp->gr_next; 1392 free_grp(tgrp); 1393 } 1394 grphead = (struct grouplist *)NULL; 1395 1396 /* 1397 * And delete exports that are in the kernel for all local 1398 * filesystems. 1399 * XXX: Should know how to handle all local exportable filesystems. 1400 */ 1401 num = getmntinfo(&mntbufp, MNT_NOWAIT); 1402 1403 if (num > 0) { 1404 build_iovec(&iov, &iovlen, "fstype", NULL, 0); 1405 build_iovec(&iov, &iovlen, "fspath", NULL, 0); 1406 build_iovec(&iov, &iovlen, "from", NULL, 0); 1407 build_iovec(&iov, &iovlen, "update", NULL, 0); 1408 build_iovec(&iov, &iovlen, "export", &export, sizeof(export)); 1409 build_iovec(&iov, &iovlen, "errmsg", errmsg, sizeof(errmsg)); 1410 } 1411 1412 for (i = 0; i < num; i++) { 1413 fsp = &mntbufp[i]; 1414 if (getvfsbyname(fsp->f_fstypename, &vfc) != 0) { 1415 syslog(LOG_ERR, "getvfsbyname() failed for %s", 1416 fsp->f_fstypename); 1417 continue; 1418 } 1419 1420 /* 1421 * Do not delete export for network filesystem by 1422 * passing "export" arg to nmount(). 1423 * It only makes sense to do this for local filesystems. 1424 */ 1425 if (vfc.vfc_flags & VFCF_NETWORK) 1426 continue; 1427 1428 iov[1].iov_base = fsp->f_fstypename; 1429 iov[1].iov_len = strlen(fsp->f_fstypename) + 1; 1430 iov[3].iov_base = fsp->f_mntonname; 1431 iov[3].iov_len = strlen(fsp->f_mntonname) + 1; 1432 iov[5].iov_base = fsp->f_mntfromname; 1433 iov[5].iov_len = strlen(fsp->f_mntfromname) + 1; 1434 1435 /* 1436 * Kick out MNT_ROOTFS. It should not be passed from 1437 * userland to kernel. It should only be used 1438 * internally in the kernel. 1439 */ 1440 if (fsp->f_flags & MNT_ROOTFS) { 1441 fsp->f_flags &= ~MNT_ROOTFS; 1442 } 1443 1444 if (nmount(iov, iovlen, fsp->f_flags) < 0 && 1445 errno != ENOENT && errno != ENOTSUP) { 1446 syslog(LOG_ERR, 1447 "can't delete exports for %s: %m %s", 1448 fsp->f_mntonname, errmsg); 1449 } 1450 } 1451 1452 if (iov != NULL) { 1453 /* Free strings allocated by strdup() in getmntopts.c */ 1454 free(iov[0].iov_base); /* fstype */ 1455 free(iov[2].iov_base); /* fspath */ 1456 free(iov[4].iov_base); /* from */ 1457 free(iov[6].iov_base); /* update */ 1458 free(iov[8].iov_base); /* export */ 1459 free(iov[10].iov_base); /* errmsg */ 1460 1461 /* free iov, allocated by realloc() */ 1462 free(iov); 1463 iovlen = 0; 1464 } 1465 1466 /* 1467 * Read in the exports file and build the list, calling 1468 * nmount() as we go along to push the export rules into the kernel. 1469 */ 1470 done = 0; 1471 for (i = 0; exnames[i] != NULL; i++) { 1472 if (debug) 1473 warnx("reading exports from %s", exnames[i]); 1474 if ((exp_file = fopen(exnames[i], "r")) == NULL) { 1475 syslog(LOG_WARNING, "can't open %s", exnames[i]); 1476 continue; 1477 } 1478 get_exportlist_one(); 1479 fclose(exp_file); 1480 done++; 1481 } 1482 if (done == 0) { 1483 syslog(LOG_ERR, "can't open any exports file"); 1484 exit(2); 1485 } 1486} 1487 1488/* 1489 * Allocate an export list element 1490 */ 1491struct exportlist * 1492get_exp() 1493{ 1494 struct exportlist *ep; 1495 1496 ep = (struct exportlist *)malloc(sizeof (struct exportlist)); 1497 if (ep == (struct exportlist *)NULL) 1498 out_of_mem(); 1499 memset(ep, 0, sizeof(struct exportlist)); 1500 return (ep); 1501} 1502 1503/* 1504 * Allocate a group list element 1505 */ 1506struct grouplist * 1507get_grp() 1508{ 1509 struct grouplist *gp; 1510 1511 gp = (struct grouplist *)malloc(sizeof (struct grouplist)); 1512 if (gp == (struct grouplist *)NULL) 1513 out_of_mem(); 1514 memset(gp, 0, sizeof(struct grouplist)); 1515 return (gp); 1516} 1517 1518/* 1519 * Clean up upon an error in get_exportlist(). 1520 */ 1521void 1522getexp_err(ep, grp) 1523 struct exportlist *ep; 1524 struct grouplist *grp; 1525{ 1526 struct grouplist *tgrp; 1527 1528 if (!(opt_flags & OP_QUIET)) 1529 syslog(LOG_ERR, "bad exports list line %s", line); 1530 if (ep && (ep->ex_flag & EX_LINKED) == 0) 1531 free_exp(ep); 1532 while (grp) { 1533 tgrp = grp; 1534 grp = grp->gr_next; 1535 free_grp(tgrp); 1536 } 1537} 1538 1539/* 1540 * Search the export list for a matching fs. 1541 */ 1542struct exportlist * 1543ex_search(fsid) 1544 fsid_t *fsid; 1545{ 1546 struct exportlist *ep; 1547 1548 ep = exphead; 1549 while (ep) { 1550 if (ep->ex_fs.val[0] == fsid->val[0] && 1551 ep->ex_fs.val[1] == fsid->val[1]) 1552 return (ep); 1553 ep = ep->ex_next; 1554 } 1555 return (ep); 1556} 1557 1558/* 1559 * Add a directory path to the list. 1560 */ 1561char * 1562add_expdir(dpp, cp, len) 1563 struct dirlist **dpp; 1564 char *cp; 1565 int len; 1566{ 1567 struct dirlist *dp; 1568 1569 dp = (struct dirlist *)malloc(sizeof (struct dirlist) + len); 1570 if (dp == (struct dirlist *)NULL) 1571 out_of_mem(); 1572 dp->dp_left = *dpp; 1573 dp->dp_right = (struct dirlist *)NULL; 1574 dp->dp_flag = 0; 1575 dp->dp_hosts = (struct hostlist *)NULL; 1576 strcpy(dp->dp_dirp, cp); 1577 *dpp = dp; 1578 return (dp->dp_dirp); 1579} 1580 1581/* 1582 * Hang the dir list element off the dirpath binary tree as required 1583 * and update the entry for host. 1584 */ 1585void 1586hang_dirp(dp, grp, ep, flags) 1587 struct dirlist *dp; 1588 struct grouplist *grp; 1589 struct exportlist *ep; 1590 int flags; 1591{ 1592 struct hostlist *hp; 1593 struct dirlist *dp2; 1594 1595 if (flags & OP_ALLDIRS) { 1596 if (ep->ex_defdir) 1597 free((caddr_t)dp); 1598 else 1599 ep->ex_defdir = dp; 1600 if (grp == (struct grouplist *)NULL) { 1601 ep->ex_defdir->dp_flag |= DP_DEFSET; 1602 } else while (grp) { 1603 hp = get_ht(); 1604 hp->ht_grp = grp; 1605 hp->ht_next = ep->ex_defdir->dp_hosts; 1606 ep->ex_defdir->dp_hosts = hp; 1607 grp = grp->gr_next; 1608 } 1609 } else { 1610 1611 /* 1612 * Loop through the directories adding them to the tree. 1613 */ 1614 while (dp) { 1615 dp2 = dp->dp_left; 1616 add_dlist(&ep->ex_dirl, dp, grp, flags); 1617 dp = dp2; 1618 } 1619 } 1620} 1621 1622/* 1623 * Traverse the binary tree either updating a node that is already there 1624 * for the new directory or adding the new node. 1625 */ 1626void 1627add_dlist(dpp, newdp, grp, flags) 1628 struct dirlist **dpp; 1629 struct dirlist *newdp; 1630 struct grouplist *grp; 1631 int flags; 1632{ 1633 struct dirlist *dp; 1634 struct hostlist *hp; 1635 int cmp; 1636 1637 dp = *dpp; 1638 if (dp) { 1639 cmp = strcmp(dp->dp_dirp, newdp->dp_dirp); 1640 if (cmp > 0) { 1641 add_dlist(&dp->dp_left, newdp, grp, flags); 1642 return; 1643 } else if (cmp < 0) { 1644 add_dlist(&dp->dp_right, newdp, grp, flags); 1645 return; 1646 } else 1647 free((caddr_t)newdp); 1648 } else { 1649 dp = newdp; 1650 dp->dp_left = (struct dirlist *)NULL; 1651 *dpp = dp; 1652 } 1653 if (grp) { 1654 1655 /* 1656 * Hang all of the host(s) off of the directory point. 1657 */ 1658 do { 1659 hp = get_ht(); 1660 hp->ht_grp = grp; 1661 hp->ht_next = dp->dp_hosts; 1662 dp->dp_hosts = hp; 1663 grp = grp->gr_next; 1664 } while (grp); 1665 } else { 1666 dp->dp_flag |= DP_DEFSET; 1667 } 1668} 1669 1670/* 1671 * Search for a dirpath on the export point. 1672 */ 1673struct dirlist * 1674dirp_search(dp, dirp) 1675 struct dirlist *dp; 1676 char *dirp; 1677{ 1678 int cmp; 1679 1680 if (dp) { 1681 cmp = strcmp(dp->dp_dirp, dirp); 1682 if (cmp > 0) 1683 return (dirp_search(dp->dp_left, dirp)); 1684 else if (cmp < 0) 1685 return (dirp_search(dp->dp_right, dirp)); 1686 else 1687 return (dp); 1688 } 1689 return (dp); 1690} 1691 1692/* 1693 * Scan for a host match in a directory tree. 1694 */ 1695int 1696chk_host(dp, saddr, defsetp, hostsetp) 1697 struct dirlist *dp; 1698 struct sockaddr *saddr; 1699 int *defsetp; 1700 int *hostsetp; 1701{ 1702 struct hostlist *hp; 1703 struct grouplist *grp; 1704 struct addrinfo *ai; 1705 1706 if (dp) { 1707 if (dp->dp_flag & DP_DEFSET) 1708 *defsetp = dp->dp_flag; 1709 hp = dp->dp_hosts; 1710 while (hp) { 1711 grp = hp->ht_grp; 1712 switch (grp->gr_type) { 1713 case GT_HOST: 1714 ai = grp->gr_ptr.gt_addrinfo; 1715 for (; ai; ai = ai->ai_next) { 1716 if (!sacmp(ai->ai_addr, saddr, NULL)) { 1717 *hostsetp = 1718 (hp->ht_flag | DP_HOSTSET); 1719 return (1); 1720 } 1721 } 1722 break; 1723 case GT_NET: 1724 if (!sacmp(saddr, (struct sockaddr *) 1725 &grp->gr_ptr.gt_net.nt_net, 1726 (struct sockaddr *) 1727 &grp->gr_ptr.gt_net.nt_mask)) { 1728 *hostsetp = (hp->ht_flag | DP_HOSTSET); 1729 return (1); 1730 } 1731 break; 1732 } 1733 hp = hp->ht_next; 1734 } 1735 } 1736 return (0); 1737} 1738 1739/* 1740 * Scan tree for a host that matches the address. 1741 */ 1742int 1743scan_tree(dp, saddr) 1744 struct dirlist *dp; 1745 struct sockaddr *saddr; 1746{ 1747 int defset, hostset; 1748 1749 if (dp) { 1750 if (scan_tree(dp->dp_left, saddr)) 1751 return (1); 1752 if (chk_host(dp, saddr, &defset, &hostset)) 1753 return (1); 1754 if (scan_tree(dp->dp_right, saddr)) 1755 return (1); 1756 } 1757 return (0); 1758} 1759 1760/* 1761 * Traverse the dirlist tree and free it up. 1762 */ 1763void 1764free_dir(dp) 1765 struct dirlist *dp; 1766{ 1767 1768 if (dp) { 1769 free_dir(dp->dp_left); 1770 free_dir(dp->dp_right); 1771 free_host(dp->dp_hosts); 1772 free((caddr_t)dp); 1773 } 1774} 1775 1776/* 1777 * Parse the option string and update fields. 1778 * Option arguments may either be -<option>=<value> or 1779 * -<option> <value> 1780 */ 1781int 1782do_opt(cpp, endcpp, ep, grp, has_hostp, exflagsp, cr) 1783 char **cpp, **endcpp; 1784 struct exportlist *ep; 1785 struct grouplist *grp; 1786 int *has_hostp; 1787 int *exflagsp; 1788 struct xucred *cr; 1789{ 1790 char *cpoptarg, *cpoptend; 1791 char *cp, *endcp, *cpopt, savedc, savedc2; 1792 int allflag, usedarg; 1793 1794 savedc2 = '\0'; 1795 cpopt = *cpp; 1796 cpopt++; 1797 cp = *endcpp; 1798 savedc = *cp; 1799 *cp = '\0'; 1800 while (cpopt && *cpopt) { 1801 allflag = 1; 1802 usedarg = -2; 1803 if ((cpoptend = strchr(cpopt, ','))) { 1804 *cpoptend++ = '\0'; 1805 if ((cpoptarg = strchr(cpopt, '='))) 1806 *cpoptarg++ = '\0'; 1807 } else { 1808 if ((cpoptarg = strchr(cpopt, '='))) 1809 *cpoptarg++ = '\0'; 1810 else { 1811 *cp = savedc; 1812 nextfield(&cp, &endcp); 1813 **endcpp = '\0'; 1814 if (endcp > cp && *cp != '-') { 1815 cpoptarg = cp; 1816 savedc2 = *endcp; 1817 *endcp = '\0'; 1818 usedarg = 0; 1819 } 1820 } 1821 } 1822 if (!strcmp(cpopt, "ro") || !strcmp(cpopt, "o")) { 1823 *exflagsp |= MNT_EXRDONLY; 1824 } else if (cpoptarg && (!strcmp(cpopt, "maproot") || 1825 !(allflag = strcmp(cpopt, "mapall")) || 1826 !strcmp(cpopt, "root") || !strcmp(cpopt, "r"))) { 1827 usedarg++; 1828 parsecred(cpoptarg, cr); 1829 if (allflag == 0) { 1830 *exflagsp |= MNT_EXPORTANON; 1831 opt_flags |= OP_MAPALL; 1832 } else 1833 opt_flags |= OP_MAPROOT; 1834 } else if (cpoptarg && (!strcmp(cpopt, "mask") || 1835 !strcmp(cpopt, "m"))) { 1836 if (get_net(cpoptarg, &grp->gr_ptr.gt_net, 1)) { 1837 syslog(LOG_ERR, "bad mask: %s", cpoptarg); 1838 return (1); 1839 } 1840 usedarg++; 1841 opt_flags |= OP_MASK; 1842 } else if (cpoptarg && (!strcmp(cpopt, "network") || 1843 !strcmp(cpopt, "n"))) { 1844 if (strchr(cpoptarg, '/') != NULL) { 1845 if (debug) 1846 fprintf(stderr, "setting OP_MASKLEN\n"); 1847 opt_flags |= OP_MASKLEN; 1848 } 1849 if (grp->gr_type != GT_NULL) { 1850 syslog(LOG_ERR, "network/host conflict"); 1851 return (1); 1852 } else if (get_net(cpoptarg, &grp->gr_ptr.gt_net, 0)) { 1853 syslog(LOG_ERR, "bad net: %s", cpoptarg); 1854 return (1); 1855 } 1856 grp->gr_type = GT_NET; 1857 *has_hostp = 1; 1858 usedarg++; 1859 opt_flags |= OP_NET; 1860 } else if (!strcmp(cpopt, "alldirs")) { 1861 opt_flags |= OP_ALLDIRS; 1862 } else if (!strcmp(cpopt, "public")) { 1863 *exflagsp |= MNT_EXPUBLIC; 1864 } else if (!strcmp(cpopt, "webnfs")) { 1865 *exflagsp |= (MNT_EXPUBLIC|MNT_EXRDONLY|MNT_EXPORTANON); 1866 opt_flags |= OP_MAPALL; 1867 } else if (cpoptarg && !strcmp(cpopt, "index")) { 1868 ep->ex_indexfile = strdup(cpoptarg); 1869 } else if (!strcmp(cpopt, "quiet")) { 1870 opt_flags |= OP_QUIET; 1871 } else { 1872 syslog(LOG_ERR, "bad opt %s", cpopt); 1873 return (1); 1874 } 1875 if (usedarg >= 0) { 1876 *endcp = savedc2; 1877 **endcpp = savedc; 1878 if (usedarg > 0) { 1879 *cpp = cp; 1880 *endcpp = endcp; 1881 } 1882 return (0); 1883 } 1884 cpopt = cpoptend; 1885 } 1886 **endcpp = savedc; 1887 return (0); 1888} 1889 1890/* 1891 * Translate a character string to the corresponding list of network 1892 * addresses for a hostname. 1893 */ 1894int 1895get_host(cp, grp, tgrp) 1896 char *cp; 1897 struct grouplist *grp; 1898 struct grouplist *tgrp; 1899{ 1900 struct grouplist *checkgrp; 1901 struct addrinfo *ai, *tai, hints; 1902 int ecode; 1903 char host[NI_MAXHOST]; 1904 1905 if (grp->gr_type != GT_NULL) { 1906 syslog(LOG_ERR, "Bad netgroup type for ip host %s", cp); 1907 return (1); 1908 } 1909 memset(&hints, 0, sizeof hints); 1910 hints.ai_flags = AI_CANONNAME; 1911 hints.ai_protocol = IPPROTO_UDP; 1912 ecode = getaddrinfo(cp, NULL, &hints, &ai); 1913 if (ecode != 0) { 1914 syslog(LOG_ERR,"can't get address info for host %s", cp); 1915 return 1; 1916 } 1917 grp->gr_ptr.gt_addrinfo = ai; 1918 while (ai != NULL) { 1919 if (ai->ai_canonname == NULL) { 1920 if (getnameinfo(ai->ai_addr, ai->ai_addrlen, host, 1921 sizeof host, NULL, 0, NI_NUMERICHOST) != 0) 1922 strlcpy(host, "?", sizeof(host)); 1923 ai->ai_canonname = strdup(host); 1924 ai->ai_flags |= AI_CANONNAME; 1925 } 1926 if (debug) 1927 fprintf(stderr, "got host %s\n", ai->ai_canonname); 1928 /* 1929 * Sanity check: make sure we don't already have an entry 1930 * for this host in the grouplist. 1931 */ 1932 for (checkgrp = tgrp; checkgrp != NULL; 1933 checkgrp = checkgrp->gr_next) { 1934 if (checkgrp->gr_type != GT_HOST) 1935 continue; 1936 for (tai = checkgrp->gr_ptr.gt_addrinfo; tai != NULL; 1937 tai = tai->ai_next) { 1938 if (sacmp(tai->ai_addr, ai->ai_addr, NULL) != 0) 1939 continue; 1940 if (debug) 1941 fprintf(stderr, 1942 "ignoring duplicate host %s\n", 1943 ai->ai_canonname); 1944 grp->gr_type = GT_IGNORE; 1945 return (0); 1946 } 1947 } 1948 ai = ai->ai_next; 1949 } 1950 grp->gr_type = GT_HOST; 1951 return (0); 1952} 1953 1954/* 1955 * Free up an exports list component 1956 */ 1957void 1958free_exp(ep) 1959 struct exportlist *ep; 1960{ 1961 1962 if (ep->ex_defdir) { 1963 free_host(ep->ex_defdir->dp_hosts); 1964 free((caddr_t)ep->ex_defdir); 1965 } 1966 if (ep->ex_fsdir) 1967 free(ep->ex_fsdir); 1968 if (ep->ex_indexfile) 1969 free(ep->ex_indexfile); 1970 free_dir(ep->ex_dirl); 1971 free((caddr_t)ep); 1972} 1973 1974/* 1975 * Free hosts. 1976 */ 1977void 1978free_host(hp) 1979 struct hostlist *hp; 1980{ 1981 struct hostlist *hp2; 1982 1983 while (hp) { 1984 hp2 = hp; 1985 hp = hp->ht_next; 1986 free((caddr_t)hp2); 1987 } 1988} 1989 1990struct hostlist * 1991get_ht() 1992{ 1993 struct hostlist *hp; 1994 1995 hp = (struct hostlist *)malloc(sizeof (struct hostlist)); 1996 if (hp == (struct hostlist *)NULL) 1997 out_of_mem(); 1998 hp->ht_next = (struct hostlist *)NULL; 1999 hp->ht_flag = 0; 2000 return (hp); 2001} 2002 2003/* 2004 * Out of memory, fatal 2005 */ 2006void 2007out_of_mem() 2008{ 2009 2010 syslog(LOG_ERR, "out of memory"); 2011 exit(2); 2012} 2013 2014/* 2015 * Do the nmount() syscall with the update flag to push the export info into 2016 * the kernel. 2017 */ 2018int 2019do_mount(struct exportlist *ep, struct grouplist *grp, int exflags, 2020 struct xucred *anoncrp, char *dirp, int dirplen, struct statfs *fsb) 2021{ 2022 struct statfs fsb1; 2023 struct addrinfo *ai; 2024 struct export_args eap; 2025 char errmsg[255]; 2026 char *cp; 2027 int done; 2028 char savedc; 2029 struct iovec *iov; 2030 int iovlen; 2031 int ret; 2032 2033 cp = NULL; 2034 savedc = '\0'; 2035 iov = NULL; 2036 iovlen = 0; 2037 ret = 0; 2038 2039 bzero(&eap, sizeof(eap)); 2040 bzero(errmsg, sizeof(errmsg)); 2041 eap.ex_flags = exflags; 2042 eap.ex_anon = *anoncrp; 2043 eap.ex_indexfile = ep->ex_indexfile; 2044 if (grp->gr_type == GT_HOST) 2045 ai = grp->gr_ptr.gt_addrinfo; 2046 else 2047 ai = NULL; 2048 done = FALSE; 2049 2050 build_iovec(&iov, &iovlen, "fstype", NULL, 0); 2051 build_iovec(&iov, &iovlen, "fspath", NULL, 0); 2052 build_iovec(&iov, &iovlen, "from", NULL, 0); 2053 build_iovec(&iov, &iovlen, "update", NULL, 0); 2054 build_iovec(&iov, &iovlen, "export", &eap, sizeof(eap)); 2055 build_iovec(&iov, &iovlen, "errmsg", errmsg, sizeof(errmsg)); 2056 2057 while (!done) { 2058 switch (grp->gr_type) { 2059 case GT_HOST: 2060 if (ai->ai_addr->sa_family == AF_INET6 && have_v6 == 0) 2061 goto skip; 2062 eap.ex_addr = ai->ai_addr; 2063 eap.ex_addrlen = ai->ai_addrlen; 2064 eap.ex_masklen = 0; 2065 break; 2066 case GT_NET: 2067 if (grp->gr_ptr.gt_net.nt_net.ss_family == AF_INET6 && 2068 have_v6 == 0) 2069 goto skip; 2070 eap.ex_addr = 2071 (struct sockaddr *)&grp->gr_ptr.gt_net.nt_net; 2072 eap.ex_addrlen = 2073 ((struct sockaddr *)&grp->gr_ptr.gt_net.nt_net)->sa_len; 2074 eap.ex_mask = 2075 (struct sockaddr *)&grp->gr_ptr.gt_net.nt_mask; 2076 eap.ex_masklen = ((struct sockaddr *)&grp->gr_ptr.gt_net.nt_mask)->sa_len; 2077 break; 2078 case GT_DEFAULT: 2079 eap.ex_addr = NULL; 2080 eap.ex_addrlen = 0; 2081 eap.ex_mask = NULL; 2082 eap.ex_masklen = 0; 2083 break; 2084 case GT_IGNORE: 2085 ret = 0; 2086 goto error_exit; 2087 break; 2088 default: 2089 syslog(LOG_ERR, "bad grouptype"); 2090 if (cp) 2091 *cp = savedc; 2092 ret = 1; 2093 goto error_exit; 2094 }; 2095 2096 /* 2097 * XXX: 2098 * Maybe I should just use the fsb->f_mntonname path instead 2099 * of looping back up the dirp to the mount point?? 2100 * Also, needs to know how to export all types of local 2101 * exportable filesystems and not just "ufs". 2102 */ 2103 iov[1].iov_base = fsb->f_fstypename; /* "fstype" */ 2104 iov[1].iov_len = strlen(fsb->f_fstypename) + 1; 2105 iov[3].iov_base = fsb->f_mntonname; /* "fspath" */ 2106 iov[3].iov_len = strlen(fsb->f_mntonname) + 1; 2107 iov[5].iov_base = fsb->f_mntfromname; /* "from" */ 2108 iov[5].iov_len = strlen(fsb->f_mntfromname) + 1; 2109 2110 /* 2111 * Remount the filesystem, but chop off the MNT_ROOTFS flag 2112 * as it is used internally (and will result in an error if 2113 * specified) 2114 */ 2115 while (nmount(iov, iovlen, fsb->f_flags & ~MNT_ROOTFS) < 0) { 2116 if (cp) 2117 *cp-- = savedc; 2118 else 2119 cp = dirp + dirplen - 1; 2120 if (opt_flags & OP_QUIET) { 2121 ret = 1; 2122 goto error_exit; 2123 } 2124 if (errno == EPERM) { 2125 if (debug) 2126 warnx("can't change attributes for %s", 2127 dirp); 2128 syslog(LOG_ERR, 2129 "can't change attributes for %s", dirp); 2130 ret = 1; 2131 goto error_exit; 2132 } 2133 if (opt_flags & OP_ALLDIRS) { 2134 if (errno == EINVAL) 2135 syslog(LOG_ERR, 2136 "-alldirs requested but %s is not a filesystem mountpoint", 2137 dirp); 2138 else 2139 syslog(LOG_ERR, 2140 "could not remount %s: %m", 2141 dirp); 2142 ret = 1; 2143 goto error_exit; 2144 } 2145 /* back up over the last component */ 2146 while (*cp == '/' && cp > dirp) 2147 cp--; 2148 while (*(cp - 1) != '/' && cp > dirp) 2149 cp--; 2150 if (cp == dirp) { 2151 if (debug) 2152 warnx("mnt unsucc"); 2153 syslog(LOG_ERR, "can't export %s %s", dirp, 2154 errmsg); 2155 ret = 1; 2156 goto error_exit; 2157 } 2158 savedc = *cp; 2159 *cp = '\0'; 2160 /* Check that we're still on the same filesystem. */ 2161 if (statfs(dirp, &fsb1) != 0 || bcmp(&fsb1.f_fsid, 2162 &fsb->f_fsid, sizeof(fsb1.f_fsid)) != 0) { 2163 *cp = savedc; 2164 syslog(LOG_ERR, "can't export %s %s", dirp, 2165 errmsg); 2166 ret = 1; 2167 goto error_exit; 2168 } 2169 } 2170skip: 2171 if (ai != NULL) 2172 ai = ai->ai_next; 2173 if (ai == NULL) 2174 done = TRUE; 2175 } 2176 if (cp) 2177 *cp = savedc; 2178error_exit: 2179 /* free strings allocated by strdup() in getmntopts.c */ 2180 if (iov != NULL) { 2181 free(iov[0].iov_base); /* fstype */ 2182 free(iov[2].iov_base); /* fspath */ 2183 free(iov[4].iov_base); /* from */ 2184 free(iov[6].iov_base); /* update */ 2185 free(iov[8].iov_base); /* export */ 2186 free(iov[10].iov_base); /* errmsg */ 2187 2188 /* free iov, allocated by realloc() */ 2189 free(iov); 2190 } 2191 return (ret); 2192} 2193 2194/* 2195 * Translate a net address. 2196 * 2197 * If `maskflg' is nonzero, then `cp' is a netmask, not a network address. 2198 */ 2199int 2200get_net(cp, net, maskflg) 2201 char *cp; 2202 struct netmsk *net; 2203 int maskflg; 2204{ 2205 struct netent *np = NULL; 2206 char *name, *p, *prefp; 2207 struct sockaddr_in sin; 2208 struct sockaddr *sa = NULL; 2209 struct addrinfo hints, *ai = NULL; 2210 char netname[NI_MAXHOST]; 2211 long preflen; 2212 2213 p = prefp = NULL; 2214 if ((opt_flags & OP_MASKLEN) && !maskflg) { 2215 p = strchr(cp, '/'); 2216 *p = '\0'; 2217 prefp = p + 1; 2218 } 2219 2220 /* 2221 * Check for a numeric address first. We wish to avoid 2222 * possible DNS lookups in getnetbyname(). 2223 */ 2224 if (isxdigit(*cp) || *cp == ':') { 2225 memset(&hints, 0, sizeof hints); 2226 /* Ensure the mask and the network have the same family. */ 2227 if (maskflg && (opt_flags & OP_NET)) 2228 hints.ai_family = net->nt_net.ss_family; 2229 else if (!maskflg && (opt_flags & OP_HAVEMASK)) 2230 hints.ai_family = net->nt_mask.ss_family; 2231 else 2232 hints.ai_family = AF_UNSPEC; 2233 hints.ai_flags = AI_NUMERICHOST; 2234 if (getaddrinfo(cp, NULL, &hints, &ai) == 0) 2235 sa = ai->ai_addr; 2236 if (sa != NULL && ai->ai_family == AF_INET) { 2237 /* 2238 * The address in `cp' is really a network address, so 2239 * use inet_network() to re-interpret this correctly. 2240 * e.g. "127.1" means 127.1.0.0, not 127.0.0.1. 2241 */ 2242 bzero(&sin, sizeof sin); 2243 sin.sin_family = AF_INET; 2244 sin.sin_len = sizeof sin; 2245 sin.sin_addr = inet_makeaddr(inet_network(cp), 0); 2246 if (debug) 2247 fprintf(stderr, "get_net: v4 addr %s\n", 2248 inet_ntoa(sin.sin_addr)); 2249 sa = (struct sockaddr *)&sin; 2250 } 2251 } 2252 if (sa == NULL && (np = getnetbyname(cp)) != NULL) { 2253 bzero(&sin, sizeof sin); 2254 sin.sin_family = AF_INET; 2255 sin.sin_len = sizeof sin; 2256 sin.sin_addr = inet_makeaddr(np->n_net, 0); 2257 sa = (struct sockaddr *)&sin; 2258 } 2259 if (sa == NULL) 2260 goto fail; 2261 2262 if (maskflg) { 2263 /* The specified sockaddr is a mask. */ 2264 if (checkmask(sa) != 0) 2265 goto fail; 2266 bcopy(sa, &net->nt_mask, sa->sa_len); 2267 opt_flags |= OP_HAVEMASK; 2268 } else { 2269 /* The specified sockaddr is a network address. */ 2270 bcopy(sa, &net->nt_net, sa->sa_len); 2271 2272 /* Get a network name for the export list. */ 2273 if (np) { 2274 name = np->n_name; 2275 } else if (getnameinfo(sa, sa->sa_len, netname, sizeof netname, 2276 NULL, 0, NI_NUMERICHOST) == 0) { 2277 name = netname; 2278 } else { 2279 goto fail; 2280 } 2281 if ((net->nt_name = strdup(name)) == NULL) 2282 out_of_mem(); 2283 2284 /* 2285 * Extract a mask from either a "/<masklen>" suffix, or 2286 * from the class of an IPv4 address. 2287 */ 2288 if (opt_flags & OP_MASKLEN) { 2289 preflen = strtol(prefp, NULL, 10); 2290 if (preflen < 0L || preflen == LONG_MAX) 2291 goto fail; 2292 bcopy(sa, &net->nt_mask, sa->sa_len); 2293 if (makemask(&net->nt_mask, (int)preflen) != 0) 2294 goto fail; 2295 opt_flags |= OP_HAVEMASK; 2296 *p = '/'; 2297 } else if (sa->sa_family == AF_INET && 2298 (opt_flags & OP_MASK) == 0) { 2299 in_addr_t addr; 2300 2301 addr = ((struct sockaddr_in *)sa)->sin_addr.s_addr; 2302 if (IN_CLASSA(addr)) 2303 preflen = 8; 2304 else if (IN_CLASSB(addr)) 2305 preflen = 16; 2306 else if (IN_CLASSC(addr)) 2307 preflen = 24; 2308 else if (IN_CLASSD(addr)) 2309 preflen = 28; 2310 else 2311 preflen = 32; /* XXX */ 2312 2313 bcopy(sa, &net->nt_mask, sa->sa_len); 2314 makemask(&net->nt_mask, (int)preflen); 2315 opt_flags |= OP_HAVEMASK; 2316 } 2317 } 2318 2319 if (ai) 2320 freeaddrinfo(ai); 2321 return 0; 2322 2323fail: 2324 if (ai) 2325 freeaddrinfo(ai); 2326 return 1; 2327} 2328 2329/* 2330 * Parse out the next white space separated field 2331 */ 2332void 2333nextfield(cp, endcp) 2334 char **cp; 2335 char **endcp; 2336{ 2337 char *p; 2338 2339 p = *cp; 2340 while (*p == ' ' || *p == '\t') 2341 p++; 2342 if (*p == '\n' || *p == '\0') 2343 *cp = *endcp = p; 2344 else { 2345 *cp = p++; 2346 while (*p != ' ' && *p != '\t' && *p != '\n' && *p != '\0') 2347 p++; 2348 *endcp = p; 2349 } 2350} 2351 2352/* 2353 * Get an exports file line. Skip over blank lines and handle line 2354 * continuations. 2355 */ 2356int 2357get_line() 2358{ 2359 char *p, *cp; 2360 size_t len; 2361 int totlen, cont_line; 2362 2363 /* 2364 * Loop around ignoring blank lines and getting all continuation lines. 2365 */ 2366 p = line; 2367 totlen = 0; 2368 do { 2369 if ((p = fgetln(exp_file, &len)) == NULL) 2370 return (0); 2371 cp = p + len - 1; 2372 cont_line = 0; 2373 while (cp >= p && 2374 (*cp == ' ' || *cp == '\t' || *cp == '\n' || *cp == '\\')) { 2375 if (*cp == '\\') 2376 cont_line = 1; 2377 cp--; 2378 len--; 2379 } 2380 if (cont_line) { 2381 *++cp = ' '; 2382 len++; 2383 } 2384 if (linesize < len + totlen + 1) { 2385 linesize = len + totlen + 1; 2386 line = realloc(line, linesize); 2387 if (line == NULL) 2388 out_of_mem(); 2389 } 2390 memcpy(line + totlen, p, len); 2391 totlen += len; 2392 line[totlen] = '\0'; 2393 } while (totlen == 0 || cont_line); 2394 return (1); 2395} 2396 2397/* 2398 * Parse a description of a credential. 2399 */ 2400void 2401parsecred(namelist, cr) 2402 char *namelist; 2403 struct xucred *cr; 2404{ 2405 char *name; 2406 int cnt; 2407 char *names; 2408 struct passwd *pw; 2409 struct group *gr; 2410 gid_t groups[NGROUPS + 1]; 2411 int ngroups; 2412 2413 cr->cr_version = XUCRED_VERSION; 2414 /* 2415 * Set up the unprivileged user. 2416 */ 2417 cr->cr_uid = -2; 2418 cr->cr_groups[0] = -2; 2419 cr->cr_ngroups = 1; 2420 /* 2421 * Get the user's password table entry. 2422 */ 2423 names = strsep(&namelist, " \t\n"); 2424 name = strsep(&names, ":"); 2425 if (isdigit(*name) || *name == '-') 2426 pw = getpwuid(atoi(name)); 2427 else 2428 pw = getpwnam(name); 2429 /* 2430 * Credentials specified as those of a user. 2431 */ 2432 if (names == NULL) { 2433 if (pw == NULL) { 2434 syslog(LOG_ERR, "unknown user: %s", name); 2435 return; 2436 } 2437 cr->cr_uid = pw->pw_uid; 2438 ngroups = NGROUPS + 1; 2439 if (getgrouplist(pw->pw_name, pw->pw_gid, groups, &ngroups)) 2440 syslog(LOG_ERR, "too many groups"); 2441 /* 2442 * Compress out duplicate. 2443 */ 2444 cr->cr_ngroups = ngroups - 1; 2445 cr->cr_groups[0] = groups[0]; 2446 for (cnt = 2; cnt < ngroups; cnt++) 2447 cr->cr_groups[cnt - 1] = groups[cnt]; 2448 return; 2449 } 2450 /* 2451 * Explicit credential specified as a colon separated list: 2452 * uid:gid:gid:... 2453 */ 2454 if (pw != NULL) 2455 cr->cr_uid = pw->pw_uid; 2456 else if (isdigit(*name) || *name == '-') 2457 cr->cr_uid = atoi(name); 2458 else { 2459 syslog(LOG_ERR, "unknown user: %s", name); 2460 return; 2461 } 2462 cr->cr_ngroups = 0; 2463 while (names != NULL && *names != '\0' && cr->cr_ngroups < NGROUPS) { 2464 name = strsep(&names, ":"); 2465 if (isdigit(*name) || *name == '-') { 2466 cr->cr_groups[cr->cr_ngroups++] = atoi(name); 2467 } else { 2468 if ((gr = getgrnam(name)) == NULL) { 2469 syslog(LOG_ERR, "unknown group: %s", name); 2470 continue; 2471 } 2472 cr->cr_groups[cr->cr_ngroups++] = gr->gr_gid; 2473 } 2474 } 2475 if (names != NULL && *names != '\0' && cr->cr_ngroups == NGROUPS) 2476 syslog(LOG_ERR, "too many groups"); 2477} 2478 2479#define STRSIZ (RPCMNT_NAMELEN+RPCMNT_PATHLEN+50) 2480/* 2481 * Routines that maintain the remote mounttab 2482 */ 2483void 2484get_mountlist() 2485{ 2486 struct mountlist *mlp, **mlpp; 2487 char *host, *dirp, *cp; 2488 char str[STRSIZ]; 2489 FILE *mlfile; 2490 2491 if ((mlfile = fopen(_PATH_RMOUNTLIST, "r")) == NULL) { 2492 if (errno == ENOENT) 2493 return; 2494 else { 2495 syslog(LOG_ERR, "can't open %s", _PATH_RMOUNTLIST); 2496 return; 2497 } 2498 } 2499 mlpp = &mlhead; 2500 while (fgets(str, STRSIZ, mlfile) != NULL) { 2501 cp = str; 2502 host = strsep(&cp, " \t\n"); 2503 dirp = strsep(&cp, " \t\n"); 2504 if (host == NULL || dirp == NULL) 2505 continue; 2506 mlp = (struct mountlist *)malloc(sizeof (*mlp)); 2507 if (mlp == (struct mountlist *)NULL) 2508 out_of_mem(); 2509 strncpy(mlp->ml_host, host, RPCMNT_NAMELEN); 2510 mlp->ml_host[RPCMNT_NAMELEN] = '\0'; 2511 strncpy(mlp->ml_dirp, dirp, RPCMNT_PATHLEN); 2512 mlp->ml_dirp[RPCMNT_PATHLEN] = '\0'; 2513 mlp->ml_next = (struct mountlist *)NULL; 2514 *mlpp = mlp; 2515 mlpp = &mlp->ml_next; 2516 } 2517 fclose(mlfile); 2518} 2519 2520void 2521del_mlist(char *hostp, char *dirp) 2522{ 2523 struct mountlist *mlp, **mlpp; 2524 struct mountlist *mlp2; 2525 FILE *mlfile; 2526 int fnd = 0; 2527 2528 mlpp = &mlhead; 2529 mlp = mlhead; 2530 while (mlp) { 2531 if (!strcmp(mlp->ml_host, hostp) && 2532 (!dirp || !strcmp(mlp->ml_dirp, dirp))) { 2533 fnd = 1; 2534 mlp2 = mlp; 2535 *mlpp = mlp = mlp->ml_next; 2536 free((caddr_t)mlp2); 2537 } else { 2538 mlpp = &mlp->ml_next; 2539 mlp = mlp->ml_next; 2540 } 2541 } 2542 if (fnd) { 2543 if ((mlfile = fopen(_PATH_RMOUNTLIST, "w")) == NULL) { 2544 syslog(LOG_ERR,"can't update %s", _PATH_RMOUNTLIST); 2545 return; 2546 } 2547 mlp = mlhead; 2548 while (mlp) { 2549 fprintf(mlfile, "%s %s\n", mlp->ml_host, mlp->ml_dirp); 2550 mlp = mlp->ml_next; 2551 } 2552 fclose(mlfile); 2553 } 2554} 2555 2556void 2557add_mlist(hostp, dirp) 2558 char *hostp, *dirp; 2559{ 2560 struct mountlist *mlp, **mlpp; 2561 FILE *mlfile; 2562 2563 mlpp = &mlhead; 2564 mlp = mlhead; 2565 while (mlp) { 2566 if (!strcmp(mlp->ml_host, hostp) && !strcmp(mlp->ml_dirp, dirp)) 2567 return; 2568 mlpp = &mlp->ml_next; 2569 mlp = mlp->ml_next; 2570 } 2571 mlp = (struct mountlist *)malloc(sizeof (*mlp)); 2572 if (mlp == (struct mountlist *)NULL) 2573 out_of_mem(); 2574 strncpy(mlp->ml_host, hostp, RPCMNT_NAMELEN); 2575 mlp->ml_host[RPCMNT_NAMELEN] = '\0'; 2576 strncpy(mlp->ml_dirp, dirp, RPCMNT_PATHLEN); 2577 mlp->ml_dirp[RPCMNT_PATHLEN] = '\0'; 2578 mlp->ml_next = (struct mountlist *)NULL; 2579 *mlpp = mlp; 2580 if ((mlfile = fopen(_PATH_RMOUNTLIST, "a")) == NULL) { 2581 syslog(LOG_ERR, "can't update %s", _PATH_RMOUNTLIST); 2582 return; 2583 } 2584 fprintf(mlfile, "%s %s\n", mlp->ml_host, mlp->ml_dirp); 2585 fclose(mlfile); 2586} 2587 2588/* 2589 * Free up a group list. 2590 */ 2591void 2592free_grp(grp) 2593 struct grouplist *grp; 2594{ 2595 if (grp->gr_type == GT_HOST) { 2596 if (grp->gr_ptr.gt_addrinfo != NULL) 2597 freeaddrinfo(grp->gr_ptr.gt_addrinfo); 2598 } else if (grp->gr_type == GT_NET) { 2599 if (grp->gr_ptr.gt_net.nt_name) 2600 free(grp->gr_ptr.gt_net.nt_name); 2601 } 2602 free((caddr_t)grp); 2603} 2604 2605#ifdef DEBUG 2606void 2607SYSLOG(int pri, const char *fmt, ...) 2608{ 2609 va_list ap; 2610 2611 va_start(ap, fmt); 2612 vfprintf(stderr, fmt, ap); 2613 va_end(ap); 2614} 2615#endif /* DEBUG */ 2616 2617/* 2618 * Check options for consistency. 2619 */ 2620int 2621check_options(dp) 2622 struct dirlist *dp; 2623{ 2624 2625 if (dp == (struct dirlist *)NULL) 2626 return (1); 2627 if ((opt_flags & (OP_MAPROOT | OP_MAPALL)) == (OP_MAPROOT | OP_MAPALL)) { 2628 syslog(LOG_ERR, "-mapall and -maproot mutually exclusive"); 2629 return (1); 2630 } 2631 if ((opt_flags & OP_MASK) && (opt_flags & OP_NET) == 0) { 2632 syslog(LOG_ERR, "-mask requires -network"); 2633 return (1); 2634 } 2635 if ((opt_flags & OP_NET) && (opt_flags & OP_HAVEMASK) == 0) { 2636 syslog(LOG_ERR, "-network requires mask specification"); 2637 return (1); 2638 } 2639 if ((opt_flags & OP_MASK) && (opt_flags & OP_MASKLEN)) { 2640 syslog(LOG_ERR, "-mask and /masklen are mutually exclusive"); 2641 return (1); 2642 } 2643 if ((opt_flags & OP_ALLDIRS) && dp->dp_left) { 2644 syslog(LOG_ERR, "-alldirs has multiple directories"); 2645 return (1); 2646 } 2647 return (0); 2648} 2649 2650/* 2651 * Check an absolute directory path for any symbolic links. Return true 2652 */ 2653int 2654check_dirpath(dirp) 2655 char *dirp; 2656{ 2657 char *cp; 2658 int ret = 1; 2659 struct stat sb; 2660 2661 cp = dirp + 1; 2662 while (*cp && ret) { 2663 if (*cp == '/') { 2664 *cp = '\0'; 2665 if (lstat(dirp, &sb) < 0 || !S_ISDIR(sb.st_mode)) 2666 ret = 0; 2667 *cp = '/'; 2668 } 2669 cp++; 2670 } 2671 if (lstat(dirp, &sb) < 0 || !S_ISDIR(sb.st_mode)) 2672 ret = 0; 2673 return (ret); 2674} 2675 2676/* 2677 * Make a netmask according to the specified prefix length. The ss_family 2678 * and other non-address fields must be initialised before calling this. 2679 */ 2680int 2681makemask(struct sockaddr_storage *ssp, int bitlen) 2682{ 2683 u_char *p; 2684 int bits, i, len; 2685 2686 if ((p = sa_rawaddr((struct sockaddr *)ssp, &len)) == NULL) 2687 return (-1); 2688 if (bitlen > len * CHAR_BIT) 2689 return (-1); 2690 2691 for (i = 0; i < len; i++) { 2692 bits = (bitlen > CHAR_BIT) ? CHAR_BIT : bitlen; 2693 *p++ = (1 << bits) - 1; 2694 bitlen -= bits; 2695 } 2696 return 0; 2697} 2698 2699/* 2700 * Check that the sockaddr is a valid netmask. Returns 0 if the mask 2701 * is acceptable (i.e. of the form 1...10....0). 2702 */ 2703int 2704checkmask(struct sockaddr *sa) 2705{ 2706 u_char *mask; 2707 int i, len; 2708 2709 if ((mask = sa_rawaddr(sa, &len)) == NULL) 2710 return (-1); 2711 2712 for (i = 0; i < len; i++) 2713 if (mask[i] != 0xff) 2714 break; 2715 if (i < len) { 2716 if (~mask[i] & (u_char)(~mask[i] + 1)) 2717 return (-1); 2718 i++; 2719 } 2720 for (; i < len; i++) 2721 if (mask[i] != 0) 2722 return (-1); 2723 return (0); 2724} 2725 2726/* 2727 * Compare two sockaddrs according to a specified mask. Return zero if 2728 * `sa1' matches `sa2' when filtered by the netmask in `samask'. 2729 * If samask is NULL, perform a full comparision. 2730 */ 2731int 2732sacmp(struct sockaddr *sa1, struct sockaddr *sa2, struct sockaddr *samask) 2733{ 2734 unsigned char *p1, *p2, *mask; 2735 int len, i; 2736 2737 if (sa1->sa_family != sa2->sa_family || 2738 (p1 = sa_rawaddr(sa1, &len)) == NULL || 2739 (p2 = sa_rawaddr(sa2, NULL)) == NULL) 2740 return (1); 2741 2742 switch (sa1->sa_family) { 2743 case AF_INET6: 2744 if (((struct sockaddr_in6 *)sa1)->sin6_scope_id != 2745 ((struct sockaddr_in6 *)sa2)->sin6_scope_id) 2746 return (1); 2747 break; 2748 } 2749 2750 /* Simple binary comparison if no mask specified. */ 2751 if (samask == NULL) 2752 return (memcmp(p1, p2, len)); 2753 2754 /* Set up the mask, and do a mask-based comparison. */ 2755 if (sa1->sa_family != samask->sa_family || 2756 (mask = sa_rawaddr(samask, NULL)) == NULL) 2757 return (1); 2758 2759 for (i = 0; i < len; i++) 2760 if ((p1[i] & mask[i]) != (p2[i] & mask[i])) 2761 return (1); 2762 return (0); 2763} 2764 2765/* 2766 * Return a pointer to the part of the sockaddr that contains the 2767 * raw address, and set *nbytes to its length in bytes. Returns 2768 * NULL if the address family is unknown. 2769 */ 2770void * 2771sa_rawaddr(struct sockaddr *sa, int *nbytes) { 2772 void *p; 2773 int len; 2774 2775 switch (sa->sa_family) { 2776 case AF_INET: 2777 len = sizeof(((struct sockaddr_in *)sa)->sin_addr); 2778 p = &((struct sockaddr_in *)sa)->sin_addr; 2779 break; 2780 case AF_INET6: 2781 len = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr); 2782 p = &((struct sockaddr_in6 *)sa)->sin6_addr; 2783 break; 2784 default: 2785 p = NULL; 2786 len = 0; 2787 } 2788 2789 if (nbytes != NULL) 2790 *nbytes = len; 2791 return (p); 2792} 2793 2794void 2795huphandler(int sig) 2796{ 2797 got_sighup = 1; 2798} 2799 2800void terminate(sig) 2801int sig; 2802{ 2803 pidfile_remove(pfh); 2804 rpcb_unset(RPCPROG_MNT, RPCMNT_VER1, NULL); 2805 rpcb_unset(RPCPROG_MNT, RPCMNT_VER3, NULL); 2806 exit (0); 2807} 2808