struct grouplist *, int, struct exportlist *);

		    struct grouplist *, int, struct exportlist *,

		    struct xucred *, int);

		    struct xucred *, char *, int, struct statfs *);

		    struct xucred *, char *, int, struct statfs *, int, int *);

static struct exportlist	*ex_search(fsid_t *);

static struct exportlist	*ex_search(fsid_t *, struct exportlisthead *);

static void	get_exportlist(void);

static void	free_v4rootexp(void);

static void	get_exportlist_one(int);

static void	get_exportlist(int);

static void	insert_exports(struct exportlist *, struct exportlisthead *);

static void	free_exports(struct exportlisthead *);

static void	read_exportfile(int);

static int	compare_nmount_exportlist(struct iovec *, int, char *);

static int	compare_export(struct exportlist *, struct exportlist *);

static int	compare_cred(struct xucred *, struct xucred *);

static int	compare_secflavor(int *, int *, int);

static void	delete_export(struct iovec *, int, struct statfs *, char *);

				struct exportlist *, int);

		    struct exportlist *, int, struct xucred *, int);

static SLIST_HEAD(, exportlist) exphead = SLIST_HEAD_INITIALIZER(exphead);

#define	EXPHASH(f)	(fnv_32_buf((f), sizeof(fsid_t), 0) % exphashsize)

static SLIST_HEAD(, mountlist) mlhead = SLIST_HEAD_INITIALIZER(mlhead);

static struct exportlisthead *exphead = NULL;

static struct grouplist *grphead;

static struct exportlisthead *oldexphead = NULL;

static int exphashsize = 0;

static SLIST_HEAD(, mountlist) mlhead = SLIST_HEAD_INITIALIZER(&mlhead);

	int attempt_cnt, port_len, port_pos, ret;

	int attempt_cnt, passno, port_len, port_pos, ret;

	while ((c = getopt(argc, argv, "2deh:lnp:rS")) != -1)

	while ((c = getopt(argc, argv, "2deh:Ilnp:rS")) != -1)

	get_exportlist();

	get_exportlist(0);

			get_exportlist();

			get_exportlist(passno);

			ep = ex_search(&fsb.f_fsid);

			ep = ex_search(&fsb.f_fsid, exphead);

	SLIST_FOREACH(ep, &exphead, entries) {

	for (i = 0; i < exphashsize; i++)

		putdef = 0;

		SLIST_FOREACH(ep, &exphead[i], entries) {

		if (put_exlist(ep->ex_dirl, xdrsp, ep->ex_defdir,

			putdef = 0;

			       &putdef, brief))

			if (put_exlist(ep->ex_dirl, xdrsp, ep->ex_defdir,

			goto errout;

				       &putdef, brief))

		if (ep->ex_defdir && putdef == 0 &&

				goto errout;

			put_exlist(ep->ex_defdir, xdrsp, (struct dirlist *)NULL,

			if (ep->ex_defdir && putdef == 0 &&

			&putdef, brief))

				put_exlist(ep->ex_defdir, xdrsp, NULL,

			goto errout;

				&putdef, brief))

	}

				goto errout;

		}

get_exportlist_one(void)

get_exportlist_one(int passno)

	struct grouplist *grp, *tgrp;

	struct grouplist *grp, *tgrp, *savgrp;

					ep = ex_search(&fsb.f_fsid);

					ep = ex_search(&fsb.f_fsid, exphead);

			if (do_mount(ep, grp, exflags, &anon, dirp, dirplen,

			grp->gr_exflags = exflags;

			    &fsb)) {

			grp->gr_anon = anon;

			if (passno == 0 && do_mount(ep, grp, exflags, &anon,

			    dirp, dirplen, &fsb, ep->ex_numsecflavors,

			    ep->ex_secflavors)) {

			 * Since these structures aren't used by mountd,

			 * These structures are used for the "-I" reload,

			 * so save them for that case.  Otherwise, just

			hang_dirp(dirhead, tgrp, ep, opt_flags);

			hang_dirp(dirhead, tgrp, ep, opt_flags, &anon, exflags);

			grp->gr_next = grphead;

			grp->gr_next = ep->ex_grphead;

			grphead = tgrp;

			ep->ex_grphead = tgrp;

				opt_flags);

				opt_flags, &anon, exflags);

			SLIST_INSERT_HEAD(&exphead, ep, entries);

			insert_exports(ep, exphead);

get_exportlist(void)

get_exportlist(int passno)

	struct statfs *fsp, *mntbufp;

	struct statfs *mntbufp;

	struct xvfsconf vfc;

	if (suspend_nfsd != 0)

	MOUNTD_PASSNO("passno", passno);

		(void)nfssvc(NFSSVC_SUSPENDNFSD, NULL);

	 * First, get rid of the old list

	 * Delete the old V4 root dir.

	 */

	SLIST_FOREACH_SAFE(ep, &exphead, entries, ep2) {

		SLIST_REMOVE(&exphead, ep, exportlist, entries);

		free_exp(ep);

	}

	grp = grphead;

	while (grp) {

		tgrp = grp;

		grp = grp->gr_next;

		free_grp(tgrp);

	}

	grphead = (struct grouplist *)NULL;

	/*

	 * and the old V4 root dir.

	/*

	build_iovec(&iov, &iovlen, "fstype", NULL, 0);

	 * and clear flag that notes if a public fh has been exported.

	build_iovec(&iov, &iovlen, "fspath", NULL, 0);

	 */

	build_iovec(&iov, &iovlen, "from", NULL, 0);

	has_publicfh = 0;

	build_iovec(&iov, &iovlen, "update", NULL, 0);

	build_iovec(&iov, &iovlen, "export", &export,

	    sizeof(export));

	build_iovec(&iov, &iovlen, "errmsg", errmsg,

	    sizeof(errmsg));

	 * And delete exports that are in the kernel for all local

	 * For passno == 1, compare the old and new lists updating the kernel

	 * filesystems.

	 * exports for any cases that have changed.

	 * XXX: Should know how to handle all local exportable filesystems.

	 * This call is doing the second pass through the lists.

	 * If it fails, fall back on the bulk reload.

	num = getmntinfo(&mntbufp, MNT_NOWAIT);

	if (passno == 1 && compare_nmount_exportlist(iov, iovlen, errmsg) ==

	    0) {

	if (num > 0) {

		MOUNTD_COMPAREOK("compareok");

		build_iovec(&iov, &iovlen, "fstype", NULL, 0);

		/* Free up the old lists. */

		build_iovec(&iov, &iovlen, "fspath", NULL, 0);

		free_exports(oldexphead);

		build_iovec(&iov, &iovlen, "from", NULL, 0);

	} else {

		build_iovec(&iov, &iovlen, "update", NULL, 0);

		MOUNTD_PASSNO_0("doing passno=0");

		build_iovec(&iov, &iovlen, "export", &export, sizeof(export));

		/*

		build_iovec(&iov, &iovlen, "errmsg", errmsg, sizeof(errmsg));

		 * Clear flag that notes if a public fh has been exported.

	}

		 * It is set by do_mount() if MNT_EXPUBLIC is set for the entry.

		 */

		has_publicfh = 0;

	for (i = 0; i < num; i++) {

		/* exphead == NULL if not yet allocated (first call). */

		fsp = &mntbufp[i];

		if (exphead != NULL) {

		if (getvfsbyname(fsp->f_fstypename, &vfc) != 0) {

			/*

			syslog(LOG_ERR, "getvfsbyname() failed for %s",

			 * First, get rid of the old lists.

			    fsp->f_fstypename);

			 */

			continue;

			free_exports(exphead);

			free_exports(oldexphead);

		 * We do not need to delete "export" flag from

		 * And delete exports that are in the kernel for all local

		 * filesystems that do not have it set.

		 * filesystems.

		 */

		 * XXX: Should know how to handle all local exportable

		if (!(fsp->f_flags & MNT_EXPORTED))

		 * filesystems.

		    continue;

		 */

		/*

		num = getmntinfo(&mntbufp, MNT_NOWAIT);

		 * Do not delete export for network filesystem by

		 * passing "export" arg to nmount().

		/* Allocate hash tables, for first call. */

		 * It only makes sense to do this for local filesystems.

		if (exphead == NULL) {

		 */

			/* Target an average linked list length of 10. */

		if (vfc.vfc_flags & VFCF_NETWORK)

			exphashsize = num / 10;

			continue;

			if (exphashsize < 1)

				exphashsize = 1;

		iov[1].iov_base = fsp->f_fstypename;

			else if (exphashsize > 100000)

		iov[1].iov_len = strlen(fsp->f_fstypename) + 1;

				exphashsize = 100000;

		iov[3].iov_base = fsp->f_mntonname;

			exphead = malloc(exphashsize * sizeof(*exphead));

		iov[3].iov_len = strlen(fsp->f_mntonname) + 1;

			oldexphead = malloc(exphashsize * sizeof(*oldexphead));

		iov[5].iov_base = fsp->f_mntfromname;

			if (exphead == NULL || oldexphead == NULL)

		iov[5].iov_len = strlen(fsp->f_mntfromname) + 1;

				errx(1, "Can't malloc hash tables");

		errmsg[0] = '\0';

			for (i = 0; i < exphashsize; i++) {

		/*

				SLIST_INIT(&exphead[i]);

		 * EXDEV is returned when path exists but is not a

				SLIST_INIT(&oldexphead[i]);

		 * mount point.  May happens if raced with unmount.

			}

		 */

		if (nmount(iov, iovlen, fsp->f_flags) < 0 &&

		    errno != ENOENT && errno != ENOTSUP && errno != EXDEV) {

			syslog(LOG_ERR,

			    "can't delete exports for %s: %m %s",

			    fsp->f_mntonname, errmsg);

		get_exportlist_one();

		get_exportlist_one(passno);

	 * If there was no public fh, clear any previous one set.

	 * Loop through the current list and look for an entry in the old

	 * list.

	 * If found, check to see if it the same.

	 *        If it is not the same, delete and re-export.

	 *        Then mark it done on the old list.

	 * else (not found)

	 *        export it.

	 * Any entries left in the old list after processing must have their

	 * exports deleted.

	if (has_publicfh == 0)

	for (i = 0; i < exphashsize; i++)

		(void) nfssvc(NFSSVC_NOPUBLICFH, NULL);

		SLIST_FOREACH(ep, &exphead[i], entries) {

			MOUNTD_FOREACH_EP("foreach ep", ep->ex_fsdir);

			oep = ex_search(&ep->ex_fs, oldexphead);

			if (oep != NULL) {

				/*

				 * Check the mount paths are the same.

				 * If not, return 1 so that the reload of the

				 * exports will be done in bulk, the

				 * passno == 0 way.

				 */

				MOUNTD_FOUND_OLD_EXP("found old exp");

				if (strcmp(ep->ex_fsdir, oep->ex_fsdir) != 0)

					return (1);

				MOUNTD_SAME_FSDIR("same fsdir");

				/*

				 * Test to see if the entry is the same.

				 * If not the same delete exports and

				 * re-export.

				 */

				if (compare_export(ep, oep) != 0) {

					/*

					 * Clear has_publicfh if if was set

					 * in the old exports, but only if it

					 * has not been set during processing of

					 * the exports for this pass, as

					 * indicated by has_set_publicfh.

					 */

					if (has_set_publicfh == 0 &&

					    (oep->ex_flag & EX_PUBLICFH) != 0)

						has_publicfh = 0;

	/* Resume the nfsd. If they weren't suspended, this is harmless. */

					/* Delete and re-export. */

	(void)nfssvc(NFSSVC_RESUMENFSD, NULL);

					if (statfs(ep->ex_fsdir, &fs) < 0)

						return (1);

					delete_export(iov, iovlen, &fs, errmsg);

					ret = do_export_mount(ep, &fs);

					if (ret != 0)

						return (ret);

				}

				oep->ex_flag |= EX_DONE;

				MOUNTD_EXDONE("exdone");

			} else {

				MOUNTD_NOT_FOUND_SO_EXPORT(

				    "not found so export");

				/* Not found, so do export. */

				if (statfs(ep->ex_fsdir, &fs) < 0)

					return (1);

				ret = do_export_mount(ep, &fs);

				if (ret != 0)

					return (ret);

			}

		}

	/* Delete exports not done. */

	for (i = 0; i < exphashsize; i++)

		SLIST_FOREACH(oep, &oldexphead[i], entries) {

			if ((oep->ex_flag & EX_DONE) == 0) {

				MOUNTD_NOT_DONE_DELETE("not done delete",

					oep->ex_fsdir);

				if (statfs(oep->ex_fsdir, &ofs) >= 0 &&

				    oep->ex_fs.val[0] == ofs.f_fsid.val[0] &&

				    oep->ex_fs.val[1] == ofs.f_fsid.val[1]) {

					MOUNTD_DO_DELETE("do_delete");

					/*

					 * Clear has_publicfh if if was set

					 * in the old exports, but only if it

					 * has not been set during processing of

					 * the exports for this pass, as

					 * indicated by has_set_publicfh.

					 */

					if (has_set_publicfh == 0 &&

					    (oep->ex_flag & EX_PUBLICFH) != 0)

						has_publicfh = 0;

					delete_export(iov, iovlen, &ofs,

					    errmsg);

				}

			}

		}

	/* Do the V4 root exports, as required. */

	grp = NULL;

	if (v4root_ep != NULL)

		grp = v4root_ep->ex_grphead;

	v4root_phase = 2;

	while (v4root_ep != NULL && grp != NULL) {

		MOUNTD_V4ROOT_EXPATH("v4root expath", v4root_dirpath);

		ret = do_mount(v4root_ep, grp, grp->gr_exflags, &grp->gr_anon,

		    v4root_dirpath, strlen(v4root_dirpath), &fs,

		    grp->gr_numsecflavors, grp->gr_secflavors);

		if (ret != 0) {

			v4root_phase = 0;

			return (ret);

		}

		grp = grp->gr_next;

	}

	v4root_phase = 0;

	free_v4rootexp();

	return (0);

}

/*

 * Compare old and current exportlist entries for the fsid and return 0

 * if they are the same, 1 otherwise.

 */

static int

compare_export(struct exportlist *ep, struct exportlist *oep)

{

	struct grouplist *grp, *ogrp;

	if (strcmp(ep->ex_fsdir, oep->ex_fsdir) != 0)

		return (1);

	if ((ep->ex_flag & EX_DEFSET) != (oep->ex_flag & EX_DEFSET))

		return (1);

	if ((ep->ex_defdir != NULL && oep->ex_defdir == NULL) ||

	    (ep->ex_defdir == NULL && oep->ex_defdir != NULL))

		return (1);

	if (ep->ex_defdir != NULL && (ep->ex_defdir->dp_flag & DP_DEFSET) !=

	    (oep->ex_defdir->dp_flag & DP_DEFSET))

		return (1);

	if ((ep->ex_flag & EX_DEFSET) != 0 && (ep->ex_defnumsecflavors !=

	    oep->ex_defnumsecflavors || ep->ex_defexflags !=

	    oep->ex_defexflags || compare_cred(&ep->ex_defanon,

	    &oep->ex_defanon) != 0 || compare_secflavor(ep->ex_defsecflavors,

	    oep->ex_defsecflavors, ep->ex_defnumsecflavors) != 0))

		return (1);

	/* Now, check all the groups. */

	for (ogrp = oep->ex_grphead; ogrp != NULL; ogrp = ogrp->gr_next)

		ogrp->gr_flag = 0;

	for (grp = ep->ex_grphead; grp != NULL; grp = grp->gr_next) {

		for (ogrp = oep->ex_grphead; ogrp != NULL; ogrp =

		    ogrp->gr_next)

			if ((ogrp->gr_flag & GR_FND) == 0 &&

			    grp->gr_numsecflavors == ogrp->gr_numsecflavors &&

			    grp->gr_exflags == ogrp->gr_exflags &&

			    compare_cred(&grp->gr_anon, &ogrp->gr_anon) == 0 &&

			    compare_secflavor(grp->gr_secflavors,

			    ogrp->gr_secflavors, grp->gr_numsecflavors) == 0)

				break;

		if (ogrp != NULL)

			ogrp->gr_flag |= GR_FND;

		else

			return (1);

	}

	for (ogrp = oep->ex_grphead; ogrp != NULL; ogrp = ogrp->gr_next)

		if ((ogrp->gr_flag & GR_FND) == 0)

			return (1);

	return (0);

}

/*

 * Compare to struct xucred's.  Return 0 if the same and 1 otherwise.

 */

static int

compare_cred(struct xucred *cr0, struct xucred *cr1)

{

	int fnd, grp_fnd[XU_NGROUPS], i, j;

	if (cr0->cr_uid != cr1->cr_uid || cr0->cr_ngroups != cr1->cr_ngroups)

		return (1);

	/* Handle common cases. */

	if (cr0->cr_ngroups == 0)

		return (0);

	if (cr0->cr_ngroups == 1) {

		if (cr0->cr_groups[0] == cr1->cr_groups[0])

			return (0);

		return (1);

	}

	if (memcmp(cr0->cr_groups, cr1->cr_groups, sizeof(*cr0->cr_groups) *

	    cr0->cr_ngroups) == 0)

		return (0);

	for (i = 0; i < cr0->cr_ngroups; i++)

		grp_fnd[i] = 0;

	/*

	 * Search through the old and new groups lists, noting matches.

	 * Since there is no ordering and duplicates can exist in the lists,

	 * the algorithm is inefficient.  However cr_ngroups is small and

	 * the common cases are handled above.

	 */

	for (i = 0; i < cr0->cr_ngroups; i++) {

		fnd = 0;

		for (j = 0; j < cr0->cr_ngroups; j++) {

			if (cr0->cr_groups[i] == cr1->cr_groups[j]) {

				grp_fnd[j] = 1;

				fnd = 1;

			}

		}

		if (fnd == 0)

			return (1);

	}

	for (i = 0; i < cr0->cr_ngroups; i++)

		if (grp_fnd[i] == 0)

			return (1);

	return (0);

}

/*

 * Compare two lists of security flavors.  Return 0 if the same and 1 otherwise.

 * This is almost identical to compare_cred(), but I didn't factor out

 * the algorithm, since compare_cred() may need to change if/when more than

 * XU_NGROUPS groups are supported.

 */

static int

compare_secflavor(int *sec1, int *sec2, int nsec)

{

	int fnd, sec_fnd[MAXSECFLAVORS], i, j;

	/* Handle common cases first. */

	if (nsec == 0)

		return (0);

	if (nsec == 1) {

		if (sec1[0] == sec2[0])

			return (0);

		return (1);

	}

	if (memcmp(sec1, sec2, sizeof(*sec1) * nsec) == 0)

		return (0);

	for (i = 0; i < nsec; i++)

		sec_fnd[i] = 0;

	/*

	 * Search the new group list starting at the same position in the

	 * Search through the old and new secflavors lists, noting matches.

	 * Since there is no ordering and duplicates can exist in the lists,

	 * the algorithm is inefficient.  However nsec is small and

	 * the common cases are handled above.

	 */

	for (i = 0; i < nsec; i++) {

		fnd = 0;

		for (j = 0; j < nsec; j++) {

			if (sec1[i] == sec2[j]) {

				sec_fnd[j] = 1;

				fnd = 1;

			}

		}

		if (fnd == 0)

			return (1);

	}

	for (i = 0; i < nsec; i++)

		if (sec_fnd[i] == 0)

			return (1);

	return (0);

}

/*

 * Delete an exports entry.

 */

static void

delete_export(struct iovec *iov, int iovlen, struct statfs *fsp, char *errmsg)

{

	struct xvfsconf vfc;

	if (getvfsbyname(fsp->f_fstypename, &vfc) != 0) {

		syslog(LOG_ERR, "getvfsbyname() failed for %s",

		    fsp->f_fstypename);

		return;

	}

	/*

	 * We do not need to delete "export" flag from

	 * filesystems that do not have it set.

	 */

	if (!(fsp->f_flags & MNT_EXPORTED))

		return;

	/*

	 * Do not delete export for network filesystem by

	 * passing "export" arg to nmount().

	 * It only makes sense to do this for local filesystems.

	 */

	if (vfc.vfc_flags & VFCF_NETWORK)

		return;

	iov[1].iov_base = fsp->f_fstypename;

	iov[1].iov_len = strlen(fsp->f_fstypename) + 1;

	iov[3].iov_base = fsp->f_mntonname;

	iov[3].iov_len = strlen(fsp->f_mntonname) + 1;

	iov[5].iov_base = fsp->f_mntfromname;

	iov[5].iov_len = strlen(fsp->f_mntfromname) + 1;

	errmsg[0] = '\0';

	/*

	 * EXDEV is returned when path exists but is not a

	 * mount point.  May happens if raced with unmount.

	 */

	if (nmount(iov, iovlen, fsp->f_flags) < 0 && errno != ENOENT &&

	    errno != ENOTSUP && errno != EXDEV) {

		syslog(LOG_ERR,

		    "can't delete exports for %s: %m %s",

		    fsp->f_mntonname, errmsg);

	}

ex_search(fsid_t *fsid)

ex_search(fsid_t *fsid, struct exportlisthead *exhp)

	SLIST_FOREACH(ep, &exphead, entries) {

	i = EXPHASH(fsid);

	SLIST_FOREACH(ep, &exhp[i], entries) {

	int flags)

	int flags, struct xucred *anoncrp, int exflags)

			add_dlist(&ep->ex_dirl, dp, grp, flags, ep);

			add_dlist(&ep->ex_dirl, dp, grp, flags, ep, anoncrp,

			    exflags);

	int flags, struct exportlist *ep)

	int flags, struct exportlist *ep, struct xucred *anoncrp, int exflags)

			add_dlist(&dp->dp_left, newdp, grp, flags, ep);

			add_dlist(&dp->dp_left, newdp, grp, flags, ep, anoncrp,

			    exflags);

			add_dlist(&dp->dp_right, newdp, grp, flags, ep);

			add_dlist(&dp->dp_right, newdp, grp, flags, ep, anoncrp,

			    exflags);

    struct xucred *anoncrp, char *dirp, int dirplen, struct statfs *fsb)

    struct xucred *anoncrp, char *dirp, int dirplen, struct statfs *fsb,

    int numsecflavors, int *secflavors)

	eap->ex_numsecflavors = ep->ex_numsecflavors;

	eap->ex_numsecflavors = numsecflavors;

	MOUNTD_DO_MOUNT_NUMSEC("do mount numsec", numsecflavors);

		eap->ex_secflavors[i] = ep->ex_secflavors[i];

		eap->ex_secflavors[i] = secflavors[i];

			else

			else {

	if (*p == '\n' || *p == '\0')

	*cp = p;

		*cp = *endcp = p;

	while (*p != '\0') {

	else {

		if (quot) {

		*cp = p++;

			if (*p == quot)

		while (*p != ' ' && *p != '\t' && *p != '\n' && *p != '\0')

				quot = 0;

			p++;

		} else {

		*endcp = p;

			if (*p == '\\' && *(p + 1) != '\0')

	}

				p++;

			else if (*p == '\'' || *p == '"')

				quot = *p;

			else if (*p == ' ' || *p == '\t')

				break;

		}

		p++;

	};

	*endcp = p;

	names = strsep_quote(&namelist, " \t\n");

	names = namelist;

	name = strsep(&names, ":");

	name = strsep_quote(&names, ":");

		name = strsep(&names, ":");

		name = strsep_quote(&names, ":");