1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1980, 1989, 1993
5 *	The Regents of the University of California.  All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 *    may be used to endorse or promote products derived from this software
17 *    without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32#include <sys/param.h>
33#include <sys/mount.h>
34#include <sys/socket.h>
35#include <sys/stat.h>
36
37#include <netdb.h>
38#include <rpc/rpc.h>
39#include <rpcsvc/mount.h>
40#include <nfs/nfssvc.h>
41
42#include <ctype.h>
43#include <err.h>
44#include <errno.h>
45#include <fstab.h>
46#include <stdio.h>
47#include <stdlib.h>
48#include <string.h>
49#include <unistd.h>
50
51#include "mounttab.h"
52
53/* used by md_detach() */
54#include <sys/ioctl.h>
55#include <sys/mdioctl.h>
56#include <fcntl.h>
57#include <paths.h>
58
59#define DEV_MD     _PATH_DEV   MD_NAME
60#define DEV_MDCTL   _PATH_DEV  MDCTL_NAME
61
62typedef enum { FIND, REMOVE, CHECKUNIQUE } dowhat;
63
64static struct addrinfo *nfshost_ai = NULL;
65static int	dflag, fflag, vflag;
66static int	all;
67static char	*nfshost;
68
69struct statfs *checkmntlist(char *);
70int	 checkvfsname (const char *, char **);
71struct statfs *getmntentry(const char *fromname, const char *onname,
72	     fsid_t *fsid, dowhat what);
73char   **makevfslist (const char *);
74size_t	 mntinfo (struct statfs **);
75int	 namematch (struct addrinfo *);
76int	 parsehexfsid(const char *hex, fsid_t *fsid);
77int	 sacmp (void *, void *);
78int	 umountall (char **);
79int	 checkname (char *, char **);
80int	 umountfs(struct statfs *sfs);
81void	 usage (void);
82int	 xdr_dir (XDR *, char *);
83int	 md_detach(const char *);
84
85int
86main(int argc, char *argv[])
87{
88	int errs, ch, mntsize, error, nfsforce, ret;
89	char **typelist = NULL;
90	struct statfs *mntbuf, *sfs;
91	struct addrinfo hints;
92
93	nfsforce = all = errs = 0;
94	while ((ch = getopt(argc, argv, "AadF:fh:Nnt:v")) != -1)
95		switch (ch) {
96		case 'A':
97			all = 2;
98			break;
99		case 'a':
100			all = 1;
101			break;
102		case 'd':
103			dflag = 1;
104			break;
105		case 'F':
106			setfstab(optarg);
107			break;
108		case 'f':
109			fflag |= MNT_FORCE;
110			break;
111		case 'h':	/* -h implies -A. */
112			all = 2;
113			nfshost = optarg;
114			break;
115		case 'N':
116			nfsforce = 1;
117			break;
118		case 'n':
119			fflag |= MNT_NONBUSY;
120			break;
121		case 't':
122			if (typelist != NULL)
123				err(1, "only one -t option may be specified");
124			typelist = makevfslist(optarg);
125			break;
126		case 'v':
127			vflag = 1;
128			break;
129		default:
130			usage();
131			/* NOTREACHED */
132		}
133	argc -= optind;
134	argv += optind;
135
136	if ((fflag & MNT_FORCE) != 0 && (fflag & MNT_NONBUSY) != 0)
137		err(1, "-f and -n are mutually exclusive");
138
139	if ((argc == 0 && !all) || (argc != 0 && all))
140		usage();
141
142	if (nfsforce != 0 && (argc == 0 || nfshost != NULL || typelist != NULL))
143		usage();
144
145	/* -h implies "-t nfs" if no -t flag. */
146	if ((nfshost != NULL) && (typelist == NULL))
147		typelist = makevfslist("nfs");
148
149	if (nfshost != NULL) {
150		memset(&hints, 0, sizeof hints);
151		error = getaddrinfo(nfshost, NULL, &hints, &nfshost_ai);
152		if (error)
153			errx(1, "%s: %s", nfshost, gai_strerror(error));
154	}
155
156	switch (all) {
157	case 2:
158		if ((mntsize = mntinfo(&mntbuf)) <= 0)
159			break;
160		/*
161		 * We unmount the nfs-mounts in the reverse order
162		 * that they were mounted.
163		 */
164		for (errs = 0, mntsize--; mntsize > 0; mntsize--) {
165			sfs = &mntbuf[mntsize];
166			if (checkvfsname(sfs->f_fstypename, typelist))
167				continue;
168			if (strcmp(sfs->f_mntonname, "/dev") == 0)
169				continue;
170			if (umountfs(sfs) != 0)
171				errs = 1;
172		}
173		free(mntbuf);
174		break;
175	case 1:
176		if (setfsent() == 0)
177			err(1, "%s", getfstab());
178		errs = umountall(typelist);
179		break;
180	case 0:
181		for (errs = 0; *argv != NULL; ++argv)
182			if (nfsforce != 0) {
183				/*
184				 * First do the nfssvc() syscall to shut down
185				 * the mount point and then do the forced
186				 * dismount.
187				 */
188				ret = nfssvc(NFSSVC_FORCEDISM, *argv);
189				if (ret >= 0)
190					ret = unmount(*argv, MNT_FORCE);
191				if (ret < 0) {
192					warn("%s", *argv);
193					errs = 1;
194				}
195			} else if (checkname(*argv, typelist) != 0)
196				errs = 1;
197		break;
198	}
199	exit(errs);
200}
201
202int
203umountall(char **typelist)
204{
205	struct xvfsconf vfc;
206	struct fstab *fs;
207	int rval;
208	char *cp;
209	static int firstcall = 1;
210
211	if ((fs = getfsent()) != NULL)
212		firstcall = 0;
213	else if (firstcall)
214		errx(1, "fstab reading failure");
215	else
216		return (0);
217	do {
218		/* Ignore the root. */
219		if (strcmp(fs->fs_file, "/") == 0)
220			continue;
221		/*
222		 * !!!
223		 * Historic practice: ignore unknown FSTAB_* fields.
224		 */
225		if (strcmp(fs->fs_type, FSTAB_RW) &&
226		    strcmp(fs->fs_type, FSTAB_RO) &&
227		    strcmp(fs->fs_type, FSTAB_RQ))
228			continue;
229		/* Ignore unknown file system types. */
230		if (getvfsbyname(fs->fs_vfstype, &vfc) == -1)
231			continue;
232		if (checkvfsname(fs->fs_vfstype, typelist))
233			continue;
234
235		/*
236		 * We want to unmount the file systems in the reverse order
237		 * that they were mounted.  So, we save off the file name
238		 * in some allocated memory, and then call recursively.
239		 */
240		if ((cp = malloc((size_t)strlen(fs->fs_file) + 1)) == NULL)
241			err(1, "malloc failed");
242		(void)strcpy(cp, fs->fs_file);
243		rval = umountall(typelist);
244		rval = checkname(cp, typelist) || rval;
245		free(cp);
246		return (rval);
247	} while ((fs = getfsent()) != NULL);
248	return (0);
249}
250
251/*
252 * Do magic checks on mountpoint/device/fsid, and then call unmount(2).
253 */
254int
255checkname(char *mntname, char **typelist)
256{
257	char buf[MAXPATHLEN];
258	struct statfs sfsbuf;
259	struct stat sb;
260	struct statfs *sfs;
261	char *delimp;
262	dev_t dev;
263	int len;
264
265	/*
266	 * 1. Check if the name exists in the mounttable.
267	 */
268	sfs = checkmntlist(mntname);
269	/*
270	 * 2. Remove trailing slashes if there are any. After that
271	 * we look up the name in the mounttable again.
272	 */
273	if (sfs == NULL) {
274		len = strlen(mntname);
275		while (len > 1 && mntname[len - 1] == '/')
276			mntname[--len] = '\0';
277		sfs = checkmntlist(mntname);
278	}
279	/*
280	 * 3. Check if the deprecated NFS syntax with an '@' has been used
281	 * and translate it to the ':' syntax. Look up the name in the
282	 * mount table again.
283	 */
284	if (sfs == NULL && (delimp = strrchr(mntname, '@')) != NULL) {
285		snprintf(buf, sizeof(buf), "%s:%.*s", delimp + 1,
286		    (int)(delimp - mntname), mntname);
287		len = strlen(buf);
288		while (len > 1 && buf[len - 1] == '/')
289			buf[--len] = '\0';
290		sfs = checkmntlist(buf);
291	}
292	/*
293	 * 4. Resort to a statfs(2) call. This is the last check so that
294	 * hung NFS filesystems for example can be unmounted without
295	 * potentially blocking forever in statfs() as long as the
296	 * filesystem is specified unambiguously. This covers all the
297	 * hard cases such as symlinks and mismatches between the
298	 * mount list and reality.
299	 * We also do this if an ambiguous mount point was specified.
300	 */
301	if (sfs == NULL || (getmntentry(NULL, mntname, NULL, FIND) != NULL &&
302	    getmntentry(NULL, mntname, NULL, CHECKUNIQUE) == NULL)) {
303		if (statfs(mntname, &sfsbuf) != 0) {
304			warn("%s: statfs", mntname);
305		} else if (stat(mntname, &sb) != 0) {
306			warn("%s: stat", mntname);
307		} else if (S_ISDIR(sb.st_mode)) {
308			/* Check that `mntname' is the root directory. */
309			dev = sb.st_dev;
310			snprintf(buf, sizeof(buf), "%s/..", mntname);
311			if (stat(buf, &sb) != 0) {
312				warn("%s: stat", buf);
313			} else if (sb.st_dev == dev) {
314				warnx("%s: not a file system root directory",
315				    mntname);
316				return (1);
317			} else
318				sfs = &sfsbuf;
319		}
320	}
321	if (sfs == NULL) {
322		warnx("%s: unknown file system", mntname);
323		return (1);
324	}
325	if (checkvfsname(sfs->f_fstypename, typelist))
326		return (1);
327	return (umountfs(sfs));
328}
329
330/*
331 * NFS stuff and unmount(2) call
332 */
333int
334umountfs(struct statfs *sfs)
335{
336	char fsidbuf[64];
337	enum clnt_stat clnt_stat;
338	struct timeval try;
339	struct addrinfo *ai, hints;
340	int do_rpc;
341	CLIENT *clp;
342	char *nfsdirname, *orignfsdirname;
343	char *hostp, *delimp;
344	char buf[1024];
345	struct nfscl_dumpmntopts dumpmntopts;
346	const char *proto_ptr = NULL;
347
348	ai = NULL;
349	do_rpc = 0;
350	hostp = NULL;
351	nfsdirname = delimp = orignfsdirname = NULL;
352	memset(&hints, 0, sizeof hints);
353
354	if (strcmp(sfs->f_fstypename, "nfs") == 0) {
355		if ((nfsdirname = strdup(sfs->f_mntfromname)) == NULL)
356			err(1, "strdup");
357		orignfsdirname = nfsdirname;
358		if (*nfsdirname == '[' &&
359		    (delimp = strchr(nfsdirname + 1, ']')) != NULL &&
360		    *(delimp + 1) == ':') {
361			hostp = nfsdirname + 1;
362			nfsdirname = delimp + 2;
363		} else if ((delimp = strrchr(nfsdirname, ':')) != NULL) {
364			hostp = nfsdirname;
365			nfsdirname = delimp + 1;
366		}
367		if (hostp != NULL) {
368			*delimp = '\0';
369			getaddrinfo(hostp, NULL, &hints, &ai);
370			if (ai == NULL) {
371				warnx("can't get net id for host");
372			}
373		}
374
375		/*
376		 * Check if we have to start the rpc-call later.
377		 * If there are still identical nfs-names mounted,
378		 * we skip the rpc-call. Obviously this has to
379		 * happen before unmount(2), but it should happen
380		 * after the previous namecheck.
381		 * A non-NULL return means that this is the last
382		 * mount from mntfromname that is still mounted.
383		 */
384		if (getmntentry(sfs->f_mntfromname, NULL, NULL,
385		    CHECKUNIQUE) != NULL) {
386			do_rpc = 1;
387			proto_ptr = "udp";
388			/*
389			 * Try and find out whether this NFS mount is NFSv4 and
390			 * what protocol is being used. If this fails, the
391			 * default is NFSv2,3 and use UDP for the Unmount RPC.
392			 */
393			dumpmntopts.ndmnt_fname = sfs->f_mntonname;
394			dumpmntopts.ndmnt_buf = buf;
395			dumpmntopts.ndmnt_blen = sizeof(buf);
396			if (nfssvc(NFSSVC_DUMPMNTOPTS, &dumpmntopts) >= 0) {
397				if (strstr(buf, "nfsv4,") != NULL)
398					do_rpc = 0;
399				else if (strstr(buf, ",tcp,") != NULL)
400					proto_ptr = "tcp";
401			}
402		}
403	}
404
405	if (!namematch(ai)) {
406		free(orignfsdirname);
407		return (1);
408	}
409	/* First try to unmount using the file system ID. */
410	snprintf(fsidbuf, sizeof(fsidbuf), "FSID:%d:%d", sfs->f_fsid.val[0],
411	    sfs->f_fsid.val[1]);
412	if (unmount(fsidbuf, fflag | MNT_BYFSID) != 0) {
413		/* XXX, non-root users get a zero fsid, so don't warn. */
414		if (errno != ENOENT || sfs->f_fsid.val[0] != 0 ||
415		    sfs->f_fsid.val[1] != 0)
416			warn("unmount of %s failed", sfs->f_mntonname);
417		if (errno != ENOENT) {
418			free(orignfsdirname);
419			return (1);
420		}
421		/* Compatibility for old kernels. */
422		if (sfs->f_fsid.val[0] != 0 || sfs->f_fsid.val[1] != 0)
423			warnx("retrying using path instead of file system ID");
424		if (unmount(sfs->f_mntonname, fflag) != 0) {
425			warn("unmount of %s failed", sfs->f_mntonname);
426			free(orignfsdirname);
427			return (1);
428		}
429	}
430	/* Mark this file system as unmounted. */
431	getmntentry(NULL, NULL, &sfs->f_fsid, REMOVE);
432	if (vflag)
433		(void)printf("%s: unmount from %s\n", sfs->f_mntfromname,
434		    sfs->f_mntonname);
435	/*
436	 * Report to mountd-server which nfsname
437	 * has been unmounted.
438	 */
439	if (ai != NULL && !(fflag & MNT_FORCE) && do_rpc) {
440		clp = clnt_create(hostp, MOUNTPROG, MOUNTVERS3, proto_ptr);
441		if (clp  == NULL) {
442			warnx("%s: %s", hostp,
443			    clnt_spcreateerror("MOUNTPROG"));
444			free(orignfsdirname);
445			return (1);
446		}
447		clp->cl_auth = authsys_create_default();
448		try.tv_sec = 20;
449		try.tv_usec = 0;
450		clnt_stat = clnt_call(clp, MOUNTPROC_UMNT, (xdrproc_t)xdr_dir,
451		    nfsdirname, (xdrproc_t)xdr_void, (caddr_t)0, try);
452		if (clnt_stat != RPC_SUCCESS) {
453			warnx("%s: %s", hostp,
454			    clnt_sperror(clp, "RPCMNT_UMOUNT"));
455			free(orignfsdirname);
456			return (1);
457		}
458		/*
459		 * Remove the unmounted entry from /var/db/mounttab.
460		 */
461		if (read_mtab()) {
462			clean_mtab(hostp, nfsdirname, vflag);
463			if(!write_mtab(vflag))
464				warnx("cannot remove mounttab entry %s:%s",
465				    hostp, nfsdirname);
466			free_mtab();
467		}
468		auth_destroy(clp->cl_auth);
469		clnt_destroy(clp);
470	}
471	free(orignfsdirname);
472
473	if (dflag) {
474		if (md_detach(sfs->f_mntfromname) == 0) {
475			if (vflag)
476				(void)printf("%s: detached\n",
477				    sfs->f_mntfromname);
478		} else if (!all)
479			return (-1);
480	}
481
482	return (0);
483}
484
485struct statfs *
486getmntentry(const char *fromname, const char *onname, fsid_t *fsid, dowhat what)
487{
488	static struct statfs *mntbuf;
489	static size_t mntsize = 0;
490	static int *mntcheck = NULL;
491	struct statfs *sfs, *foundsfs;
492	int i, count;
493
494	if (mntsize <= 0) {
495		if ((mntsize = mntinfo(&mntbuf)) <= 0)
496			return (NULL);
497	}
498	if (mntcheck == NULL) {
499		if ((mntcheck = calloc(mntsize + 1, sizeof(int))) == NULL)
500			err(1, "calloc");
501	}
502	/*
503	 * We want to get the file systems in the reverse order
504	 * that they were mounted. Unmounted file systems are marked
505	 * in a table called 'mntcheck'.
506	 */
507	count = 0;
508	foundsfs = NULL;
509	for (i = mntsize - 1; i >= 0; i--) {
510		if (mntcheck[i])
511			continue;
512		sfs = &mntbuf[i];
513		if (fromname != NULL && strcmp(sfs->f_mntfromname,
514		    fromname) != 0)
515			continue;
516		if (onname != NULL && strcmp(sfs->f_mntonname, onname) != 0)
517			continue;
518		if (fsid != NULL && fsidcmp(&sfs->f_fsid, fsid) != 0)
519			continue;
520
521		switch (what) {
522		case CHECKUNIQUE:
523			foundsfs = sfs;
524			count++;
525			continue;
526		case REMOVE:
527			mntcheck[i] = 1;
528			break;
529		default:
530			break;
531		}
532		return (sfs);
533	}
534
535	if (what == CHECKUNIQUE && count == 1)
536		return (foundsfs);
537	return (NULL);
538}
539
540int
541sacmp(void *sa1, void *sa2)
542{
543	void *p1, *p2;
544	int len;
545
546	if (((struct sockaddr *)sa1)->sa_family !=
547	    ((struct sockaddr *)sa2)->sa_family)
548		return (1);
549
550	switch (((struct sockaddr *)sa1)->sa_family) {
551	case AF_INET:
552		p1 = &((struct sockaddr_in *)sa1)->sin_addr;
553		p2 = &((struct sockaddr_in *)sa2)->sin_addr;
554		len = 4;
555		break;
556	case AF_INET6:
557		p1 = &((struct sockaddr_in6 *)sa1)->sin6_addr;
558		p2 = &((struct sockaddr_in6 *)sa2)->sin6_addr;
559		len = 16;
560		if (((struct sockaddr_in6 *)sa1)->sin6_scope_id !=
561		    ((struct sockaddr_in6 *)sa2)->sin6_scope_id)
562			return (1);
563		break;
564	default:
565		return (1);
566	}
567
568	return memcmp(p1, p2, len);
569}
570
571int
572namematch(struct addrinfo *ai)
573{
574	struct addrinfo *aip;
575
576	if (nfshost == NULL || nfshost_ai == NULL)
577		return (1);
578
579	while (ai != NULL) {
580		aip = nfshost_ai;
581		while (aip != NULL) {
582			if (sacmp(ai->ai_addr, aip->ai_addr) == 0)
583				return (1);
584			aip = aip->ai_next;
585		}
586		ai = ai->ai_next;
587	}
588
589	return (0);
590}
591
592struct statfs *
593checkmntlist(char *mntname)
594{
595	struct statfs *sfs;
596	fsid_t fsid;
597
598	sfs = NULL;
599	if (parsehexfsid(mntname, &fsid) == 0)
600		sfs = getmntentry(NULL, NULL, &fsid, FIND);
601	if (sfs == NULL)
602		sfs = getmntentry(NULL, mntname, NULL, FIND);
603	if (sfs == NULL)
604		sfs = getmntentry(mntname, NULL, NULL, FIND);
605	return (sfs);
606}
607
608size_t
609mntinfo(struct statfs **mntbuf)
610{
611	static struct statfs *origbuf;
612	size_t bufsize;
613	int mntsize;
614
615	mntsize = getfsstat(NULL, 0, MNT_NOWAIT);
616	if (mntsize <= 0)
617		return (0);
618	bufsize = (mntsize + 1) * sizeof(struct statfs);
619	if ((origbuf = malloc(bufsize)) == NULL)
620		err(1, "malloc");
621	mntsize = getfsstat(origbuf, (long)bufsize, MNT_NOWAIT);
622	*mntbuf = origbuf;
623	return (mntsize);
624}
625
626/*
627 * Convert a hexadecimal filesystem ID to an fsid_t.
628 * Returns 0 on success.
629 */
630int
631parsehexfsid(const char *hex, fsid_t *fsid)
632{
633	char hexbuf[3];
634	int i;
635
636	if (strlen(hex) != sizeof(*fsid) * 2)
637		return (-1);
638	hexbuf[2] = '\0';
639	for (i = 0; i < (int)sizeof(*fsid); i++) {
640		hexbuf[0] = hex[i * 2];
641		hexbuf[1] = hex[i * 2 + 1];
642		if (!isxdigit(hexbuf[0]) || !isxdigit(hexbuf[1]))
643			return (-1);
644		((u_char *)fsid)[i] = strtol(hexbuf, NULL, 16);
645	}
646	return (0);
647}
648
649/*
650 * xdr routines for mount rpc's
651 */
652int
653xdr_dir(XDR *xdrsp, char *dirp)
654{
655
656	return (xdr_string(xdrsp, &dirp, MNTPATHLEN));
657}
658
659void
660usage(void)
661{
662
663	(void)fprintf(stderr, "%s\n%s\n",
664	    "usage: umount [-dfNnv] special ... | node ... | fsid ...",
665	    "       umount -a | -A [-F fstab] [-dfnv] [-h host] [-t type]");
666	exit(1);
667}
668
669int
670md_detach(const char *device)
671{
672	struct md_ioctl mdio;
673	char *eptr;
674	int fd;
675
676	if (strncmp(device, DEV_MD, sizeof(DEV_MD) - 1)) {
677		if (!all)
678			warnx("invalid md device: %s", device);
679		return (-1);
680	}
681
682	memset(&mdio, 0, sizeof(mdio));
683	mdio.md_version = MDIOVERSION;
684	mdio.md_options = fflag ? MD_FORCE : 0;
685	mdio.md_unit = strtoul(device + sizeof(DEV_MD) - 1, &eptr, 0);
686	if (mdio.md_unit == (unsigned)ULONG_MAX || eptr - device == sizeof(DEV_MD) - 1) {
687		warnx("invalid md device: %s", device);
688		return (-1);
689	}
690
691	fd = open(DEV_MDCTL, O_RDWR, 0);
692	if (fd < 0) {
693		warn("%s", DEV_MDCTL);
694		return (-1);
695	}
696
697	if (ioctl(fd, MDIOCDETACH, &mdio) < 0) {
698		warn("%s", DEV_MD);
699		close(fd);
700		return (-1);
701	}
702
703	close(fd);
704	return (0);
705}
706