/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Use is subject to license terms.

 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/

/*	  All Rights Reserved  	*/

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include	<stdio.h>

#include	<stdio_ext.h>

#include	<limits.h>

#include	<unistd.h>

#include	<stdlib.h>

#include	<string.h>

#include	<sys/signal.h>

#include	<sys/mnttab.h>

#include	<errno.h>

#include	<sys/types.h>

#include	<sys/stat.h>

#include	<sys/param.h>

#include	<sys/wait.h>

#include	<sys/vfstab.h>

#include	<sys/fcntl.h>

#include	<sys/resource.h>

#include	<sys/mntent.h>

#include	<sys/ctfs.h>

#include	<locale.h>

#include	<stdarg.h>

#include	<sys/mount.h>

#include	<sys/objfs.h>

#include	"fslib.h"

#define	FS_PATH		"/usr/lib/fs"

#define	ALT_PATH	"/etc/fs"

#define	FULLPATH_MAX	32

#define	FSTYPE_MAX	8

#define	ARGV_MAX	16

int	aflg, oflg, Vflg, dashflg, dflg, fflg;

extern void	rpterr(), usage(), mnterror();

extern	char	*optarg;	/* used by getopt */

extern	int	optind, opterr;

static char	*myname;

char	fs_path[] = FS_PATH;

char	alt_path[] = ALT_PATH;

char	mnttab[MAXPATHLEN + 1];

char	*oarg, *farg;

int	maxrun, nrun;

int	no_mnttab;

int	lofscnt;		/* presence of lofs prohibits parallel */

				/* umounting */

int	exitcode;

char	resolve[MAXPATHLEN];

static  char ibuf[BUFSIZ];

/*

 * Currently, mounting cachefs's simultaneous uncovers various problems.

 * For the short term, we serialize cachefs activity while we fix

 * these cachefs bugs.

 */

#define	CACHEFS_BUG

#ifdef	CACHEFS_BUG

#include	<sys/fs/cachefs_fs.h>	/* for BACKMNT_NAME */

int	cachefs_running;	/* parallel cachefs not supported yet */

#endif

/*

 * The basic mount struct that describes an mnttab entry.

 * It is used both in an array and as a linked list elem.

 */

typedef struct mountent {

	struct mnttab	ment;		/* the mnttab data */

	int		mlevel;		/* mount level of the mount pt */

	pid_t		pid;		/* the pid of this mount process */

#define	RDPIPE		0

#define	WRPIPE		1

	int		sopipe[2];	/* pipe attached to child's stdout */

	int		sepipe[2];	/* pipe attached to child's stderr */

	struct mountent *link;		/* used when in linked list */

} mountent_t;

static mountent_t	*mntll;		/* head of global linked list of */

					/* mountents */

int			listlength;	/* # of elems in this list */

/*

 * If the automatic flag (-a) is given and mount points are not specified

 * on the command line, then do not attempt to umount these.  These

 * generally need to be kept mounted until system shutdown.

 */

static const char   *keeplist[] = {

	"/",

	"/dev",

	"/dev/fd",

	"/devices",

	"/etc/mnttab",

	"/etc/svc/volatile",

	"/lib",

	"/proc",

	"/sbin",

	CTFS_ROOT,

	OBJFS_ROOT,

	"/tmp",

	"/usr",

	"/var",

	"/var/adm",

	"/var/run",

	NULL

};

static void	nomem();

static void	doexec(struct mnttab *);

static int	setup_iopipe(mountent_t *);

static void	setup_output(mountent_t *);

static void	doio(mountent_t *);

static void	do_umounts(mountent_t **);

static int	dowait();

static int	parumount();

static int	mcompar(const void *, const void *);

static void	cleanup(int);

static mountent_t	**make_mntarray(char **, int);

static mountent_t	*getmntall();

static mountent_t 	*new_mountent(struct mnttab *);

static mountent_t	*getmntlast(mountent_t *, char *, char *);

int

main(int argc, char **argv)

{

	int 	cc;

	struct mnttab  mget;

	char 	*mname, *is_special;

	int	fscnt;

	mountent_t	*mp;

	(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)

#define	TEXT_DOMAIN "SYS_TEST"

#endif

	(void) textdomain(TEXT_DOMAIN);

	myname = strrchr(argv[0], '/');

	if (myname)

		myname++;

	else

		myname = argv[0];

	/*

	 * Process the args.

	 * "-d" for compatibility

	 */

	while ((cc = getopt(argc, argv, "ado:Vf?")) != -1)

		switch (cc) {

		case 'a':

			aflg++;

			break;

#ifdef DEBUG

		case 'd':

			dflg++;

			break;

#endif

		case '?':

			usage();

			break;

		case 'o':

			if (oflg)

				usage();

			else {

				oflg++;

				oarg = optarg;

			}

			break;

		case 'f':

			fflg++;

			break;

		case 'V':

			if (Vflg)

				usage();

			else

				Vflg++;

			break;

		default:

			usage();

			break;

		}

	fscnt = argc - optind;

	if (!aflg && fscnt != 1)

		usage();

	/* copy '--' to specific */

	if (strcmp(argv[optind-1], "--") == 0)

		dashflg++;

	/*

	 * mnttab may be a symlink to a file in another file system.

	 * This happens during install when / is mounted read-only

	 * and /etc/mnttab is symlinked to a file in /tmp.

	 * If this is the case, we need to follow the symlink to the

	 * read-write file itself so that the subsequent mnttab.temp

	 * open and rename will work.

	 */

	if (realpath(MNTTAB, mnttab) == NULL) {

		strcpy(mnttab, MNTTAB);

	}

	/*

	 * bugid 1205242

	 * call the realpath() here, so that if the user is

	 * trying to umount an autofs directory, the directory

	 * is forced to mount.

	 */

	mname = argv[optind];

	is_special = realpath(mname, resolve);

	/*

	 * Read the whole mnttab into memory.

	 */

	mntll = getmntall();

	if (aflg && fscnt != 1)

		exit(parumount(argv + optind, fscnt));

	aflg = 0;

	mntnull(&mget);

	if (listlength == 0) {

		fprintf(stderr, gettext(

			"%s: warning: no entries found in %s\n"),

				myname, mnttab);

		mget.mnt_mountp = mname;	/* assume mount point */

		no_mnttab++;

		doexec(&mget);

		exit(0);

	}

	mp = NULL;

	/*

	 * if realpath fails, it can't be a mount point, so we'll

	 * go straight to the code that treats the arg as a special.

	 * if realpath succeeds, it could be a special or a mount point;

	 * we'll start by assuming it's a mount point, and if it's not,

	 * try to treat it as a special.

	 */

	if (is_special != NULL) {

		/*

		 * if this succeeds,

		 * we'll have the appropriate record; if it fails

		 * we'll assume the arg is a special of some sort

		 */

		mp = getmntlast(mntll, NULL, resolve);

	}

	/*

	 * Since stackable mount is allowed (RFE 2001535),

	 * we will un-mount the last entry in the MNTTAB that matches.

	 */

	if (mp == NULL) {

		/*

		 * Perhaps there is a bogus mnttab entry that

		 * can't be resolved:

		 */

		if ((mp = getmntlast(mntll, NULL, mname)) == NULL)

			/*

			 * assume it's a device (special) now

			 */

			mp = getmntlast(mntll, mname, NULL);

		if (mp) {

			/*

			 * Found it.

			 * This is a device. Now we want to know if

			 * it stackmounted on by something else.

			 * The original fix for bug 1103850 has a

			 * problem with lockfs (bug 1119731). This

			 * is a revised method.

			 */

			mountent_t *lmp;

			lmp = getmntlast(mntll, NULL, mp->ment.mnt_mountp);

			if (lmp && strcmp(lmp->ment.mnt_special,

					mp->ment.mnt_special)) {

				errno = EBUSY;

				rpterr(mname);

				exit(1);

			}

		} else {

			fprintf(stderr, gettext(

				"%s: warning: %s not in mnttab\n"),

				myname, mname);

			if (Vflg)

				exit(1);

				/*

				 * same error as mount -V

				 * would give for unknown

				 * mount point

				 */

			mget.mnt_special = mget.mnt_mountp = mname;

		}

	}

	if (mp)

		doexec(&mp->ment);

	else

		doexec(&mget);

	return (0);

}

void

doexec(struct mnttab *ment)

{

	int 	ret;

#ifdef DEBUG

	if (dflg)

		fprintf(stderr, "%d: umounting %s\n",

			getpid(), ment->mnt_mountp);

#endif

	/* try to exec the dependent portion */

	if ((ment->mnt_fstype != NULL) || Vflg) {

		char	full_path[FULLPATH_MAX];

		char	alter_path[FULLPATH_MAX];

		char	*newargv[ARGV_MAX];

		int 	ii;

		if (strlen(ment->mnt_fstype) > (size_t)FSTYPE_MAX) {

			fprintf(stderr, gettext(

				"%s: FSType %s exceeds %d characters\n"),

				myname, ment->mnt_fstype, FSTYPE_MAX);

			exit(1);

		}

		/* build the full pathname of the fstype dependent command. */

		sprintf(full_path, "%s/%s/%s", fs_path, ment->mnt_fstype,

					myname);

		sprintf(alter_path, "%s/%s/%s", alt_path, ment->mnt_fstype,

					myname);

		/*

		 * create the new arg list, and end the list with a

		 * null pointer

		 */

		ii = 2;

		if (oflg) {

			newargv[ii++] = "-o";

			newargv[ii++] = oarg;

		}

		if (dashflg) {

			newargv[ii++] = "--";

		}

		if (fflg) {

			newargv[ii++] = "-f";

		}

		newargv[ii++] = (ment->mnt_mountp)

				? ment->mnt_mountp : ment->mnt_special;

		newargv[ii] = NULL;

		/* set the new argv[0] to the filename */

		newargv[1] = myname;

		if (Vflg) {

			printf("%s", myname);

			for (ii = 2; newargv[ii]; ii++)

				printf(" %s", newargv[ii]);

			printf("\n");

			fflush(stdout);

			exit(0);

		}

		/* Try to exec the fstype dependent umount. */

		execv(full_path, &newargv[1]);

		if (errno == ENOEXEC) {

			newargv[0] = "sh";

			newargv[1] = full_path;

			execv("/sbin/sh", &newargv[0]);

		}

		newargv[1] = myname;

		execv(alter_path, &newargv[1]);

		if (errno == ENOEXEC) {

			newargv[0] = "sh";

			newargv[1] = alter_path;

			execv("/sbin/sh", &newargv[0]);

		}

		/* exec failed */

		if (errno != ENOENT) {

			fprintf(stderr, gettext("umount: cannot execute %s\n"),

					full_path);

			exit(1);

		}

	}

	/*

	 * No fstype independent executable then.  We'll go generic

	 * from here.

	 */

	/* don't use -o with generic */

	if (oflg) {

		fprintf(stderr, gettext(

	"%s: %s specific umount does not exist; -o suboption ignored\n"),

		myname, ment->mnt_fstype ? ment->mnt_fstype : "<null>");

	}

	signal(SIGHUP,  SIG_IGN);

	signal(SIGQUIT, SIG_IGN);

	signal(SIGINT,  SIG_IGN);

	/*

	 * Try to umount the mountpoint.

	 * If that fails, try the corresponding special.

	 * (This ordering is necessary for nfs umounts.)

	 * (for remote resources:  if the first umount returns EBUSY

	 * don't call umount again - umount() with a resource name

	 * will return a misleading error to the user

	 */

	if (fflg) {

		if (((ret = umount2(ment->mnt_mountp, MS_FORCE)) < 0) &&

				(errno != EBUSY && errno != ENOTSUP &&

				errno != EPERM))

			ret = umount2(ment->mnt_special, MS_FORCE);

	} else {

		if (((ret = umount2(ment->mnt_mountp, 0)) < 0) &&

				(errno != EBUSY) && (errno != EPERM))

			ret = umount2(ment->mnt_special, 0);

	}

	if (ret < 0) {

		rpterr(ment->mnt_mountp);

		if (errno != EINVAL && errno != EFAULT)

			exit(1);

		exitcode = 1;

	}

	exit(exitcode);

}

void

rpterr(char *sp)

{

	switch (errno) {

	case EPERM:

		fprintf(stderr, gettext("%s: permission denied\n"), myname);

		break;

	case ENXIO:

		fprintf(stderr, gettext("%s: %s no device\n"), myname, sp);

		break;

	case ENOENT:

		fprintf(stderr,

			gettext("%s: %s no such file or directory\n"),

			myname, sp);

		break;

	case EINVAL:

		fprintf(stderr, gettext("%s: %s not mounted\n"), myname, sp);

		break;

	case EBUSY:

		fprintf(stderr, gettext("%s: %s busy\n"), myname, sp);

		break;

	case ENOTBLK:

		fprintf(stderr,

			gettext("%s: %s block device required\n"), myname, sp);

		break;

	case ECOMM:

		fprintf(stderr,

			gettext("%s: warning: broken link detected\n"), myname);

		break;

	default:

		perror(myname);

		fprintf(stderr, gettext("%s: cannot unmount %s\n"), myname, sp);

	}

}

void

usage(void)

{

	fprintf(stderr, gettext(

"Usage:\n%s [-f] [-V] [-o specific_options] {special | mount-point}\n"),

		myname);

	fprintf(stderr, gettext(

"%s -a [-f] [-V] [-o specific_options] [mount_point ...]\n"), myname);

	exit(1);

}

void

mnterror(int flag)

{

	switch (flag) {

	case MNT_TOOLONG:

		fprintf(stderr,

			gettext("%s: line in mnttab exceeds %d characters\n"),

			myname, MNT_LINE_MAX-2);

		break;

	case MNT_TOOFEW:

		fprintf(stderr,

			gettext("%s: line in mnttab has too few entries\n"),