path: root/usr/src/cmd/fs.d/autofs/automount.c

/*
 * 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
 */
/*
 *	automount.c
 *
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */


#include <ctype.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <locale.h>
#include <stdarg.h>
#include <errno.h>
#include <string.h>
#include <dirent.h>
#include <signal.h>
#include <syslog.h>
#include <libshare.h>
#include <libscf.h>
#include <sys/param.h>
#include <sys/time.h>
#include <sys/vfs.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mnttab.h>
#include <sys/mntent.h>
#include <sys/mount.h>
#include <sys/utsname.h>
#include <sys/tiuser.h>
#include <rpc/rpc.h>
#include <rpcsvc/nfs_prot.h>
#include <nsswitch.h>
#include <deflt.h>
#include <rpcsvc/daemon_utils.h>
#include "automount.h"
#include "smfcfg.h"

static int mkdir_r(char *);
struct autodir *dir_head;
struct autodir *dir_tail;
static struct extmnttab *find_mount();
int verbose = 0;
int trace = 0;

static void usage();
static int compare_opts(char *, char *);
static void do_unmounts();

static int mount_timeout = AUTOFS_MOUNT_TIMEOUT;

static char	*service_list[] = { AUTOMOUNTD, NULL };

/*
 * XXX
 * The following are needed because they're used in auto_subr.c and
 * we link with it. Should avoid this.
 */
mutex_t cleanup_lock;
cond_t cleanup_start_cv;
cond_t cleanup_done_cv;

int
main(int argc, char *argv[])
{
	int c;
	struct autofs_args ai;
	struct utsname utsname;
	char autofs_addr[MAXADDRLEN];
	struct autodir *dir, *d;
	struct stat stbuf;
	char *master_map = "auto_master";
	int null;
	struct extmnttab mnt, *mntp;
	struct mnttab *omntp;
	char mntopts[MAX_MNTOPT_STR];
	int mntflgs;
	int count = 0;
	char *stack[STACKSIZ];
	char **stkptr;
	char *defval;
	struct sigaction sigintact;
	int ret = 0, bufsz = 0;
	char valbuf[6];

	/*
	 * protect this command from session termination when run in background
	 * we test background by whether SIGINT is ignored
	 */
	(void) sigaction(SIGINT, NULL, &sigintact);
	if (sigintact.sa_sigaction == SIG_IGN) {
		(void) signal(SIGHUP, SIG_IGN);
		(void) setsid();
	}

	/*
	 * Read in the values from SMF first before we check
	 * commandline options so the options override the SMF values.
	 */
	bufsz = 6;
	ret = autofs_smf_get_prop("timeout", valbuf, DEFAULT_INSTANCE,
	    SCF_TYPE_INTEGER, AUTOMOUNTD, &bufsz);
	if (ret == SA_OK)
		/*
		 * Ignore errno.  In event of failure, mount_timeout is
		 * already initialized to the correct value.
		 */
		mount_timeout = strtol(valbuf, (char **)NULL, 10);

	bufsz = 6;
	ret = autofs_smf_get_prop("automount_verbose", valbuf, DEFAULT_INSTANCE,
	    SCF_TYPE_BOOLEAN, AUTOMOUNTD, &bufsz);
	if (ret == SA_OK) {
		if (strncasecmp("true", valbuf, 4) == 0)
			verbose = TRUE;
	}

	put_automountd_env();

	while ((c = getopt(argc, argv, "mM:D:f:t:v?")) != EOF) {
		switch (c) {
		case 'm':
			pr_msg("Warning: -m option not supported");
			break;
		case 'M':
			pr_msg("Warning: -M option not supported");
			break;
		case 'D':
			pr_msg("Warning: -D option not supported");
			break;
		case 'f':
			pr_msg("Error: -f option no longer supported");
			usage();
			break;
		case 't':
			if (strchr(optarg, '=')) {
				pr_msg("Error: invalid value for -t");
				usage();
			}
			mount_timeout = atoi(optarg);
			break;
		case 'v':
			verbose++;
			break;
		default:
			usage();
			break;
		}
	}

	if (optind < argc) {
		pr_msg("%s: command line mountpoints/maps "
		    "no longer supported", argv[optind]);
		usage();
	}

	current_mounts = getmntlist();
	if (current_mounts == NULL) {
		pr_msg("Couldn't establish current mounts");
		exit(1);
	}

	(void) umask(0);
	ns_setup(stack, &stkptr);

	openlog("automount", LOG_PID, LOG_DAEMON);
	(void) loadmaster_map(master_map, "", stack, &stkptr);
	if (dir_head != NULL) {
		/*
		 * automount maps found. enable services as needed.
		 */
		_check_services(service_list);
	}

	closelog();

	if (uname(&utsname) < 0) {
		pr_msg("uname: %m");
		exit(1);
	}
	(void) strcpy(autofs_addr, utsname.nodename);
	(void) strcat(autofs_addr, ".autofs");
	ai.addr.buf	= autofs_addr;
	ai.addr.len	= strlen(ai.addr.buf);
	ai.addr.maxlen	= ai.addr.len;

	ai.mount_to	= mount_timeout;
	ai.rpc_to	= AUTOFS_RPC_TIMEOUT;

	/*
	 * Mount the daemon at its mount points.
	 */
	for (dir = dir_head; dir; dir = dir->dir_next) {

		/*
		 * Skip null entries
		 */
		if (strcmp(dir->dir_map, "-null") == 0)
			continue;

		/*
		 * Skip null'ed entries
		 */
		null = 0;
		for (d = dir->dir_prev; d; d = d->dir_prev) {
			if (strcmp(dir->dir_name, d->dir_name) == 0)
				null = 1;
		}
		if (null)
			continue;

		/*
		 * Check whether there's already an entry
		 * in the mnttab for this mountpoint.
		 */
		if (mntp = find_mount(dir->dir_name, 1)) {
			/*
			 * If it's not an autofs mount - don't
			 * mount over it.
			 */
			if (strcmp(mntp->mnt_fstype, MNTTYPE_AUTOFS) != 0) {
				pr_msg("%s: already mounted",
				    mntp->mnt_mountp);
				continue;
			}

			/*
			 * Compare the mnttab entry with the master map
			 * entry.  If the map or mount options are
			 * different, then update this information
			 * with a remount.
			 */
			if (strcmp(mntp->mnt_special, dir->dir_map) == 0 &&
			    compare_opts(dir->dir_opts,
			    mntp->mnt_mntopts) == 0) {
				continue;	/* no change */
			}

			/*
			 * Check for an overlaid direct autofs mount.
			 * Cannot remount since it's inaccessible.
			 */
			omntp = (struct mnttab *)mntp;
			if (hasmntopt(omntp, "direct") != NULL) {
				mntp = find_mount(dir->dir_name, 0);
				omntp = (struct mnttab *)mntp;
				if (hasmntopt(omntp, "direct") == NULL) {
					if (verbose)
						pr_msg("%s: cannot remount",
						    dir->dir_name);
					continue;
				}
			}

			dir->dir_remount = 1;
		}

		/*
		 * Create a mount point if necessary
		 * If the path refers to an existing symbolic
		 * link, refuse to mount on it.  This avoids
		 * future problems.
		 */
		if (lstat(dir->dir_name, &stbuf) == 0) {
			if ((stbuf.st_mode & S_IFMT) != S_IFDIR) {
				pr_msg("%s: Not a directory", dir->dir_name);
				continue;
			}
		} else {
			if (mkdir_r(dir->dir_name)) {
				pr_msg("%s: %m", dir->dir_name);
				continue;
			}
		}

		ai.path 	= dir->dir_name;
		ai.opts		= dir->dir_opts;
		ai.map		= dir->dir_map;
		ai.subdir	= "";
		ai.direct 	= dir->dir_direct;
		if (dir->dir_direct)
			ai.key = dir->dir_name;
		else
			ai.key = "";

		(void) sprintf(mntopts, "ignore,%s",
		    dir->dir_direct  ? "direct" : "indirect");
		if (dir->dir_opts && *dir->dir_opts) {
			(void) strcat(mntopts, ",");
			(void) strcat(mntopts, dir->dir_opts);
		}
		mntflgs = MS_OPTIONSTR | (dir->dir_remount ? MS_REMOUNT : 0);
		if (mount(dir->dir_map, dir->dir_name, MS_DATA | mntflgs,
		    MNTTYPE_AUTOFS, &ai, sizeof (ai), mntopts,
		    MAX_MNTOPT_STR) < 0) {
			pr_msg("mount %s: %m", dir->dir_name);
			continue;
		}

		count++;

		if (verbose) {
			if (dir->dir_remount)
				pr_msg("%s remounted", dir->dir_name);
			else
				pr_msg("%s mounted", dir->dir_name);
		}
	}

	if (verbose && count == 0)
		pr_msg("no mounts");

	/*
	 * Now compare the /etc/mnttab with the master
	 * map.  Any autofs mounts in the /etc/mnttab
	 * that are not in the master map must be
	 * unmounted
	 */
	do_unmounts();

	return (0);
}

/*
 * Find a mount entry given
 * the mountpoint path.
 * Optionally return the first
 * or last entry.
 */
static struct extmnttab *
find_mount(mntpnt, first)
	char *mntpnt;
	int first;
{
	struct mntlist *mntl;
	struct extmnttab *found = NULL;

	for (mntl = current_mounts; mntl; mntl = mntl->mntl_next) {

		if (strcmp(mntpnt, mntl->mntl_mnt->mnt_mountp) == 0) {
			found = mntl->mntl_mnt;
			if (first)
				break;
		}
	}

	return (found);
}

static char *ignore_opts[] = {"ignore", "direct", "indirect", "dev", NULL};

/*
 * Compare mount options
 * ignoring "ignore", "direct", "indirect"
 * and "dev=".
 */
static int
compare_opts(opts, mntopts)
	char *opts, *mntopts;
{
	char optbuf1[MAX_MNTOPT_STR], *s = optbuf1;
	char optbuf2[MAX_MNTOPT_STR];
	char **opttbl1, **opttbl2;
	int nopts1, nopts2;
	char *ostart, *optr, *valp;
	int j, i, notsame;

	opttbl1 = opttbl2 = NULL;
	/*
	 * Parse the two option strings to split them both into
	 * lists of individual options.
	 */
	if (mntopts != NULL)
		(void) strcpy(s, mntopts);
	else
		*s = '\0';
	if (*s != '\0')
		nopts1 = 1;
	else
		nopts1 = 0;
	for (s = strchr(s, ','); s != NULL; s = strchr(s, ',')) {
		nopts1++;
		s++;
	}
	if (nopts1)
		if ((opttbl1 = memalign(sizeof (char *),
			nopts1 * sizeof (char *))) == NULL)
			return (1);
	nopts1 = 0;
	s = optbuf1;
	for (ostart = optr = s; *optr != '\0'; ostart = optr) {
		if (getsubopt(&optr, ignore_opts, &valp) == -1) {
			opttbl1[nopts1++] = ostart;
		}
	}
	s = optbuf2;
	if (opts != NULL)
		(void) strcpy(s, opts);
	else
		*s = '\0';
	if (*s != '\0')
		nopts2 = 1;
	else
		nopts2 = 0;
	for (s = strchr(s, ','); s != NULL; s = strchr(s, ',')) {
		nopts2++;
		s++;
	}
	if (nopts2)
		if ((opttbl2 = memalign(sizeof (char *),
			nopts2 * sizeof (char *))) == NULL) {
			notsame = 1;
			goto done;
		}
	nopts2 = 0;
	s = optbuf2;
	for (ostart = optr = s; *optr != '\0'; ostart = optr) {
		if (getsubopt(&optr, ignore_opts, &valp) == -1) {
			opttbl2[nopts2++] = ostart;
		}
	}
	if (nopts2 != nopts1) {
		notsame = 1;
		goto done;
	}
	notsame = 0;
	for (i = 0; i < nopts1; i++) {
		notsame = 1;
		for (j = 0; j < nopts2; j++) {
			if (strcmp(opttbl1[i], opttbl2[j]) == 0) {
				notsame = 0;
				break;
			}
		}
		if (notsame)
			break;
	}

done:
	if (opttbl1 != NULL)
		free(opttbl1);
	if (opttbl2 != NULL)
		free(opttbl2);
	return (notsame);
}

static void
usage()
{
	pr_msg("Usage: automount  [ -v ]  [ -t duration ]");
	exit(1);
	/* NOTREACHED */
}

/*
 * Unmount any autofs mounts that
 * aren't in the master map
 */
static void
do_unmounts()
{
	struct mntlist *mntl;
	struct extmnttab *mnt;
	struct mnttab *omnt;
	struct autodir *dir;
	int current;
	int count = 0;
	struct zone_summary *zsp;

	zsp = fs_get_zone_summaries();
	if (zsp == NULL) {
		pr_msg("Couldn't establish active zones");
		exit(1);
	}
	for (mntl = current_mounts; mntl; mntl = mntl->mntl_next) {
		mnt = mntl->mntl_mnt;
		omnt = (struct mnttab *)mnt;
		if (strcmp(mnt->mnt_fstype, MNTTYPE_AUTOFS) != 0)
			continue;
		if (fs_mount_in_other_zone(zsp, mnt->mnt_mountp))
			continue;
		/*
		 * Don't unmount autofs mounts done
		 * from the autofs mount command.
		 * How do we tell them apart ?
		 * Autofs mounts not eligible for auto-unmount
		 * have the "nest" pseudo-option.
		 */
		if (hasmntopt(omnt, "nest") != NULL)
			continue;

		current = 0;
		for (dir = dir_head; dir; dir = dir->dir_next) {
			if (strcmp(dir->dir_name, mnt->mnt_mountp) == 0) {
				current = strcmp(dir->dir_map, "-null");
				break;
			}
		}
		if (current)
			continue;


		if (umount(mnt->mnt_mountp) == 0) {
			if (verbose) {
				pr_msg("%s unmounted",
				    mnt->mnt_mountp);
			}
			count++;
		}
	}
	if (verbose && count == 0)
		pr_msg("no unmounts");
}

static int
mkdir_r(dir)
	char *dir;
{
	int err;
	char *slash;

	if (mkdir(dir, 0555) == 0 || errno == EEXIST)
		return (0);
	if (errno != ENOENT)
		return (-1);
	slash = strrchr(dir, '/');
	if (slash == NULL)
		return (-1);
	*slash = '\0';
	err = mkdir_r(dir);
	*slash++ = '/';
	if (err || !*slash)
		return (err);
	return (mkdir(dir, 0555));
}

/*
 * Print an error.
 * Works like printf (fmt string and variable args)
 * except that it will subsititute an error message
 * for a "%m" string (like syslog).
 */
/* VARARGS1 */
void
pr_msg(const char *fmt, ...)
{
	va_list ap;
	char buf[BUFSIZ], *p2;
	char *p1;
	char *nfmt;

	(void) strcpy(buf, "automount: ");
	p2 = buf + strlen(buf);

	nfmt = gettext(fmt);

	for (p1 = nfmt; *p1; p1++) {
		if (*p1 == '%' && *(p1+1) == 'm') {
			(void) strcpy(p2, strerror(errno));
			p2 += strlen(p2);
			p1++;
		} else {
			*p2++ = *p1;
		}
	}
	if (p2 > buf && *(p2-1) != '\n')
		*p2++ = '\n';
	*p2 = '\0';

	va_start(ap, fmt);
	(void) vfprintf(stderr, buf, ap);
	va_end(ap);
}