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