mountd.c revision 17bb48fa11d98a1b5e3e18f74dc7f80436f95922
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 * 3. All advertising materials mentioning features or use of this software
17 *    must display the following acknowledgement:
18 *	This product includes software developed by the University of
19 *	California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 *    may be used to endorse or promote products derived from this software
22 *    without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 */
36
37#ifndef lint
38static char copyright[] =
39"@(#) Copyright (c) 1989, 1993\n\
40	The Regents of the University of California.  All rights reserved.\n";
41#endif /*not lint*/
42
43#ifndef lint
44/*static char sccsid[] = "From: @(#)mountd.c	8.8 (Berkeley) 2/20/94";*/
45static const char rcsid[] =
46	"$Id: mountd.c,v 1.3 1994/09/22 22:16:50 wollman Exp $";
47#endif /*not lint*/
48
49#include <sys/param.h>
50#include <sys/file.h>
51#include <sys/ioctl.h>
52#include <sys/mount.h>
53#include <sys/socket.h>
54#include <sys/stat.h>
55#include <sys/syslog.h>
56#include <sys/ucred.h>
57
58#include <rpc/rpc.h>
59#include <rpc/pmap_clnt.h>
60#include <rpc/pmap_prot.h>
61#ifdef ISO
62#include <netiso/iso.h>
63#endif
64#include <nfs/rpcv2.h>
65#include <nfs/nfsv2.h>
66
67#include <arpa/inet.h>
68
69#include <ctype.h>
70#include <errno.h>
71#include <grp.h>
72#include <netdb.h>
73#include <pwd.h>
74#include <signal.h>
75#include <stdio.h>
76#include <stdlib.h>
77#include <string.h>
78#include <unistd.h>
79#include "pathnames.h"
80
81#ifdef DEBUG
82#include <stdarg.h>
83#endif
84
85/*
86 * Structures for keeping the mount list and export list
87 */
88struct mountlist {
89	struct mountlist *ml_next;
90	char	ml_host[RPCMNT_NAMELEN+1];
91	char	ml_dirp[RPCMNT_PATHLEN+1];
92};
93
94struct dirlist {
95	struct dirlist	*dp_left;
96	struct dirlist	*dp_right;
97	int		dp_flag;
98	struct hostlist	*dp_hosts;	/* List of hosts this dir exported to */
99	char		dp_dirp[1];	/* Actually malloc'd to size of dir */
100};
101/* dp_flag bits */
102#define	DP_DEFSET	0x1
103
104struct exportlist {
105	struct exportlist *ex_next;
106	struct dirlist	*ex_dirl;
107	struct dirlist	*ex_defdir;
108	int		ex_flag;
109	fsid_t		ex_fs;
110	char		*ex_fsdir;
111};
112/* ex_flag bits */
113#define	EX_LINKED	0x1
114
115struct netmsk {
116	u_long	nt_net;
117	u_long	nt_mask;
118	char *nt_name;
119};
120
121union grouptypes {
122	struct hostent *gt_hostent;
123	struct netmsk	gt_net;
124#ifdef ISO
125	struct sockaddr_iso *gt_isoaddr;
126#endif
127};
128
129struct grouplist {
130	int gr_type;
131	union grouptypes gr_ptr;
132	struct grouplist *gr_next;
133};
134/* Group types */
135#define	GT_NULL		0x0
136#define	GT_HOST		0x1
137#define	GT_NET		0x2
138#define	GT_ISO		0x4
139
140struct hostlist {
141	struct grouplist *ht_grp;
142	struct hostlist	 *ht_next;
143};
144
145/* Global defs */
146char	*add_expdir __P((struct dirlist **, char *, int));
147void	add_dlist __P((struct dirlist **, struct dirlist *,
148				struct grouplist *));
149void	add_mlist __P((char *, char *));
150int	check_dirpath __P((char *));
151int	check_options __P((struct dirlist *));
152int	chk_host __P((struct dirlist *, u_long, int *));
153void	del_mlist __P((char *, char *));
154struct dirlist *dirp_search __P((struct dirlist *, char *));
155int	do_mount __P((struct exportlist *, struct grouplist *, int,
156				struct ucred *, char *, int, struct statfs *));
157int	do_opt __P((char **, char **, struct exportlist *, struct grouplist *,
158				int *, int *, struct ucred *));
159struct	exportlist *ex_search __P((fsid_t *));
160struct	exportlist *get_exp __P((void));
161void	free_dir __P((struct dirlist *));
162void	free_exp __P((struct exportlist *));
163void	free_grp __P((struct grouplist *));
164void	free_host __P((struct hostlist *));
165void	get_exportlist __P((void));
166int	get_host __P((char *, struct grouplist *));
167struct hostlist *get_ht __P((void));
168int	get_line __P((void));
169void	get_mountlist __P((void));
170int	get_net __P((char *, struct netmsk *, int));
171void	getexp_err __P((struct exportlist *, struct grouplist *));
172struct grouplist *get_grp __P((void));
173void	hang_dirp __P((struct dirlist *, struct grouplist *,
174				struct exportlist *, int));
175void	mntsrv __P((struct svc_req *, SVCXPRT *));
176void	nextfield __P((char **, char **));
177void	out_of_mem __P((void));
178void	parsecred __P((char *, struct ucred *));
179int	put_exlist __P((struct dirlist *, XDR *, struct dirlist *, int *));
180int	scan_tree __P((struct dirlist *, u_long));
181void	send_umntall __P((void));
182int	umntall_each __P((caddr_t, struct sockaddr_in *));
183int	xdr_dir __P((XDR *, char *));
184int	xdr_explist __P((XDR *, caddr_t));
185int	xdr_fhs __P((XDR *, nfsv2fh_t *));
186int	xdr_mlist __P((XDR *, caddr_t));
187
188/* C library */
189int	getnetgrent();
190void	endnetgrent();
191void	setnetgrent();
192
193#ifdef ISO
194struct iso_addr *iso_addr();
195#endif
196
197struct exportlist *exphead;
198struct mountlist *mlhead;
199struct grouplist *grphead;
200char exname[MAXPATHLEN];
201struct ucred def_anon = {
202	1,
203	(uid_t) -2,
204	1,
205	{ (gid_t) -2 }
206};
207int root_only = 1;
208int opt_flags;
209/* Bits for above */
210#define	OP_MAPROOT	0x01
211#define	OP_MAPALL	0x02
212#define	OP_KERB		0x04
213#define	OP_MASK		0x08
214#define	OP_NET		0x10
215#define	OP_ISO		0x20
216#define	OP_ALLDIRS	0x40
217
218#ifdef DEBUG
219int debug = 1;
220void	SYSLOG __P((int, const char *, ...));
221#define syslog SYSLOG
222#else
223int debug = 0;
224#endif
225
226/*
227 * Mountd server for NFS mount protocol as described in:
228 * NFS: Network File System Protocol Specification, RFC1094, Appendix A
229 * The optional arguments are the exports file name
230 * default: _PATH_EXPORTS
231 * and "-n" to allow nonroot mount.
232 */
233int
234main(argc, argv)
235	int argc;
236	char **argv;
237{
238	SVCXPRT *transp;
239	int c;
240	struct vfsconf *vfc;
241
242	vfc = getvfsbyname("nfs");
243	if(!vfc && vfsisloadable("nfs")) {
244		if(vfsload("nfs"))
245			err(1, "vfsload(nfs)");
246		endvfsent();	/* flush cache */
247		vfc = getvfsbyname("nfs");
248	}
249	if(!vfc) {
250		errx(1, "NFS support is not available in the running kernel");
251	}
252
253	while ((c = getopt(argc, argv, "n")) != EOF)
254		switch (c) {
255		case 'n':
256			root_only = 0;
257			break;
258		default:
259			fprintf(stderr, "Usage: mountd [-n] [export_file]\n");
260			exit(1);
261		};
262	argc -= optind;
263	argv += optind;
264	grphead = (struct grouplist *)NULL;
265	exphead = (struct exportlist *)NULL;
266	mlhead = (struct mountlist *)NULL;
267	if (argc == 1) {
268		strncpy(exname, *argv, MAXPATHLEN-1);
269		exname[MAXPATHLEN-1] = '\0';
270	} else
271		strcpy(exname, _PATH_EXPORTS);
272	openlog("mountd", LOG_PID, LOG_DAEMON);
273	if (debug)
274		fprintf(stderr,"Getting export list.\n");
275	get_exportlist();
276	if (debug)
277		fprintf(stderr,"Getting mount list.\n");
278	get_mountlist();
279	if (debug)
280		fprintf(stderr,"Here we go.\n");
281	if (debug == 0) {
282		daemon(0, 0);
283		signal(SIGINT, SIG_IGN);
284		signal(SIGQUIT, SIG_IGN);
285	}
286	signal(SIGHUP, (void (*) __P((int))) get_exportlist);
287	signal(SIGTERM, (void (*) __P((int))) send_umntall);
288	{ FILE *pidfile = fopen(_PATH_MOUNTDPID, "w");
289	  if (pidfile != NULL) {
290		fprintf(pidfile, "%d\n", getpid());
291		fclose(pidfile);
292	  }
293	}
294	if ((transp = svcudp_create(RPC_ANYSOCK)) == NULL) {
295		syslog(LOG_ERR, "Can't create socket");
296		exit(1);
297	}
298	pmap_unset(RPCPROG_MNT, RPCMNT_VER1);
299	if (!svc_register(transp, RPCPROG_MNT, RPCMNT_VER1, mntsrv,
300	    IPPROTO_UDP)) {
301		syslog(LOG_ERR, "Can't register mount");
302		exit(1);
303	}
304	svc_run();
305	syslog(LOG_ERR, "Mountd died");
306	exit(1);
307}
308
309/*
310 * The mount rpc service
311 */
312void
313mntsrv(rqstp, transp)
314	struct svc_req *rqstp;
315	SVCXPRT *transp;
316{
317	struct exportlist *ep;
318	struct dirlist *dp;
319	nfsv2fh_t nfh;
320	struct authunix_parms *ucr;
321	struct stat stb;
322	struct statfs fsb;
323	struct hostent *hp;
324	u_long saddr;
325	char rpcpath[RPCMNT_PATHLEN+1], dirpath[MAXPATHLEN];
326	int bad = ENOENT, omask, defset;
327	uid_t uid = -2;
328
329	/* Get authorization */
330	switch (rqstp->rq_cred.oa_flavor) {
331	case AUTH_UNIX:
332		ucr = (struct authunix_parms *)rqstp->rq_clntcred;
333		uid = ucr->aup_uid;
334		break;
335	case AUTH_NULL:
336	default:
337		break;
338	}
339
340	saddr = transp->xp_raddr.sin_addr.s_addr;
341	hp = (struct hostent *)NULL;
342	switch (rqstp->rq_proc) {
343	case NULLPROC:
344		if (!svc_sendreply(transp, xdr_void, (caddr_t)NULL))
345			syslog(LOG_ERR, "Can't send reply");
346		return;
347	case RPCMNT_MOUNT:
348		if ((uid != 0 && root_only) || uid == -2) {
349			svcerr_weakauth(transp);
350			return;
351		}
352		if (!svc_getargs(transp, xdr_dir, rpcpath)) {
353			svcerr_decode(transp);
354			return;
355		}
356
357		/*
358		 * Get the real pathname and make sure it is a directory
359		 * that exists.
360		 */
361		if (realpath(rpcpath, dirpath) == 0 ||
362		    stat(dirpath, &stb) < 0 ||
363		    (stb.st_mode & S_IFMT) != S_IFDIR ||
364		    statfs(dirpath, &fsb) < 0) {
365			chdir("/");	/* Just in case realpath doesn't */
366			if (debug)
367				fprintf(stderr, "stat failed on %s\n", dirpath);
368			if (!svc_sendreply(transp, xdr_long, (caddr_t)&bad))
369				syslog(LOG_ERR, "Can't send reply");
370			return;
371		}
372
373		/* Check in the exports list */
374		omask = sigblock(sigmask(SIGHUP));
375		ep = ex_search(&fsb.f_fsid);
376		defset = 0;
377		if (ep && (chk_host(ep->ex_defdir, saddr, &defset) ||
378		    ((dp = dirp_search(ep->ex_dirl, dirpath)) &&
379		     chk_host(dp, saddr, &defset)) ||
380		     (defset && scan_tree(ep->ex_defdir, saddr) == 0 &&
381		      scan_tree(ep->ex_dirl, saddr) == 0))) {
382			/* Get the file handle */
383			bzero((caddr_t)&nfh, sizeof(nfh));
384			if (getfh(dirpath, (fhandle_t *)&nfh) < 0) {
385				bad = errno;
386				syslog(LOG_ERR, "Can't get fh for %s", dirpath);
387				if (!svc_sendreply(transp, xdr_long,
388				    (caddr_t)&bad))
389					syslog(LOG_ERR, "Can't send reply");
390				sigsetmask(omask);
391				return;
392			}
393			if (!svc_sendreply(transp, xdr_fhs, (caddr_t)&nfh))
394				syslog(LOG_ERR, "Can't send reply");
395			if (hp == NULL)
396				hp = gethostbyaddr((caddr_t)&saddr,
397				    sizeof(saddr), AF_INET);
398			if (hp)
399				add_mlist(hp->h_name, dirpath);
400			else
401				add_mlist(inet_ntoa(transp->xp_raddr.sin_addr),
402					dirpath);
403			if (debug)
404				fprintf(stderr,"Mount successfull.\n");
405		} else {
406			bad = EACCES;
407			if (!svc_sendreply(transp, xdr_long, (caddr_t)&bad))
408				syslog(LOG_ERR, "Can't send reply");
409		}
410		sigsetmask(omask);
411		return;
412	case RPCMNT_DUMP:
413		if (!svc_sendreply(transp, xdr_mlist, (caddr_t)NULL))
414			syslog(LOG_ERR, "Can't send reply");
415		return;
416	case RPCMNT_UMOUNT:
417		if ((uid != 0 && root_only) || uid == -2) {
418			svcerr_weakauth(transp);
419			return;
420		}
421		if (!svc_getargs(transp, xdr_dir, dirpath)) {
422			svcerr_decode(transp);
423			return;
424		}
425		if (!svc_sendreply(transp, xdr_void, (caddr_t)NULL))
426			syslog(LOG_ERR, "Can't send reply");
427		hp = gethostbyaddr((caddr_t)&saddr, sizeof(saddr), AF_INET);
428		if (hp)
429			del_mlist(hp->h_name, dirpath);
430		del_mlist(inet_ntoa(transp->xp_raddr.sin_addr), dirpath);
431		return;
432	case RPCMNT_UMNTALL:
433		if ((uid != 0 && root_only) || uid == -2) {
434			svcerr_weakauth(transp);
435			return;
436		}
437		if (!svc_sendreply(transp, xdr_void, (caddr_t)NULL))
438			syslog(LOG_ERR, "Can't send reply");
439		hp = gethostbyaddr((caddr_t)&saddr, sizeof(saddr), AF_INET);
440		if (hp)
441			del_mlist(hp->h_name, (char *)NULL);
442		del_mlist(inet_ntoa(transp->xp_raddr.sin_addr), (char *)NULL);
443		return;
444	case RPCMNT_EXPORT:
445		if (!svc_sendreply(transp, xdr_explist, (caddr_t)NULL))
446			syslog(LOG_ERR, "Can't send reply");
447		return;
448	default:
449		svcerr_noproc(transp);
450		return;
451	}
452}
453
454/*
455 * Xdr conversion for a dirpath string
456 */
457int
458xdr_dir(xdrsp, dirp)
459	XDR *xdrsp;
460	char *dirp;
461{
462	return (xdr_string(xdrsp, &dirp, RPCMNT_PATHLEN));
463}
464
465/*
466 * Xdr routine to generate fhstatus
467 */
468int
469xdr_fhs(xdrsp, nfh)
470	XDR *xdrsp;
471	nfsv2fh_t *nfh;
472{
473	int ok = 0;
474
475	if (!xdr_long(xdrsp, &ok))
476		return (0);
477	return (xdr_opaque(xdrsp, (caddr_t)nfh, NFSX_FH));
478}
479
480int
481xdr_mlist(xdrsp, cp)
482	XDR *xdrsp;
483	caddr_t cp;
484{
485	struct mountlist *mlp;
486	int true = 1;
487	int false = 0;
488	char *strp;
489
490	mlp = mlhead;
491	while (mlp) {
492		if (!xdr_bool(xdrsp, &true))
493			return (0);
494		strp = &mlp->ml_host[0];
495		if (!xdr_string(xdrsp, &strp, RPCMNT_NAMELEN))
496			return (0);
497		strp = &mlp->ml_dirp[0];
498		if (!xdr_string(xdrsp, &strp, RPCMNT_PATHLEN))
499			return (0);
500		mlp = mlp->ml_next;
501	}
502	if (!xdr_bool(xdrsp, &false))
503		return (0);
504	return (1);
505}
506
507/*
508 * Xdr conversion for export list
509 */
510int
511xdr_explist(xdrsp, cp)
512	XDR *xdrsp;
513	caddr_t cp;
514{
515	struct exportlist *ep;
516	int false = 0;
517	int omask, putdef;
518
519	omask = sigblock(sigmask(SIGHUP));
520	ep = exphead;
521	while (ep) {
522		putdef = 0;
523		if (put_exlist(ep->ex_dirl, xdrsp, ep->ex_defdir, &putdef))
524			goto errout;
525		if (ep->ex_defdir && putdef == 0 &&
526			put_exlist(ep->ex_defdir, xdrsp, (struct dirlist *)NULL,
527			&putdef))
528			goto errout;
529		ep = ep->ex_next;
530	}
531	sigsetmask(omask);
532	if (!xdr_bool(xdrsp, &false))
533		return (0);
534	return (1);
535errout:
536	sigsetmask(omask);
537	return (0);
538}
539
540/*
541 * Called from xdr_explist() to traverse the tree and export the
542 * directory paths.
543 */
544int
545put_exlist(dp, xdrsp, adp, putdefp)
546	struct dirlist *dp;
547	XDR *xdrsp;
548	struct dirlist *adp;
549	int *putdefp;
550{
551	struct grouplist *grp;
552	struct hostlist *hp;
553	int true = 1;
554	int false = 0;
555	int gotalldir = 0;
556	char *strp;
557
558	if (dp) {
559		if (put_exlist(dp->dp_left, xdrsp, adp, putdefp))
560			return (1);
561		if (!xdr_bool(xdrsp, &true))
562			return (1);
563		strp = dp->dp_dirp;
564		if (!xdr_string(xdrsp, &strp, RPCMNT_PATHLEN))
565			return (1);
566		if (adp && !strcmp(dp->dp_dirp, adp->dp_dirp)) {
567			gotalldir = 1;
568			*putdefp = 1;
569		}
570		if ((dp->dp_flag & DP_DEFSET) == 0 &&
571		    (gotalldir == 0 || (adp->dp_flag & DP_DEFSET) == 0)) {
572			hp = dp->dp_hosts;
573			while (hp) {
574				grp = hp->ht_grp;
575				if (grp->gr_type == GT_HOST) {
576					if (!xdr_bool(xdrsp, &true))
577						return (1);
578					strp = grp->gr_ptr.gt_hostent->h_name;
579					if (!xdr_string(xdrsp, &strp,
580					    RPCMNT_NAMELEN))
581						return (1);
582				} else if (grp->gr_type == GT_NET) {
583					if (!xdr_bool(xdrsp, &true))
584						return (1);
585					strp = grp->gr_ptr.gt_net.nt_name;
586					if (!xdr_string(xdrsp, &strp,
587					    RPCMNT_NAMELEN))
588						return (1);
589				}
590				hp = hp->ht_next;
591				if (gotalldir && hp == (struct hostlist *)NULL) {
592					hp = adp->dp_hosts;
593					gotalldir = 0;
594				}
595			}
596		}
597		if (!xdr_bool(xdrsp, &false))
598			return (1);
599		if (put_exlist(dp->dp_right, xdrsp, adp, putdefp))
600			return (1);
601	}
602	return (0);
603}
604
605#define LINESIZ	10240
606char line[LINESIZ];
607FILE *exp_file;
608
609/*
610 * Get the export list
611 */
612void
613get_exportlist()
614{
615	struct exportlist *ep, *ep2;
616	struct grouplist *grp, *tgrp;
617	struct exportlist **epp;
618	struct dirlist *dirhead;
619	struct statfs fsb, *fsp;
620	struct hostent *hpe;
621	struct ucred anon;
622	char *cp, *endcp, *dirp, *hst, *usr, *dom, savedc;
623	int len, has_host, exflags, got_nondir, dirplen, num, i, netgrp;
624
625	/*
626	 * First, get rid of the old list
627	 */
628	ep = exphead;
629	while (ep) {
630		ep2 = ep;
631		ep = ep->ex_next;
632		free_exp(ep2);
633	}
634	exphead = (struct exportlist *)NULL;
635
636	grp = grphead;
637	while (grp) {
638		tgrp = grp;
639		grp = grp->gr_next;
640		free_grp(tgrp);
641	}
642	grphead = (struct grouplist *)NULL;
643
644	/*
645	 * And delete exports that are in the kernel for all local
646	 * file systems.
647	 * XXX: Should know how to handle all local exportable file systems
648	 *      instead of just MOUNT_UFS.
649	 */
650	num = getmntinfo(&fsp, MNT_NOWAIT);
651	for (i = 0; i < num; i++) {
652		union {
653			struct ufs_args ua;
654			struct iso_args ia;
655			struct mfs_args ma;
656		} targs;
657
658		switch (fsp->f_type) {
659		case MOUNT_MFS:
660		case MOUNT_UFS:
661		case MOUNT_CD9660:
662		case MOUNT_MSDOS:
663			targs.ua.fspec = NULL;
664			targs.ua.export.ex_flags = MNT_DELEXPORT;
665			if (mount(fsp->f_type, fsp->f_mntonname,
666				  fsp->f_flags | MNT_UPDATE,
667				  (caddr_t)&targs) < 0)
668				syslog(LOG_ERR, "Can't delete exports for %s",
669				       fsp->f_mntonname);
670		}
671		fsp++;
672	}
673
674	/*
675	 * Read in the exports file and build the list, calling
676	 * mount() as we go along to push the export rules into the kernel.
677	 */
678	if ((exp_file = fopen(exname, "r")) == NULL) {
679		syslog(LOG_ERR, "Can't open %s", exname);
680		exit(2);
681	}
682	dirhead = (struct dirlist *)NULL;
683	while (get_line()) {
684		if (debug)
685			fprintf(stderr,"Got line %s\n",line);
686		cp = line;
687		nextfield(&cp, &endcp);
688		if (*cp == '#')
689			goto nextline;
690
691		/*
692		 * Set defaults.
693		 */
694		has_host = FALSE;
695		anon = def_anon;
696		exflags = MNT_EXPORTED;
697		got_nondir = 0;
698		opt_flags = 0;
699		ep = (struct exportlist *)NULL;
700
701		/*
702		 * Create new exports list entry
703		 */
704		len = endcp-cp;
705		tgrp = grp = get_grp();
706		while (len > 0) {
707			if (len > RPCMNT_NAMELEN) {
708			    getexp_err(ep, tgrp);
709			    goto nextline;
710			}
711			if (*cp == '-') {
712			    if (ep == (struct exportlist *)NULL) {
713				getexp_err(ep, tgrp);
714				goto nextline;
715			    }
716			    if (debug)
717				fprintf(stderr, "doing opt %s\n", cp);
718			    got_nondir = 1;
719			    if (do_opt(&cp, &endcp, ep, grp, &has_host,
720				&exflags, &anon)) {
721				getexp_err(ep, tgrp);
722				goto nextline;
723			    }
724			} else if (*cp == '/') {
725			    savedc = *endcp;
726			    *endcp = '\0';
727			    if (check_dirpath(cp) &&
728				statfs(cp, &fsb) >= 0) {
729				if (got_nondir) {
730				    syslog(LOG_ERR, "Dirs must be first");
731				    getexp_err(ep, tgrp);
732				    goto nextline;
733				}
734				if (ep) {
735				    if (ep->ex_fs.val[0] != fsb.f_fsid.val[0] ||
736					ep->ex_fs.val[1] != fsb.f_fsid.val[1]) {
737					getexp_err(ep, tgrp);
738					goto nextline;
739				    }
740				} else {
741				    /*
742				     * See if this directory is already
743				     * in the list.
744				     */
745				    ep = ex_search(&fsb.f_fsid);
746				    if (ep == (struct exportlist *)NULL) {
747					ep = get_exp();
748					ep->ex_fs = fsb.f_fsid;
749					ep->ex_fsdir = (char *)
750					    malloc(strlen(fsb.f_mntonname) + 1);
751					if (ep->ex_fsdir)
752					    strcpy(ep->ex_fsdir,
753						fsb.f_mntonname);
754					else
755					    out_of_mem();
756					if (debug)
757					  fprintf(stderr,
758					      "Making new ep fs=0x%x,0x%x\n",
759					      fsb.f_fsid.val[0],
760					      fsb.f_fsid.val[1]);
761				    } else if (debug)
762					fprintf(stderr,
763					    "Found ep fs=0x%x,0x%x\n",
764					    fsb.f_fsid.val[0],
765					    fsb.f_fsid.val[1]);
766				}
767
768				/*
769				 * Add dirpath to export mount point.
770				 */
771				dirp = add_expdir(&dirhead, cp, len);
772				dirplen = len;
773			    } else {
774				getexp_err(ep, tgrp);
775				goto nextline;
776			    }
777			    *endcp = savedc;
778			} else {
779			    savedc = *endcp;
780			    *endcp = '\0';
781			    got_nondir = 1;
782			    if (ep == (struct exportlist *)NULL) {
783				getexp_err(ep, tgrp);
784				goto nextline;
785			    }
786
787			    /*
788			     * Get the host or netgroup.
789			     */
790			    setnetgrent(cp);
791			    netgrp = getnetgrent(&hst, &usr, &dom);
792			    do {
793				if (has_host) {
794				    grp->gr_next = get_grp();
795				    grp = grp->gr_next;
796				}
797				if (netgrp) {
798				    if (get_host(hst, grp)) {
799					syslog(LOG_ERR, "Bad netgroup %s", cp);
800					getexp_err(ep, tgrp);
801					goto nextline;
802				    }
803				} else if (get_host(cp, grp)) {
804				    getexp_err(ep, tgrp);
805				    goto nextline;
806				}
807				has_host = TRUE;
808			    } while (netgrp && getnetgrent(&hst, &usr, &dom));
809			    endnetgrent();
810			    *endcp = savedc;
811			}
812			cp = endcp;
813			nextfield(&cp, &endcp);
814			len = endcp - cp;
815		}
816		if (check_options(dirhead)) {
817			getexp_err(ep, tgrp);
818			goto nextline;
819		}
820		if (!has_host) {
821			grp->gr_type = GT_HOST;
822			if (debug)
823				fprintf(stderr,"Adding a default entry\n");
824			/* add a default group and make the grp list NULL */
825			hpe = (struct hostent *)malloc(sizeof(struct hostent));
826			if (hpe == (struct hostent *)NULL)
827				out_of_mem();
828			hpe->h_name = "Default";
829			hpe->h_addrtype = AF_INET;
830			hpe->h_length = sizeof (u_long);
831			hpe->h_addr_list = (char **)NULL;
832			grp->gr_ptr.gt_hostent = hpe;
833
834		/*
835		 * Don't allow a network export coincide with a list of
836		 * host(s) on the same line.
837		 */
838		} else if ((opt_flags & OP_NET) && tgrp->gr_next) {
839			getexp_err(ep, tgrp);
840			goto nextline;
841		}
842
843		/*
844		 * Loop through hosts, pushing the exports into the kernel.
845		 * After loop, tgrp points to the start of the list and
846		 * grp points to the last entry in the list.
847		 */
848		grp = tgrp;
849		do {
850		    if (do_mount(ep, grp, exflags, &anon, dirp,
851			dirplen, &fsb)) {
852			getexp_err(ep, tgrp);
853			goto nextline;
854		    }
855		} while (grp->gr_next && (grp = grp->gr_next));
856
857		/*
858		 * Success. Update the data structures.
859		 */
860		if (has_host) {
861			hang_dirp(dirhead, tgrp, ep, (opt_flags & OP_ALLDIRS));
862			grp->gr_next = grphead;
863			grphead = tgrp;
864		} else {
865			hang_dirp(dirhead, (struct grouplist *)NULL, ep,
866			(opt_flags & OP_ALLDIRS));
867			free_grp(grp);
868		}
869		dirhead = (struct dirlist *)NULL;
870		if ((ep->ex_flag & EX_LINKED) == 0) {
871			ep2 = exphead;
872			epp = &exphead;
873
874			/*
875			 * Insert in the list in alphabetical order.
876			 */
877			while (ep2 && strcmp(ep2->ex_fsdir, ep->ex_fsdir) < 0) {
878				epp = &ep2->ex_next;
879				ep2 = ep2->ex_next;
880			}
881			if (ep2)
882				ep->ex_next = ep2;
883			*epp = ep;
884			ep->ex_flag |= EX_LINKED;
885		}
886nextline:
887		if (dirhead) {
888			free_dir(dirhead);
889			dirhead = (struct dirlist *)NULL;
890		}
891	}
892	fclose(exp_file);
893}
894
895/*
896 * Allocate an export list element
897 */
898struct exportlist *
899get_exp()
900{
901	struct exportlist *ep;
902
903	ep = (struct exportlist *)malloc(sizeof (struct exportlist));
904	if (ep == (struct exportlist *)NULL)
905		out_of_mem();
906	bzero((caddr_t)ep, sizeof (struct exportlist));
907	return (ep);
908}
909
910/*
911 * Allocate a group list element
912 */
913struct grouplist *
914get_grp()
915{
916	struct grouplist *gp;
917
918	gp = (struct grouplist *)malloc(sizeof (struct grouplist));
919	if (gp == (struct grouplist *)NULL)
920		out_of_mem();
921	bzero((caddr_t)gp, sizeof (struct grouplist));
922	return (gp);
923}
924
925/*
926 * Clean up upon an error in get_exportlist().
927 */
928void
929getexp_err(ep, grp)
930	struct exportlist *ep;
931	struct grouplist *grp;
932{
933	struct grouplist *tgrp;
934
935	syslog(LOG_ERR, "Bad exports list line %s", line);
936	if (ep && (ep->ex_flag & EX_LINKED) == 0)
937		free_exp(ep);
938	while (grp) {
939		tgrp = grp;
940		grp = grp->gr_next;
941		free_grp(tgrp);
942	}
943}
944
945/*
946 * Search the export list for a matching fs.
947 */
948struct exportlist *
949ex_search(fsid)
950	fsid_t *fsid;
951{
952	struct exportlist *ep;
953
954	ep = exphead;
955	while (ep) {
956		if (ep->ex_fs.val[0] == fsid->val[0] &&
957		    ep->ex_fs.val[1] == fsid->val[1])
958			return (ep);
959		ep = ep->ex_next;
960	}
961	return (ep);
962}
963
964/*
965 * Add a directory path to the list.
966 */
967char *
968add_expdir(dpp, cp, len)
969	struct dirlist **dpp;
970	char *cp;
971	int len;
972{
973	struct dirlist *dp;
974
975	dp = (struct dirlist *)malloc(sizeof (struct dirlist) + len);
976	dp->dp_left = *dpp;
977	dp->dp_right = (struct dirlist *)NULL;
978	dp->dp_flag = 0;
979	dp->dp_hosts = (struct hostlist *)NULL;
980	strcpy(dp->dp_dirp, cp);
981	*dpp = dp;
982	return (dp->dp_dirp);
983}
984
985/*
986 * Hang the dir list element off the dirpath binary tree as required
987 * and update the entry for host.
988 */
989void
990hang_dirp(dp, grp, ep, alldirs)
991	struct dirlist *dp;
992	struct grouplist *grp;
993	struct exportlist *ep;
994	int alldirs;
995{
996	struct hostlist *hp;
997	struct dirlist *dp2;
998
999	if (alldirs) {
1000		if (ep->ex_defdir)
1001			free((caddr_t)dp);
1002		else
1003			ep->ex_defdir = dp;
1004		if (grp == (struct grouplist *)NULL)
1005			ep->ex_defdir->dp_flag |= DP_DEFSET;
1006		else while (grp) {
1007			hp = get_ht();
1008			hp->ht_grp = grp;
1009			hp->ht_next = ep->ex_defdir->dp_hosts;
1010			ep->ex_defdir->dp_hosts = hp;
1011			grp = grp->gr_next;
1012		}
1013	} else {
1014
1015		/*
1016		 * Loop throught the directories adding them to the tree.
1017		 */
1018		while (dp) {
1019			dp2 = dp->dp_left;
1020			add_dlist(&ep->ex_dirl, dp, grp);
1021			dp = dp2;
1022		}
1023	}
1024}
1025
1026/*
1027 * Traverse the binary tree either updating a node that is already there
1028 * for the new directory or adding the new node.
1029 */
1030void
1031add_dlist(dpp, newdp, grp)
1032	struct dirlist **dpp;
1033	struct dirlist *newdp;
1034	struct grouplist *grp;
1035{
1036	struct dirlist *dp;
1037	struct hostlist *hp;
1038	int cmp;
1039
1040	dp = *dpp;
1041	if (dp) {
1042		cmp = strcmp(dp->dp_dirp, newdp->dp_dirp);
1043		if (cmp > 0) {
1044			add_dlist(&dp->dp_left, newdp, grp);
1045			return;
1046		} else if (cmp < 0) {
1047			add_dlist(&dp->dp_right, newdp, grp);
1048			return;
1049		} else
1050			free((caddr_t)newdp);
1051	} else {
1052		dp = newdp;
1053		dp->dp_left = (struct dirlist *)NULL;
1054		*dpp = dp;
1055	}
1056	if (grp) {
1057
1058		/*
1059		 * Hang all of the host(s) off of the directory point.
1060		 */
1061		do {
1062			hp = get_ht();
1063			hp->ht_grp = grp;
1064			hp->ht_next = dp->dp_hosts;
1065			dp->dp_hosts = hp;
1066			grp = grp->gr_next;
1067		} while (grp);
1068	} else
1069		dp->dp_flag |= DP_DEFSET;
1070}
1071
1072/*
1073 * Search for a dirpath on the export point.
1074 */
1075struct dirlist *
1076dirp_search(dp, dirpath)
1077	struct dirlist *dp;
1078	char *dirpath;
1079{
1080	int cmp;
1081
1082	if (dp) {
1083		cmp = strcmp(dp->dp_dirp, dirpath);
1084		if (cmp > 0)
1085			return (dirp_search(dp->dp_left, dirpath));
1086		else if (cmp < 0)
1087			return (dirp_search(dp->dp_right, dirpath));
1088		else
1089			return (dp);
1090	}
1091	return (dp);
1092}
1093
1094/*
1095 * Scan for a host match in a directory tree.
1096 */
1097int
1098chk_host(dp, saddr, defsetp)
1099	struct dirlist *dp;
1100	u_long saddr;
1101	int *defsetp;
1102{
1103	struct hostlist *hp;
1104	struct grouplist *grp;
1105	u_long **addrp;
1106
1107	if (dp) {
1108		if (dp->dp_flag & DP_DEFSET)
1109			*defsetp = 1;
1110		hp = dp->dp_hosts;
1111		while (hp) {
1112			grp = hp->ht_grp;
1113			switch (grp->gr_type) {
1114			case GT_HOST:
1115			    addrp = (u_long **)
1116				grp->gr_ptr.gt_hostent->h_addr_list;
1117			    while (*addrp) {
1118				if (**addrp == saddr)
1119				    return (1);
1120				addrp++;
1121			    }
1122			    break;
1123			case GT_NET:
1124			    if ((saddr & grp->gr_ptr.gt_net.nt_mask) ==
1125				grp->gr_ptr.gt_net.nt_net)
1126				return (1);
1127			    break;
1128			};
1129			hp = hp->ht_next;
1130		}
1131	}
1132	return (0);
1133}
1134
1135/*
1136 * Scan tree for a host that matches the address.
1137 */
1138int
1139scan_tree(dp, saddr)
1140	struct dirlist *dp;
1141	u_long saddr;
1142{
1143	int defset;
1144
1145	if (dp) {
1146		if (scan_tree(dp->dp_left, saddr))
1147			return (1);
1148		if (chk_host(dp, saddr, &defset))
1149			return (1);
1150		if (scan_tree(dp->dp_right, saddr))
1151			return (1);
1152	}
1153	return (0);
1154}
1155
1156/*
1157 * Traverse the dirlist tree and free it up.
1158 */
1159void
1160free_dir(dp)
1161	struct dirlist *dp;
1162{
1163
1164	if (dp) {
1165		free_dir(dp->dp_left);
1166		free_dir(dp->dp_right);
1167		free_host(dp->dp_hosts);
1168		free((caddr_t)dp);
1169	}
1170}
1171
1172/*
1173 * Parse the option string and update fields.
1174 * Option arguments may either be -<option>=<value> or
1175 * -<option> <value>
1176 */
1177int
1178do_opt(cpp, endcpp, ep, grp, has_hostp, exflagsp, cr)
1179	char **cpp, **endcpp;
1180	struct exportlist *ep;
1181	struct grouplist *grp;
1182	int *has_hostp;
1183	int *exflagsp;
1184	struct ucred *cr;
1185{
1186	char *cpoptarg, *cpoptend;
1187	char *cp, *endcp, *cpopt, savedc, savedc2;
1188	int allflag, usedarg;
1189
1190	cpopt = *cpp;
1191	cpopt++;
1192	cp = *endcpp;
1193	savedc = *cp;
1194	*cp = '\0';
1195	while (cpopt && *cpopt) {
1196		allflag = 1;
1197		usedarg = -2;
1198		if (cpoptend = index(cpopt, ',')) {
1199			*cpoptend++ = '\0';
1200			if (cpoptarg = index(cpopt, '='))
1201				*cpoptarg++ = '\0';
1202		} else {
1203			if (cpoptarg = index(cpopt, '='))
1204				*cpoptarg++ = '\0';
1205			else {
1206				*cp = savedc;
1207				nextfield(&cp, &endcp);
1208				**endcpp = '\0';
1209				if (endcp > cp && *cp != '-') {
1210					cpoptarg = cp;
1211					savedc2 = *endcp;
1212					*endcp = '\0';
1213					usedarg = 0;
1214				}
1215			}
1216		}
1217		if (!strcmp(cpopt, "ro") || !strcmp(cpopt, "o")) {
1218			*exflagsp |= MNT_EXRDONLY;
1219		} else if (cpoptarg && (!strcmp(cpopt, "maproot") ||
1220		    !(allflag = strcmp(cpopt, "mapall")) ||
1221		    !strcmp(cpopt, "root") || !strcmp(cpopt, "r"))) {
1222			usedarg++;
1223			parsecred(cpoptarg, cr);
1224			if (allflag == 0) {
1225				*exflagsp |= MNT_EXPORTANON;
1226				opt_flags |= OP_MAPALL;
1227			} else
1228				opt_flags |= OP_MAPROOT;
1229		} else if (!strcmp(cpopt, "kerb") || !strcmp(cpopt, "k")) {
1230			*exflagsp |= MNT_EXKERB;
1231			opt_flags |= OP_KERB;
1232		} else if (cpoptarg && (!strcmp(cpopt, "mask") ||
1233			!strcmp(cpopt, "m"))) {
1234			if (get_net(cpoptarg, &grp->gr_ptr.gt_net, 1)) {
1235				syslog(LOG_ERR, "Bad mask: %s", cpoptarg);
1236				return (1);
1237			}
1238			usedarg++;
1239			opt_flags |= OP_MASK;
1240		} else if (cpoptarg && (!strcmp(cpopt, "network") ||
1241			!strcmp(cpopt, "n"))) {
1242			if (grp->gr_type != GT_NULL) {
1243				syslog(LOG_ERR, "Network/host conflict");
1244				return (1);
1245			} else if (get_net(cpoptarg, &grp->gr_ptr.gt_net, 0)) {
1246				syslog(LOG_ERR, "Bad net: %s", cpoptarg);
1247				return (1);
1248			}
1249			grp->gr_type = GT_NET;
1250			*has_hostp = 1;
1251			usedarg++;
1252			opt_flags |= OP_NET;
1253		} else if (!strcmp(cpopt, "alldirs")) {
1254			opt_flags |= OP_ALLDIRS;
1255#ifdef ISO
1256		} else if (cpoptarg && !strcmp(cpopt, "iso")) {
1257			if (get_isoaddr(cpoptarg, grp)) {
1258				syslog(LOG_ERR, "Bad iso addr: %s", cpoptarg);
1259				return (1);
1260			}
1261			*has_hostp = 1;
1262			usedarg++;
1263			opt_flags |= OP_ISO;
1264#endif /* ISO */
1265		} else {
1266			syslog(LOG_ERR, "Bad opt %s", cpopt);
1267			return (1);
1268		}
1269		if (usedarg >= 0) {
1270			*endcp = savedc2;
1271			**endcpp = savedc;
1272			if (usedarg > 0) {
1273				*cpp = cp;
1274				*endcpp = endcp;
1275			}
1276			return (0);
1277		}
1278		cpopt = cpoptend;
1279	}
1280	**endcpp = savedc;
1281	return (0);
1282}
1283
1284/*
1285 * Translate a character string to the corresponding list of network
1286 * addresses for a hostname.
1287 */
1288int
1289get_host(cp, grp)
1290	char *cp;
1291	struct grouplist *grp;
1292{
1293	struct hostent *hp, *nhp;
1294	char **addrp, **naddrp;
1295	struct hostent t_host;
1296	int i;
1297	u_long saddr;
1298	char *aptr[2];
1299
1300	if (grp->gr_type != GT_NULL)
1301		return (1);
1302	if ((hp = gethostbyname(cp)) == NULL) {
1303		if (isdigit(*cp)) {
1304			saddr = inet_addr(cp);
1305			if (saddr == -1) {
1306				syslog(LOG_ERR, "Inet_addr failed");
1307				return (1);
1308			}
1309			if ((hp = gethostbyaddr((caddr_t)&saddr, sizeof (saddr),
1310				AF_INET)) == NULL) {
1311				hp = &t_host;
1312				hp->h_name = cp;
1313				hp->h_addrtype = AF_INET;
1314				hp->h_length = sizeof (u_long);
1315				hp->h_addr_list = aptr;
1316				aptr[0] = (char *)&saddr;
1317				aptr[1] = (char *)NULL;
1318			}
1319		} else {
1320			syslog(LOG_ERR, "Gethostbyname failed");
1321			return (1);
1322		}
1323	}
1324	grp->gr_type = GT_HOST;
1325	nhp = grp->gr_ptr.gt_hostent = (struct hostent *)
1326		malloc(sizeof(struct hostent));
1327	if (nhp == (struct hostent *)NULL)
1328		out_of_mem();
1329	bcopy((caddr_t)hp, (caddr_t)nhp,
1330		sizeof(struct hostent));
1331	i = strlen(hp->h_name)+1;
1332	nhp->h_name = (char *)malloc(i);
1333	if (nhp->h_name == (char *)NULL)
1334		out_of_mem();
1335	bcopy(hp->h_name, nhp->h_name, i);
1336	addrp = hp->h_addr_list;
1337	i = 1;
1338	while (*addrp++)
1339		i++;
1340	naddrp = nhp->h_addr_list = (char **)
1341		malloc(i*sizeof(char *));
1342	if (naddrp == (char **)NULL)
1343		out_of_mem();
1344	addrp = hp->h_addr_list;
1345	while (*addrp) {
1346		*naddrp = (char *)
1347		    malloc(hp->h_length);
1348		if (*naddrp == (char *)NULL)
1349		    out_of_mem();
1350		bcopy(*addrp, *naddrp,
1351			hp->h_length);
1352		addrp++;
1353		naddrp++;
1354	}
1355	*naddrp = (char *)NULL;
1356	if (debug)
1357		fprintf(stderr, "got host %s\n", hp->h_name);
1358	return (0);
1359}
1360
1361/*
1362 * Free up an exports list component
1363 */
1364void
1365free_exp(ep)
1366	struct exportlist *ep;
1367{
1368
1369	if (ep->ex_defdir) {
1370		free_host(ep->ex_defdir->dp_hosts);
1371		free((caddr_t)ep->ex_defdir);
1372	}
1373	if (ep->ex_fsdir)
1374		free(ep->ex_fsdir);
1375	free_dir(ep->ex_dirl);
1376	free((caddr_t)ep);
1377}
1378
1379/*
1380 * Free hosts.
1381 */
1382void
1383free_host(hp)
1384	struct hostlist *hp;
1385{
1386	struct hostlist *hp2;
1387
1388	while (hp) {
1389		hp2 = hp;
1390		hp = hp->ht_next;
1391		free((caddr_t)hp2);
1392	}
1393}
1394
1395struct hostlist *
1396get_ht()
1397{
1398	struct hostlist *hp;
1399
1400	hp = (struct hostlist *)malloc(sizeof (struct hostlist));
1401	if (hp == (struct hostlist *)NULL)
1402		out_of_mem();
1403	hp->ht_next = (struct hostlist *)NULL;
1404	return (hp);
1405}
1406
1407#ifdef ISO
1408/*
1409 * Translate an iso address.
1410 */
1411get_isoaddr(cp, grp)
1412	char *cp;
1413	struct grouplist *grp;
1414{
1415	struct iso_addr *isop;
1416	struct sockaddr_iso *isoaddr;
1417
1418	if (grp->gr_type != GT_NULL)
1419		return (1);
1420	if ((isop = iso_addr(cp)) == NULL) {
1421		syslog(LOG_ERR,
1422		    "iso_addr failed, ignored");
1423		return (1);
1424	}
1425	isoaddr = (struct sockaddr_iso *)
1426	    malloc(sizeof (struct sockaddr_iso));
1427	if (isoaddr == (struct sockaddr_iso *)NULL)
1428		out_of_mem();
1429	bzero((caddr_t)isoaddr, sizeof (struct sockaddr_iso));
1430	bcopy((caddr_t)isop, (caddr_t)&isoaddr->siso_addr,
1431		sizeof (struct iso_addr));
1432	isoaddr->siso_len = sizeof (struct sockaddr_iso);
1433	isoaddr->siso_family = AF_ISO;
1434	grp->gr_type = GT_ISO;
1435	grp->gr_ptr.gt_isoaddr = isoaddr;
1436	return (0);
1437}
1438#endif	/* ISO */
1439
1440/*
1441 * Out of memory, fatal
1442 */
1443void
1444out_of_mem()
1445{
1446
1447	syslog(LOG_ERR, "Out of memory");
1448	exit(2);
1449}
1450
1451/*
1452 * Do the mount syscall with the update flag to push the export info into
1453 * the kernel.
1454 */
1455int
1456do_mount(ep, grp, exflags, anoncrp, dirp, dirplen, fsb)
1457	struct exportlist *ep;
1458	struct grouplist *grp;
1459	int exflags;
1460	struct ucred *anoncrp;
1461	char *dirp;
1462	int dirplen;
1463	struct statfs *fsb;
1464{
1465	char *cp = (char *)NULL;
1466	u_long **addrp;
1467	int done;
1468	char savedc = '\0';
1469	struct sockaddr_in sin, imask;
1470	union {
1471		struct ufs_args ua;
1472		struct iso_args ia;
1473		struct mfs_args ma;
1474	} args;
1475	u_long net;
1476
1477	args.ua.fspec = 0;
1478	args.ua.export.ex_flags = exflags;
1479	args.ua.export.ex_anon = *anoncrp;
1480	bzero((char *)&sin, sizeof(sin));
1481	bzero((char *)&imask, sizeof(imask));
1482	sin.sin_family = AF_INET;
1483	sin.sin_len = sizeof(sin);
1484	imask.sin_family = AF_INET;
1485	imask.sin_len = sizeof(sin);
1486	if (grp->gr_type == GT_HOST)
1487		addrp = (u_long **)grp->gr_ptr.gt_hostent->h_addr_list;
1488	else
1489		addrp = (u_long **)NULL;
1490	done = FALSE;
1491	while (!done) {
1492		switch (grp->gr_type) {
1493		case GT_HOST:
1494			if (addrp) {
1495				sin.sin_addr.s_addr = **addrp;
1496				args.ua.export.ex_addrlen = sizeof(sin);
1497			} else
1498				args.ua.export.ex_addrlen = 0;
1499			args.ua.export.ex_addr = (struct sockaddr *)&sin;
1500			args.ua.export.ex_masklen = 0;
1501			break;
1502		case GT_NET:
1503			if (grp->gr_ptr.gt_net.nt_mask)
1504			    imask.sin_addr.s_addr = grp->gr_ptr.gt_net.nt_mask;
1505			else {
1506			    net = ntohl(grp->gr_ptr.gt_net.nt_net);
1507			    if (IN_CLASSA(net))
1508				imask.sin_addr.s_addr = inet_addr("255.0.0.0");
1509			    else if (IN_CLASSB(net))
1510				imask.sin_addr.s_addr =
1511				    inet_addr("255.255.0.0");
1512			    else
1513				imask.sin_addr.s_addr =
1514				    inet_addr("255.255.255.0");
1515			    grp->gr_ptr.gt_net.nt_mask = imask.sin_addr.s_addr;
1516			}
1517			sin.sin_addr.s_addr = grp->gr_ptr.gt_net.nt_net;
1518			args.ua.export.ex_addr = (struct sockaddr *)&sin;
1519			args.ua.export.ex_addrlen = sizeof (sin);
1520			args.ua.export.ex_mask = (struct sockaddr *)&imask;
1521			args.ua.export.ex_masklen = sizeof (imask);
1522			break;
1523#ifdef ISO
1524		case GT_ISO:
1525			args.ua.export.ex_addr =
1526				(struct sockaddr *)grp->gr_ptr.gt_isoaddr;
1527			args.ua.export.ex_addrlen =
1528				sizeof(struct sockaddr_iso);
1529			args.ua.export.ex_masklen = 0;
1530			break;
1531#endif	/* ISO */
1532		default:
1533			syslog(LOG_ERR, "Bad grouptype");
1534			if (cp)
1535				*cp = savedc;
1536			return (1);
1537		};
1538
1539		/*
1540		 * XXX:
1541		 * Maybe I should just use the fsb->f_mntonname path instead
1542		 * of looping back up the dirp to the mount point??
1543		 * Also, needs to know how to export all types of local
1544		 * exportable file systems and not just MOUNT_UFS.
1545		 */
1546		while (mount(fsb->f_type, dirp,
1547		       fsb->f_flags | MNT_UPDATE, (caddr_t)&args) < 0) {
1548			if (cp)
1549				*cp-- = savedc;
1550			else
1551				cp = dirp + dirplen - 1;
1552			if (errno == EPERM) {
1553				syslog(LOG_ERR,
1554				   "Can't change attributes for %s.\n", dirp);
1555				return (1);
1556			}
1557			if (opt_flags & OP_ALLDIRS) {
1558				syslog(LOG_ERR, "Could not remount %s: %m",
1559					dirp);
1560				return (1);
1561			}
1562			/* back up over the last component */
1563			while (*cp == '/' && cp > dirp)
1564				cp--;
1565			while (*(cp - 1) != '/' && cp > dirp)
1566				cp--;
1567			if (cp == dirp) {
1568				if (debug)
1569					fprintf(stderr,"mnt unsucc\n");
1570				syslog(LOG_ERR, "Can't export %s", dirp);
1571				return (1);
1572			}
1573			savedc = *cp;
1574			*cp = '\0';
1575		}
1576		if (addrp) {
1577			++addrp;
1578			if (*addrp == (u_long *)NULL)
1579				done = TRUE;
1580		} else
1581			done = TRUE;
1582	}
1583	if (cp)
1584		*cp = savedc;
1585	return (0);
1586}
1587
1588/*
1589 * Translate a net address.
1590 */
1591int
1592get_net(cp, net, maskflg)
1593	char *cp;
1594	struct netmsk *net;
1595	int maskflg;
1596{
1597	struct netent *np;
1598	long netaddr;
1599	struct in_addr inetaddr, inetaddr2;
1600	char *name;
1601
1602	if (np = getnetbyname(cp))
1603		inetaddr = inet_makeaddr(np->n_net, 0);
1604	else if (isdigit(*cp)) {
1605		if ((netaddr = inet_network(cp)) == -1)
1606			return (1);
1607		inetaddr = inet_makeaddr(netaddr, 0);
1608		/*
1609		 * Due to arbritrary subnet masks, you don't know how many
1610		 * bits to shift the address to make it into a network,
1611		 * however you do know how to make a network address into
1612		 * a host with host == 0 and then compare them.
1613		 * (What a pest)
1614		 */
1615		if (!maskflg) {
1616			setnetent(0);
1617			while (np = getnetent()) {
1618				inetaddr2 = inet_makeaddr(np->n_net, 0);
1619				if (inetaddr2.s_addr == inetaddr.s_addr)
1620					break;
1621			}
1622			endnetent();
1623		}
1624	} else
1625		return (1);
1626	if (maskflg)
1627		net->nt_mask = inetaddr.s_addr;
1628	else {
1629		if (np)
1630			name = np->n_name;
1631		else
1632			name = inet_ntoa(inetaddr);
1633		net->nt_name = (char *)malloc(strlen(name) + 1);
1634		if (net->nt_name == (char *)NULL)
1635			out_of_mem();
1636		strcpy(net->nt_name, name);
1637		net->nt_net = inetaddr.s_addr;
1638	}
1639	return (0);
1640}
1641
1642/*
1643 * Parse out the next white space separated field
1644 */
1645void
1646nextfield(cp, endcp)
1647	char **cp;
1648	char **endcp;
1649{
1650	char *p;
1651
1652	p = *cp;
1653	while (*p == ' ' || *p == '\t')
1654		p++;
1655	if (*p == '\n' || *p == '\0')
1656		*cp = *endcp = p;
1657	else {
1658		*cp = p++;
1659		while (*p != ' ' && *p != '\t' && *p != '\n' && *p != '\0')
1660			p++;
1661		*endcp = p;
1662	}
1663}
1664
1665/*
1666 * Get an exports file line. Skip over blank lines and handle line
1667 * continuations.
1668 */
1669int
1670get_line()
1671{
1672	char *p, *cp;
1673	int len;
1674	int totlen, cont_line;
1675
1676	/*
1677	 * Loop around ignoring blank lines and getting all continuation lines.
1678	 */
1679	p = line;
1680	totlen = 0;
1681	do {
1682		if (fgets(p, LINESIZ - totlen, exp_file) == NULL)
1683			return (0);
1684		len = strlen(p);
1685		cp = p + len - 1;
1686		cont_line = 0;
1687		while (cp >= p &&
1688		    (*cp == ' ' || *cp == '\t' || *cp == '\n' || *cp == '\\')) {
1689			if (*cp == '\\')
1690				cont_line = 1;
1691			cp--;
1692			len--;
1693		}
1694		*++cp = '\0';
1695		if (len > 0) {
1696			totlen += len;
1697			if (totlen >= LINESIZ) {
1698				syslog(LOG_ERR, "Exports line too long");
1699				exit(2);
1700			}
1701			p = cp;
1702		}
1703	} while (totlen == 0 || cont_line);
1704	return (1);
1705}
1706
1707/*
1708 * Parse a description of a credential.
1709 */
1710void
1711parsecred(namelist, cr)
1712	char *namelist;
1713	struct ucred *cr;
1714{
1715	char *name;
1716	int cnt;
1717	char *names;
1718	struct passwd *pw;
1719	struct group *gr;
1720	int ngroups, groups[NGROUPS + 1];
1721
1722	/*
1723	 * Set up the unpriviledged user.
1724	 */
1725	cr->cr_ref = 1;
1726	cr->cr_uid = -2;
1727	cr->cr_groups[0] = -2;
1728	cr->cr_ngroups = 1;
1729	/*
1730	 * Get the user's password table entry.
1731	 */
1732	names = strsep(&namelist, " \t\n");
1733	name = strsep(&names, ":");
1734	if (isdigit(*name) || *name == '-')
1735		pw = getpwuid(atoi(name));
1736	else
1737		pw = getpwnam(name);
1738	/*
1739	 * Credentials specified as those of a user.
1740	 */
1741	if (names == NULL) {
1742		if (pw == NULL) {
1743			syslog(LOG_ERR, "Unknown user: %s", name);
1744			return;
1745		}
1746		cr->cr_uid = pw->pw_uid;
1747		ngroups = NGROUPS + 1;
1748		if (getgrouplist(pw->pw_name, pw->pw_gid, groups, &ngroups))
1749			syslog(LOG_ERR, "Too many groups");
1750		/*
1751		 * Convert from int's to gid_t's and compress out duplicate
1752		 */
1753		cr->cr_ngroups = ngroups - 1;
1754		cr->cr_groups[0] = groups[0];
1755		for (cnt = 2; cnt < ngroups; cnt++)
1756			cr->cr_groups[cnt - 1] = groups[cnt];
1757		return;
1758	}
1759	/*
1760	 * Explicit credential specified as a colon separated list:
1761	 *	uid:gid:gid:...
1762	 */
1763	if (pw != NULL)
1764		cr->cr_uid = pw->pw_uid;
1765	else if (isdigit(*name) || *name == '-')
1766		cr->cr_uid = atoi(name);
1767	else {
1768		syslog(LOG_ERR, "Unknown user: %s", name);
1769		return;
1770	}
1771	cr->cr_ngroups = 0;
1772	while (names != NULL && *names != '\0' && cr->cr_ngroups < NGROUPS) {
1773		name = strsep(&names, ":");
1774		if (isdigit(*name) || *name == '-') {
1775			cr->cr_groups[cr->cr_ngroups++] = atoi(name);
1776		} else {
1777			if ((gr = getgrnam(name)) == NULL) {
1778				syslog(LOG_ERR, "Unknown group: %s", name);
1779				continue;
1780			}
1781			cr->cr_groups[cr->cr_ngroups++] = gr->gr_gid;
1782		}
1783	}
1784	if (names != NULL && *names != '\0' && cr->cr_ngroups == NGROUPS)
1785		syslog(LOG_ERR, "Too many groups");
1786}
1787
1788#define	STRSIZ	(RPCMNT_NAMELEN+RPCMNT_PATHLEN+50)
1789/*
1790 * Routines that maintain the remote mounttab
1791 */
1792void
1793get_mountlist()
1794{
1795	struct mountlist *mlp, **mlpp;
1796	char *eos, *dirp;
1797	int len;
1798	char str[STRSIZ];
1799	FILE *mlfile;
1800
1801	if ((mlfile = fopen(_PATH_RMOUNTLIST, "r")) == NULL) {
1802		syslog(LOG_ERR, "Can't open %s", _PATH_RMOUNTLIST);
1803		return;
1804	}
1805	mlpp = &mlhead;
1806	while (fgets(str, STRSIZ, mlfile) != NULL) {
1807		if ((dirp = index(str, '\t')) == NULL &&
1808		    (dirp = index(str, ' ')) == NULL)
1809			continue;
1810		mlp = (struct mountlist *)malloc(sizeof (*mlp));
1811		len = dirp-str;
1812		if (len > RPCMNT_NAMELEN)
1813			len = RPCMNT_NAMELEN;
1814		bcopy(str, mlp->ml_host, len);
1815		mlp->ml_host[len] = '\0';
1816		while (*dirp == '\t' || *dirp == ' ')
1817			dirp++;
1818		if ((eos = index(dirp, '\t')) == NULL &&
1819		    (eos = index(dirp, ' ')) == NULL &&
1820		    (eos = index(dirp, '\n')) == NULL)
1821			len = strlen(dirp);
1822		else
1823			len = eos-dirp;
1824		if (len > RPCMNT_PATHLEN)
1825			len = RPCMNT_PATHLEN;
1826		bcopy(dirp, mlp->ml_dirp, len);
1827		mlp->ml_dirp[len] = '\0';
1828		mlp->ml_next = (struct mountlist *)NULL;
1829		*mlpp = mlp;
1830		mlpp = &mlp->ml_next;
1831	}
1832	fclose(mlfile);
1833}
1834
1835void
1836del_mlist(hostp, dirp)
1837	char *hostp, *dirp;
1838{
1839	struct mountlist *mlp, **mlpp;
1840	struct mountlist *mlp2;
1841	FILE *mlfile;
1842	int fnd = 0;
1843
1844	mlpp = &mlhead;
1845	mlp = mlhead;
1846	while (mlp) {
1847		if (!strcmp(mlp->ml_host, hostp) &&
1848		    (!dirp || !strcmp(mlp->ml_dirp, dirp))) {
1849			fnd = 1;
1850			mlp2 = mlp;
1851			*mlpp = mlp = mlp->ml_next;
1852			free((caddr_t)mlp2);
1853		} else {
1854			mlpp = &mlp->ml_next;
1855			mlp = mlp->ml_next;
1856		}
1857	}
1858	if (fnd) {
1859		if ((mlfile = fopen(_PATH_RMOUNTLIST, "w")) == NULL) {
1860			syslog(LOG_ERR,"Can't update %s", _PATH_RMOUNTLIST);
1861			return;
1862		}
1863		mlp = mlhead;
1864		while (mlp) {
1865			fprintf(mlfile, "%s %s\n", mlp->ml_host, mlp->ml_dirp);
1866			mlp = mlp->ml_next;
1867		}
1868		fclose(mlfile);
1869	}
1870}
1871
1872void
1873add_mlist(hostp, dirp)
1874	char *hostp, *dirp;
1875{
1876	struct mountlist *mlp, **mlpp;
1877	FILE *mlfile;
1878
1879	mlpp = &mlhead;
1880	mlp = mlhead;
1881	while (mlp) {
1882		if (!strcmp(mlp->ml_host, hostp) && !strcmp(mlp->ml_dirp, dirp))
1883			return;
1884		mlpp = &mlp->ml_next;
1885		mlp = mlp->ml_next;
1886	}
1887	mlp = (struct mountlist *)malloc(sizeof (*mlp));
1888	strncpy(mlp->ml_host, hostp, RPCMNT_NAMELEN);
1889	mlp->ml_host[RPCMNT_NAMELEN] = '\0';
1890	strncpy(mlp->ml_dirp, dirp, RPCMNT_PATHLEN);
1891	mlp->ml_dirp[RPCMNT_PATHLEN] = '\0';
1892	mlp->ml_next = (struct mountlist *)NULL;
1893	*mlpp = mlp;
1894	if ((mlfile = fopen(_PATH_RMOUNTLIST, "a")) == NULL) {
1895		syslog(LOG_ERR, "Can't update %s", _PATH_RMOUNTLIST);
1896		return;
1897	}
1898	fprintf(mlfile, "%s %s\n", mlp->ml_host, mlp->ml_dirp);
1899	fclose(mlfile);
1900}
1901
1902/*
1903 * This function is called via. SIGTERM when the system is going down.
1904 * It sends a broadcast RPCMNT_UMNTALL.
1905 */
1906void
1907send_umntall()
1908{
1909	(void) clnt_broadcast(RPCPROG_MNT, RPCMNT_VER1, RPCMNT_UMNTALL,
1910		xdr_void, (caddr_t)0, xdr_void, (caddr_t)0, umntall_each);
1911	exit(0);
1912}
1913
1914int
1915umntall_each(resultsp, raddr)
1916	caddr_t resultsp;
1917	struct sockaddr_in *raddr;
1918{
1919	return (1);
1920}
1921
1922/*
1923 * Free up a group list.
1924 */
1925void
1926free_grp(grp)
1927	struct grouplist *grp;
1928{
1929	char **addrp;
1930
1931	if (grp->gr_type == GT_HOST) {
1932		if (grp->gr_ptr.gt_hostent->h_name) {
1933			addrp = grp->gr_ptr.gt_hostent->h_addr_list;
1934			while (addrp && *addrp)
1935				free(*addrp++);
1936			free((caddr_t)grp->gr_ptr.gt_hostent->h_addr_list);
1937			free(grp->gr_ptr.gt_hostent->h_name);
1938		}
1939		free((caddr_t)grp->gr_ptr.gt_hostent);
1940	} else if (grp->gr_type == GT_NET) {
1941		if (grp->gr_ptr.gt_net.nt_name)
1942			free(grp->gr_ptr.gt_net.nt_name);
1943	}
1944#ifdef ISO
1945	else if (grp->gr_type == GT_ISO)
1946		free((caddr_t)grp->gr_ptr.gt_isoaddr);
1947#endif
1948	free((caddr_t)grp);
1949}
1950
1951#ifdef DEBUG
1952void
1953SYSLOG(int pri, const char *fmt, ...)
1954{
1955	va_list ap;
1956
1957	va_start(ap, fmt);
1958	vfprintf(stderr, fmt, ap);
1959	va_end(ap);
1960}
1961#endif /* DEBUG */
1962
1963/*
1964 * Check options for consistency.
1965 */
1966int
1967check_options(dp)
1968	struct dirlist *dp;
1969{
1970
1971	if (dp == (struct dirlist *)NULL)
1972	    return (1);
1973	if ((opt_flags & (OP_MAPROOT | OP_MAPALL)) == (OP_MAPROOT | OP_MAPALL) ||
1974	    (opt_flags & (OP_MAPROOT | OP_KERB)) == (OP_MAPROOT | OP_KERB) ||
1975	    (opt_flags & (OP_MAPALL | OP_KERB)) == (OP_MAPALL | OP_KERB)) {
1976	    syslog(LOG_ERR, "-mapall, -maproot and -kerb mutually exclusive");
1977	    return (1);
1978	}
1979	if ((opt_flags & OP_MASK) && (opt_flags & OP_NET) == 0) {
1980	    syslog(LOG_ERR, "-mask requires -net");
1981	    return (1);
1982	}
1983	if ((opt_flags & (OP_NET | OP_ISO)) == (OP_NET | OP_ISO)) {
1984	    syslog(LOG_ERR, "-net and -iso mutually exclusive");
1985	    return (1);
1986	}
1987	if ((opt_flags & OP_ALLDIRS) && dp->dp_left) {
1988	    syslog(LOG_ERR, "-alldir has multiple directories");
1989	    return (1);
1990	}
1991	return (0);
1992}
1993
1994/*
1995 * Check an absolute directory path for any symbolic links. Return true
1996 * if no symbolic links are found.
1997 */
1998int
1999check_dirpath(dirp)
2000	char *dirp;
2001{
2002	char *cp;
2003	int ret = 1;
2004	struct stat sb;
2005
2006	cp = dirp + 1;
2007	while (*cp && ret) {
2008		if (*cp == '/') {
2009			*cp = '\0';
2010			if (lstat(dirp, &sb) < 0 ||
2011				(sb.st_mode & S_IFMT) != S_IFDIR)
2012				ret = 0;
2013			*cp = '/';
2014		}
2015		cp++;
2016	}
2017	if (lstat(dirp, &sb) < 0 ||
2018		(sb.st_mode & S_IFMT) != S_IFDIR)
2019		ret = 0;
2020	return (ret);
2021}
2022