[unix-history] / usr / src / sbin / umount / umount.c

/*-
 * Copyright (c) 1980, 1989 The Regents of the University of California.
 * All rights reserved.
 *
 * %sccs.include.redist.c%
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1980, 1989 The Regents of the University of California.\n\
 All rights reserved.\n";
#endif /* not lint */

#ifndef lint
static char sccsid[] = "@(#)umount.c	5.16 (Berkeley) %G%";
#endif /* not lint */

#include <sys/param.h>
#include <sys/stat.h>
#include <sys/mount.h>

#ifdef NFS
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <netdb.h>
#include <rpc/rpc.h>
#include <rpc/pmap_clnt.h>
#include <rpc/pmap_prot.h>
#include <nfs/rpcv2.h>
#endif

#include <fstab.h>
#include <stdio.h>
#include <string.h>

#ifdef NFS
int xdr_dir();
char *nfshost;
#endif

int	vflag, all, errs, fake;
int	fflag = MNT_NOFORCE;
char	*getmntname();

#define	MNTON	1
#define	MNTFROM	2
#define	MNTTYPE 3

int *typelist, *maketypelist();

main(argc, argv)
	int argc;
	char **argv;
{
	extern char *optarg;
	extern int optind;
	int ch;

	sync();
	while ((ch = getopt(argc, argv, "afFh:t:v")) != EOF)
		switch((char)ch) {
		case 'v':
			vflag++;
			break;
		case 'f':
			fflag = MNT_FORCE;
			break;
		case 'F':
			fake++;
			break;
		case 'a':
			all++;
			break;
		case 't':
			typelist = maketypelist(optarg);
			break;
#ifdef	NFS
		case 'h':
			/* -h flag implies -a, and "-t nfs" if no -t flag */
			nfshost = optarg;
			all++;
			if (typelist == NULL)
				typelist = maketypelist("nfs");
			break;
#endif /* NFS */
		case '?':
		default:
			usage();
			/* NOTREACHED */
		}
	argc -= optind;
	argv += optind;

	if (argc == 0 && !all)
		usage();
	if (all) {
		if (argc > 0)
			usage();
		if (setfsent() == 0)
			perror(FSTAB), exit(1);
		umountall(typelist);
		exit(0);
	} else
		setfsent();
	while (argc > 0) {
		if (umountfs(*argv++, 0) == 0)
			errs++;
		argc--;
	}
	exit(errs);
}

usage()
{
	fprintf(stderr,
		"%s\n%s\n",
		"Usage: umount [-fv] special | node",
#ifndef	NFS
		"    or umount -a[fv] [-t fstypelist]"
#else
		"    or umount -a[fv] [-h host] [-t fstypelist]"
#endif
	      );
	exit(1);
}

umountall(typelist)
	char **typelist;
{
	register struct fstab *fs;
	struct fstab *allocfsent();

	if ((fs = getfsent()) == (struct fstab *)0)
		return;
	fs = allocfsent(fs);
	umountall(typelist);
	if (strcmp(fs->fs_file, "/") == 0) {
		freefsent(fs);
		return;
	}
	if (strcmp(fs->fs_type, FSTAB_RW) &&
	    strcmp(fs->fs_type, FSTAB_RO) &&
	    strcmp(fs->fs_type, FSTAB_RQ)) {
		freefsent(fs);
		return;
	}
	(void) umountfs(fs->fs_file, typelist);
	freefsent(fs);
}

struct fstab *
allocfsent(fs)
	register struct fstab *fs;
{
	register struct fstab *new;
	register char *cp;

	new = (struct fstab *)malloc((unsigned)sizeof (*fs));
	cp = (char *)malloc((unsigned)strlen(fs->fs_file) + 1);
	strcpy(cp, fs->fs_file);
	new->fs_file = cp;
	cp = (char *)malloc((unsigned)strlen(fs->fs_type) + 1);
	strcpy(cp, fs->fs_type);
	new->fs_type = cp;
	cp = (char *)malloc((unsigned)strlen(fs->fs_spec) + 1);
	strcpy(cp, fs->fs_spec);
	new->fs_spec = cp;
	new->fs_passno = fs->fs_passno;
	new->fs_freq = fs->fs_freq;
	return (new);
}

freefsent(fs)
	register struct fstab *fs;
{

	if (fs->fs_file)
		free(fs->fs_file);
	if (fs->fs_spec)
		free(fs->fs_spec);
	if (fs->fs_type)
		free(fs->fs_type);
	free((char *)fs);
}

umountfs(name, typelist)
	char *name;
	int *typelist;
{
	char *mntpt;
	struct stat stbuf;
	int type;
#ifdef NFS
	register CLIENT *clp;
	struct hostent *hp = 0;
	struct sockaddr_in saddr;
	struct timeval pertry, try;
	enum clnt_stat clnt_stat;
	int so = RPC_ANYSOCK;
	char *hostp, *delimp;
#endif /* NFS */

	if (stat(name, &stbuf) < 0) {
		if (getmntname(name, MNTFROM, &type) != 0)
			mntpt = name;
		else if ((mntpt = getmntname(name, MNTON, &type)) == 0) {
			fprintf(stderr, "%s: not currently mounted\n", name);
			return (0);
		}
	} else if ((stbuf.st_mode & S_IFMT) == S_IFBLK) {
		if ((mntpt = getmntname(name, MNTON, &type)) == 0) {
			fprintf(stderr, "%s: not currently mounted\n", name);
			return (0);
		}
	} else if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
		mntpt = name;
		if (getmntname(mntpt, MNTFROM, &type) == 0) {
			fprintf(stderr, "%s: not currently mounted\n", name);
			return (0);
		}
	} else {
		fprintf(stderr, "%s: not a directory or special device\n",
			name);
		return (0);
	}

	if (badtype(type, typelist))
		return(1);
#ifdef NFS
	if ((delimp = index(name, '@')) != NULL) {
		hostp = delimp + 1;
		*delimp = '\0';
		hp = gethostbyname(hostp);
		*delimp = '@';
	} else if ((delimp = index(name, ':')) != NULL) {
		*delimp = '\0';
		hostp = name;
		hp = gethostbyname(hostp);
		name = delimp+1;
		*delimp = ':';
	}

	if (!namematch(hp, nfshost))
		return(1);
#endif	/* NFS */
	if (!fake && unmount(mntpt, fflag) < 0) {
		perror(mntpt);
		return (0);
	}
	if (vflag)
		fprintf(stderr, "%s: Unmounted from %s\n", name, mntpt);

#ifdef	NFS
	if (!fake && hp != NULL && (fflag & MNT_FORCE) == 0) {
		*delimp = '\0';
		bcopy(hp->h_addr,(caddr_t)&saddr.sin_addr,hp->h_length);
		saddr.sin_family = AF_INET;
		saddr.sin_port = 0;
		pertry.tv_sec = 3;
		pertry.tv_usec = 0;
		if ((clp = clntudp_create(&saddr, RPCPROG_MNT, RPCMNT_VER1,
		    pertry, &so)) == NULL) {
			clnt_pcreateerror("Cannot MNT PRC");
			return (1);
		}
		clp->cl_auth = authunix_create_default();
		try.tv_sec = 20;
		try.tv_usec = 0;
		clnt_stat = clnt_call(clp, RPCMNT_UMOUNT, xdr_dir, name,
			xdr_void, (caddr_t)0, try);
		if (clnt_stat != RPC_SUCCESS) {
			clnt_perror(clp, "Bad MNT RPC");
			return (1);
		}
		auth_destroy(clp->cl_auth);
		clnt_destroy(clp);
	}
#endif /* NFS */
	return (1);
}

char *
getmntname(name, what, type)
	char *name;
	int what;
	int *type;
{
	int mntsize, i;
	struct statfs *mntbuf;

	if ((mntsize = getmntinfo(&mntbuf, MNT_NOWAIT)) == 0) {
		perror("umount");
		return (0);
	}
	for (i = 0; i < mntsize; i++) {
		if (what == MNTON && !strcmp(mntbuf[i].f_mntfromname, name)) {
			if (type)
				*type = mntbuf[i].f_type;
			return (mntbuf[i].f_mntonname);
		}
		if (what == MNTFROM && !strcmp(mntbuf[i].f_mntonname, name)) {
			if (type)
				*type = mntbuf[i].f_type;
			return (mntbuf[i].f_mntfromname);
		}
	}
	return (0);
}

static int skipvfs;

badtype(type, typelist)
	int type;
	int *typelist;
{
	if (typelist == 0)
		return(0);
	while (*typelist) {
		if (type == *typelist)
			return(skipvfs);
		typelist++;
	}
	return(!skipvfs);
}

int *
maketypelist(fslist)
	char *fslist;
{
	register char *nextcp;
	register int *av, i;

	if (fslist == NULL)
		return(NULL);
	if (fslist[0] == 'n' && fslist[1] == 'o') {
		fslist += 2;
		skipvfs = 1;
	} else
		skipvfs = 0;
	for (i = 0, nextcp = fslist; *nextcp; nextcp++)
		if (*nextcp == ',')
			i++;
	av = (int *)malloc((i+2) * sizeof(int));
	if (av == NULL)
		return(NULL);
	for (i = 0; fslist; fslist = nextcp) {
		if (nextcp = index(fslist, ','))
			*nextcp++ = '\0';
		if (strcmp(fslist, "ufs") == 0)
			av[i++] = MOUNT_UFS;
		else if (strcmp(fslist, "nfs") == 0)
			av[i++] = MOUNT_NFS;
		else if (strcmp(fslist, "mfs") == 0)
			av[i++] = MOUNT_MFS;
		else if (strcmp(fslist, "pc") == 0)
			av[i++] = MOUNT_PC;
	}
	av[i++] = 0;
	return(av);
}

#ifdef	NFS
namematch(hp, nfshost)
	struct hostent *hp;
	char *nfshost;
{
	register char *cp;
	register char **np;

	if (hp == NULL || nfshost == NULL)
		return(1);
	if (strcasecmp(nfshost, hp->h_name) == 0)
		return(1);
	if (cp = index(hp->h_name, '.')) {
		*cp = '\0';
		if (strcasecmp(nfshost, hp->h_name) == 0)
			return(1);
	}
	for (np = hp->h_aliases; *np; np++) {
		if (strcasecmp(nfshost, *np) == 0)
			return(1);
		if (cp = index(*np, '.')) {
			*cp = '\0';
			if (strcasecmp(nfshost, *np) == 0)
				return(1);
		}
	}
	return(0);
}

/*
 * xdr routines for mount rpc's
 */
xdr_dir(xdrsp, dirp)
	XDR *xdrsp;
	char *dirp;
{
	return (xdr_string(xdrsp, &dirp, RPCMNT_PATHLEN));
}
#endif /* NFS */
Commit	Line	Data
0fc6e47b	1	/*-
724216f4 KM	2	* Copyright (c) 1980, 1989 The Regents of the University of California.
	3	* All rights reserved.
	4	*
0fc6e47b	5	* %sccs.include.redist.c%
8c5eec2f DF	6	*/
	7
	8	#ifndef lint
	9	char copyright[] =
724216f4	10	"@(#) Copyright (c) 1980, 1989 The Regents of the University of California.\n\
8c5eec2f	11	All rights reserved.\n";
724216f4	12	#endif /* not lint */
8c5eec2f	13
7a6d69cb	14	#ifndef lint
6aa97e2e	15	static char sccsid[] = "@(#)umount.c 5.16 (Berkeley) %G%";
724216f4	16	#endif /* not lint */
15de4e1e	17
7a6d69cb	18	#include <sys/param.h>
4efd8d38	19	#include <sys/stat.h>
71799463	20	#include <sys/mount.h>
896b9bf5	21
71799463 KM	22	#ifdef NFS
	23	#include <sys/time.h>
	24	#include <sys/socket.h>
	25	#include <sys/socketvar.h>
	26	#include <netdb.h>
	27	#include <rpc/rpc.h>
	28	#include <rpc/pmap_clnt.h>
	29	#include <rpc/pmap_prot.h>
	30	#include <nfs/rpcv2.h>
896b9bf5 KB	31	#endif
	32
	33	#include <fstab.h>
	34	#include <stdio.h>
	35	#include <string.h>
cfbe3c25	36
71799463	37	#ifdef NFS
71799463	38	int xdr_dir();
f6bc1314	39	char *nfshost;
896b9bf5	40	#endif
f6bc1314 KM	41
f6bc1314 KM	42	int vflag, all, errs, fake;
b368c10d	43	int fflag = MNT_NOFORCE;
896b9bf5 KB	44	char *getmntname();
	45
	46	#define MNTON 1
	47	#define MNTFROM 2
f6bc1314 KM	48	#define MNTTYPE 3
	49
	50	int typelist, maketypelist();
15de4e1e	51
cfbe3c25	52	main(argc, argv)
15de4e1e BJ	53	int argc;
15de4e1e BJ	54	char **argv;
cfbe3c25	55	{
f6bc1314 KM	56	extern char *optarg;
	57	extern int optind;
	58	int ch;
cfbe3c25 BJ	59
cfbe3c25 BJ	60	sync();
f6bc1314 KM	61	while ((ch = getopt(argc, argv, "afFh:t:v")) != EOF)
	62	switch((char)ch) {
	63	case 'v':
	64	vflag++;
	65	break;
	66	case 'f':
	67	fflag = MNT_FORCE;
	68	break;
	69	case 'F':
	70	fake++;
	71	break;
	72	case 'a':
	73	all++;
	74	break;
	75	case 't':
	76	typelist = maketypelist(optarg);
	77	break;
	78	#ifdef NFS
	79	case 'h':
	80	/* -h flag implies -a, and "-t nfs" if no -t flag */
	81	nfshost = optarg;
	82	all++;
	83	if (typelist == NULL)
	84	typelist = maketypelist("nfs");
	85	break;
	86	#endif /* NFS */
	87	case '?':
	88	default:
	89	usage();
	90	/* NOTREACHED */
	91	}
	92	argc -= optind;
	93	argv += optind;
	94
	95	if (argc == 0 && !all)
	96	usage();
15de4e1e	97	if (all) {
f6bc1314 KM	98	if (argc > 0)
f6bc1314 KM	99	usage();
83dfa04a BJ	100	if (setfsent() == 0)
83dfa04a BJ	101	perror(FSTAB), exit(1);
f6bc1314	102	umountall(typelist);
15de4e1e	103	exit(0);
71799463 KM	104	} else
71799463 KM	105	setfsent();
15de4e1e	106	while (argc > 0) {
f6bc1314	107	if (umountfs(*argv++, 0) == 0)
15de4e1e BJ	108	errs++;
15de4e1e BJ	109	argc--;
cfbe3c25	110	}
15de4e1e	111	exit(errs);
cfbe3c25	112	}
15de4e1e	113
f6bc1314 KM	114	usage()
	115	{
	116	fprintf(stderr,
	117	"%s\n%s\n",
	118	"Usage: umount [-fv] special \| node",
	119	#ifndef NFS
	120	" or umount -a[fv] [-t fstypelist]"
	121	#else
	122	" or umount -a[fv] [-h host] [-t fstypelist]"
	123	#endif
	124	);
	125	exit(1);
	126	}
	127
	128	umountall(typelist)
	129	char **typelist;
83dfa04a	130	{
f6bc1314 KM	131	register struct fstab *fs;
f6bc1314 KM	132	struct fstab *allocfsent();
15de4e1e	133
0c6d0430	134	if ((fs = getfsent()) == (struct fstab *)0)
83dfa04a	135	return;
7a6d69cb	136	fs = allocfsent(fs);
f6bc1314	137	umountall(typelist);
7a6d69cb SL	138	if (strcmp(fs->fs_file, "/") == 0) {
7a6d69cb SL	139	freefsent(fs);
83dfa04a	140	return;
7a6d69cb SL	141	}
	142	if (strcmp(fs->fs_type, FSTAB_RW) &&
	143	strcmp(fs->fs_type, FSTAB_RO) &&
	144	strcmp(fs->fs_type, FSTAB_RQ)) {
	145	freefsent(fs);
15de4e1e BJ	146	return;
15de4e1e BJ	147	}
f6bc1314	148	(void) umountfs(fs->fs_file, typelist);
7a6d69cb SL	149	freefsent(fs);
	150	}
	151
	152	struct fstab *
	153	allocfsent(fs)
	154	register struct fstab *fs;
	155	{
	156	register struct fstab *new;
	157	register char *cp;
7a6d69cb	158
0c6d0430	159	new = (struct fstab )malloc((unsigned)sizeof (fs));
896b9bf5	160	cp = (char *)malloc((unsigned)strlen(fs->fs_file) + 1);
7a6d69cb SL	161	strcpy(cp, fs->fs_file);
7a6d69cb SL	162	new->fs_file = cp;
896b9bf5	163	cp = (char *)malloc((unsigned)strlen(fs->fs_type) + 1);
7a6d69cb SL	164	strcpy(cp, fs->fs_type);
7a6d69cb SL	165	new->fs_type = cp;
896b9bf5	166	cp = (char *)malloc((unsigned)strlen(fs->fs_spec) + 1);
7a6d69cb SL	167	strcpy(cp, fs->fs_spec);
	168	new->fs_spec = cp;
	169	new->fs_passno = fs->fs_passno;
	170	new->fs_freq = fs->fs_freq;
	171	return (new);
	172	}
	173
	174	freefsent(fs)
	175	register struct fstab *fs;
	176	{
	177
	178	if (fs->fs_file)
	179	free(fs->fs_file);
	180	if (fs->fs_spec)
	181	free(fs->fs_spec);
	182	if (fs->fs_type)
	183	free(fs->fs_type);
	184	free((char *)fs);
83dfa04a	185	}
cfbe3c25	186
f6bc1314	187	umountfs(name, typelist)
15de4e1e	188	char *name;
f6bc1314	189	int *typelist;
cfbe3c25	190	{
4efd8d38 KM	191	char *mntpt;
4efd8d38 KM	192	struct stat stbuf;
f6bc1314	193	int type;
71799463 KM	194	#ifdef NFS
71799463 KM	195	register CLIENT *clp;
f6bc1314	196	struct hostent *hp = 0;
71799463 KM	197	struct sockaddr_in saddr;
	198	struct timeval pertry, try;
	199	enum clnt_stat clnt_stat;
	200	int so = RPC_ANYSOCK;
71799463	201	char hostp, delimp;
f6bc1314	202	#endif /* NFS */
cfbe3c25	203
4efd8d38	204	if (stat(name, &stbuf) < 0) {
6aa97e2e KM	205	if (getmntname(name, MNTFROM, &type) != 0)
	206	mntpt = name;
	207	else if ((mntpt = getmntname(name, MNTON, &type)) == 0) {
	208	fprintf(stderr, "%s: not currently mounted\n", name);
4efd8d38	209	return (0);
6aa97e2e	210	}
49d93ed5	211	} else if ((stbuf.st_mode & S_IFMT) == S_IFBLK) {
6aa97e2e KM	212	if ((mntpt = getmntname(name, MNTON, &type)) == 0) {
6aa97e2e KM	213	fprintf(stderr, "%s: not currently mounted\n", name);
4efd8d38	214	return (0);
6aa97e2e	215	}
49d93ed5	216	} else if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
4efd8d38	217	mntpt = name;
6aa97e2e KM	218	if (getmntname(mntpt, MNTFROM, &type) == 0) {
6aa97e2e KM	219	fprintf(stderr, "%s: not currently mounted\n", name);
4efd8d38	220	return (0);
6aa97e2e	221	}
4efd8d38	222	} else {
0c6d0430 KM	223	fprintf(stderr, "%s: not a directory or special device\n",
0c6d0430 KM	224	name);
15de4e1e	225	return (0);
cfbe3c25	226	}
f6bc1314 KM	227
	228	if (badtype(type, typelist))
	229	return(1);
	230	#ifdef NFS
	231	if ((delimp = index(name, '@')) != NULL) {
	232	hostp = delimp + 1;
	233	*delimp = '\0';
	234	hp = gethostbyname(hostp);
	235	*delimp = '@';
	236	} else if ((delimp = index(name, ':')) != NULL) {
	237	*delimp = '\0';
	238	hostp = name;
	239	hp = gethostbyname(hostp);
	240	name = delimp+1;
	241	*delimp = ':';
	242	}
	243
	244	if (!namematch(hp, nfshost))
	245	return(1);
	246	#endif /* NFS */
	247	if (!fake && unmount(mntpt, fflag) < 0) {
4efd8d38 KM	248	perror(mntpt);
	249	return (0);
	250	}
	251	if (vflag)
	252	fprintf(stderr, "%s: Unmounted from %s\n", name, mntpt);
f6bc1314 KM	253
	254	#ifdef NFS
	255	if (!fake && hp != NULL && (fflag & MNT_FORCE) == 0) {
4efd8d38	256	*delimp = '\0';
4efd8d38 KM	257	bcopy(hp->h_addr,(caddr_t)&saddr.sin_addr,hp->h_length);
	258	saddr.sin_family = AF_INET;
	259	saddr.sin_port = 0;
	260	pertry.tv_sec = 3;
	261	pertry.tv_usec = 0;
	262	if ((clp = clntudp_create(&saddr, RPCPROG_MNT, RPCMNT_VER1,
	263	pertry, &so)) == NULL) {
	264	clnt_pcreateerror("Cannot MNT PRC");
	265	return (1);
71799463	266	}
4efd8d38 KM	267	clp->cl_auth = authunix_create_default();
	268	try.tv_sec = 20;
	269	try.tv_usec = 0;
	270	clnt_stat = clnt_call(clp, RPCMNT_UMOUNT, xdr_dir, name,
	271	xdr_void, (caddr_t)0, try);
	272	if (clnt_stat != RPC_SUCCESS) {
	273	clnt_perror(clp, "Bad MNT RPC");
	274	return (1);
71799463	275	}
4efd8d38 KM	276	auth_destroy(clp->cl_auth);
4efd8d38 KM	277	clnt_destroy(clp);
760b60ac	278	}
f6bc1314	279	#endif /* NFS */
760b60ac	280	return (1);
cfbe3c25	281	}
71799463	282
4efd8d38	283	char *
f6bc1314	284	getmntname(name, what, type)
4efd8d38 KM	285	char *name;
4efd8d38 KM	286	int what;
f6bc1314	287	int *type;
4efd8d38	288	{
0c6d0430 KM	289	int mntsize, i;
0c6d0430 KM	290	struct statfs *mntbuf;
4efd8d38	291
52f4d3d5	292	if ((mntsize = getmntinfo(&mntbuf, MNT_NOWAIT)) == 0) {
4efd8d38 KM	293	perror("umount");
	294	return (0);
	295	}
4efd8d38	296	for (i = 0; i < mntsize; i++) {
f6bc1314 KM	297	if (what == MNTON && !strcmp(mntbuf[i].f_mntfromname, name)) {
	298	if (type)
	299	*type = mntbuf[i].f_type;
4efd8d38	300	return (mntbuf[i].f_mntonname);
f6bc1314 KM	301	}
	302	if (what == MNTFROM && !strcmp(mntbuf[i].f_mntonname, name)) {
	303	if (type)
	304	*type = mntbuf[i].f_type;
4efd8d38	305	return (mntbuf[i].f_mntfromname);
f6bc1314	306	}
4efd8d38	307	}
4efd8d38 KM	308	return (0);
	309	}
	310
f6bc1314 KM	311	static int skipvfs;
	312
	313	badtype(type, typelist)
	314	int type;
	315	int *typelist;
	316	{
	317	if (typelist == 0)
	318	return(0);
	319	while (*typelist) {
	320	if (type == *typelist)
	321	return(skipvfs);
	322	typelist++;
	323	}
	324	return(!skipvfs);
	325	}
	326
	327	int *
	328	maketypelist(fslist)
	329	char *fslist;
	330	{
	331	register char *nextcp;
	332	register int *av, i;
f6bc1314 KM	333
	334	if (fslist == NULL)
	335	return(NULL);
	336	if (fslist[0] == 'n' && fslist[1] == 'o') {
	337	fslist += 2;
	338	skipvfs = 1;
	339	} else
	340	skipvfs = 0;
	341	for (i = 0, nextcp = fslist; *nextcp; nextcp++)
	342	if (*nextcp == ',')
	343	i++;
	344	av = (int )malloc((i+2) sizeof(int));
	345	if (av == NULL)
	346	return(NULL);
	347	for (i = 0; fslist; fslist = nextcp) {
	348	if (nextcp = index(fslist, ','))
	349	*nextcp++ = '\0';
	350	if (strcmp(fslist, "ufs") == 0)
	351	av[i++] = MOUNT_UFS;
	352	else if (strcmp(fslist, "nfs") == 0)
	353	av[i++] = MOUNT_NFS;
	354	else if (strcmp(fslist, "mfs") == 0)
	355	av[i++] = MOUNT_MFS;
	356	else if (strcmp(fslist, "pc") == 0)
	357	av[i++] = MOUNT_PC;
	358	}
	359	av[i++] = 0;
	360	return(av);
	361	}
	362
	363	#ifdef NFS
	364	namematch(hp, nfshost)
	365	struct hostent *hp;
	366	char *nfshost;
	367	{
	368	register char *cp;
	369	register char **np;
	370
	371	if (hp == NULL \|\| nfshost == NULL)
	372	return(1);
	373	if (strcasecmp(nfshost, hp->h_name) == 0)
	374	return(1);
	375	if (cp = index(hp->h_name, '.')) {
	376	*cp = '\0';
	377	if (strcasecmp(nfshost, hp->h_name) == 0)
	378	return(1);
	379	}
	380	for (np = hp->h_aliases; *np; np++) {
	381	if (strcasecmp(nfshost, *np) == 0)
	382	return(1);
	383	if (cp = index(*np, '.')) {
	384	*cp = '\0';
	385	if (strcasecmp(nfshost, *np) == 0)
	386	return(1);
	387	}
	388	}
	389	return(0);
	390	}
	391
71799463 KM	392	/*
	393	* xdr routines for mount rpc's
	394	*/
	395	xdr_dir(xdrsp, dirp)
	396	XDR *xdrsp;
	397	char *dirp;
	398	{
	399	return (xdr_string(xdrsp, &dirp, RPCMNT_PATHLEN));
	400	}
f6bc1314	401	#endif /* NFS */