/* ----------------------------------------------------------------------- *

 *

 *  automount.c - Linux automounter daemon

 *   

 *   Copyright 1997 Transmeta Corporation - All Rights Reserved

 *   Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>

 *   Copyright 2001-2005 Ian Kent <raven@themaw.net>

 *

 *   This program is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,

 *   USA; either version 2 of the License, or (at your option) any later

 *   version.

 *   

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 *

 * ----------------------------------------------------------------------- */

#include <dirent.h>

#include <getopt.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/ioctl.h>

#include <ctype.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <sys/stat.h>

#include <sys/time.h>

#include <sys/resource.h>

#include <sys/poll.h>

#include <dirent.h>

#include <sys/vfs.h>

#include <sys/utsname.h>

#ifdef WITH_SYSTEMD

#include <systemd/sd-daemon.h>

#endif

#include "automount.h"

#if defined(LIBXML2_WORKAROUND) || defined(TIRPC_WORKAROUND)

#include <dlfcn.h>

#ifdef WITH_LDAP

#include <libxml/parser.h>

#endif

#endif

const char *program;		/* Initialized with argv[0] */

const char *version = VERSION_STRING;	/* Program version */

const char *libdir = AUTOFS_LIB_DIR;	/* Location of library modules */

const char *mapdir = AUTOFS_MAP_DIR;	/* Location of mount maps */

const char *confdir = AUTOFS_CONF_DIR;	/* Location of autofs config file */

unsigned int mp_mode = 0755;

unsigned int nfs_mount_uses_string_options = 0;

static struct nfs_mount_vers vers, check = {1, 1, 1};

/* autofs fifo name prefix */

const char *fifodir = AUTOFS_FIFO_DIR "/autofs.fifo";

const char *global_options;		/* Global option, from command line */

static char *pid_file = NULL;		/* File in which to keep pid */

unsigned int global_selection_options;

long global_negative_timeout = -1;

int do_force_unlink = 0;		/* Forceably unlink mount tree at startup */

static int start_pipefd[2] = {-1, -1};

static int st_stat = 1;

static int *pst_stat = &st_stat;

static pthread_t state_mach_thid;

static sigset_t block_sigs;

/* Pre-calculated kernel packet length */

static size_t kpkt_len;

/* Attributes for creating detached and joinable threads */

pthread_attr_t th_attr;

pthread_attr_t th_attr_detached;

size_t detached_thread_stack_size = PTHREAD_STACK_MIN * 144;

struct master_readmap_cond mrc = {

	PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0, NULL, 0, 0, 0, 0};

struct startup_cond suc = {

	PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0, 0};

pthread_key_t key_thread_stdenv_vars;

pthread_key_t key_thread_attempt_id = (pthread_key_t) 0L;

#define MAX_OPEN_FILES		10240

int aquire_flag_file(void);

void release_flag_file(void);

static int umount_all(struct autofs_point *ap, int force);

extern struct master *master_list;

/* simple string hash based on public domain sdbm library */

static unsigned long sdbm_hash(const char *str, unsigned long seed)

{

	unsigned long hash = seed;

	char c;

	while ((c = *str++))

		hash = c + (hash << 6) + (hash << 16) - hash;

	return hash;

}

void set_thread_mount_request_log_id(struct pending_args *mt)

{

	char attempt_id_comp[20];

	unsigned long *attempt_id;

	int status;

	if (!defaults_get_use_mount_request_log_id())

		return;

	attempt_id = pthread_getspecific(key_thread_attempt_id);

	if (attempt_id == NULL) {

		attempt_id = (unsigned long *) calloc(1, sizeof(unsigned long));

		if (attempt_id  == NULL)

			fatal(ENOMEM);

		snprintf(attempt_id_comp, 20, "%ld", mt->wait_queue_token);

		*attempt_id = sdbm_hash(attempt_id_comp, 0);

		snprintf(attempt_id_comp, 20, "%u", mt->pid);

		*attempt_id = sdbm_hash(attempt_id_comp, *attempt_id);

		*attempt_id = sdbm_hash(mt->name, *attempt_id);

		status = pthread_setspecific(key_thread_attempt_id, attempt_id);

		if (status != 0)

			fatal(status);

	}

}

static int is_remote_fstype(unsigned int fs_type)

{

	int ret = 0;

	switch (fs_type) {

	case SMB_SUPER_MAGIC:

	case CIFS_MAGIC_NUMBER:

	case NCP_SUPER_MAGIC:

	case NFS_SUPER_MAGIC:

		ret = 1;

		break;

	};

	return ret;

}

static int do_mkdir(const char *parent, const char *path, mode_t mode)

{

	int status;

	mode_t mask;

	struct stat st, root;

	struct statfs fs;

	/* If path exists we're done */

	status = stat(path, &st);

	if (status == 0) {

		errno = EEXIST;

		if (!S_ISDIR(st.st_mode))

			errno = ENOTDIR;

		return 0;

	}

	/*

	 * We don't want to create the path on a remote file system

	 * unless it's the root file system.

	 * An empty parent means it's the root directory and always ok.

	 */

	if (*parent) {

		status = statfs(parent, &fs);

		if (status == -1)

			goto fail;

		if (is_remote_fstype(fs.f_type)) {

			status = stat(parent, &st);

			if (status == -1)

				goto fail;

			status = stat("/", &root);

			if (status == -1)

				goto fail;

			if (st.st_dev != root.st_dev)

				goto fail;

		}

	}

	mask = umask(0022);

	status = mkdir(path, mode);

	(void) umask(mask);

	if (status == -1)

		goto fail;

	return 1;

fail:

	errno = EACCES;

	return 0;

}

int mkdir_path(const char *path, mode_t mode)

{

	char buf[PATH_MAX];

	char parent[PATH_MAX];

	const char *cp = path, *lcp = path;

	char *bp = buf, *pp = parent;

	*parent = '\0';

	do {

		if (cp != path && (*cp == '/' || *cp == '\0')) {

			memcpy(bp, lcp, cp - lcp);

			bp += cp - lcp;

			*bp = '\0';

			if (!do_mkdir(parent, buf, mode)) {

				if (*cp != '\0') {

					memcpy(pp, lcp, cp - lcp);

					pp += cp - lcp;

					*pp = '\0';

					lcp = cp;

					continue;

				}

				return -1;

			}

			memcpy(pp, lcp, cp - lcp);

			pp += cp - lcp;

			*pp = '\0';

			lcp = cp;

		}

	} while (*cp++ != '\0');

	return 0;

}

/* Remove as much as possible of a path */

int rmdir_path(struct autofs_point *ap, const char *path, dev_t dev)

{

	int len = strlen(path);

	char buf[PATH_MAX];

	char *cp;

	int first = 1;

	struct stat st;

	struct statfs fs;

	strcpy(buf, path);

	cp = buf + len;

	do {

		*cp = '\0';

		/*

		 *  Before removing anything, perform some sanity checks to

		 *  ensure that we are looking at files in the automount

		 *  file system.

		 */

		memset(&st, 0, sizeof(st));

		if (lstat(buf, &st) != 0) {

			crit(ap->logopt, "lstat of %s failed", buf);

			return -1;

		}

		/* Termination condition removing full path within autofs fs */

		if (st.st_dev != dev)

			return 0;

		if (statfs(buf, &fs) != 0) {

			error(ap->logopt, "could not stat fs of %s", buf);

			return -1;

		}

		if (fs.f_type != (__SWORD_TYPE) AUTOFS_SUPER_MAGIC) {

			crit(ap->logopt, "attempt to remove directory from a "

			     "non-autofs filesystem!");

			crit(ap->logopt,

			     "requester dev == %llu, \"%s\" owner dev == %llu",

			     dev, buf, st.st_dev);

			return -1;

		}

		/*

		 * Last element of path may be a symbolic link; all others

		 * are directories (and the last directory element is

		 * processed first, hence the variable name)

		 */

		if (rmdir(buf) == -1) {

			if (first && errno == ENOTDIR) {

				/*

				 *  Ensure that we will only remove

				 *  symbolic links.

				 */

				if (S_ISLNK(st.st_mode)) {

					if (unlink(buf) == -1)

						return -1;

				} else {

					crit(ap->logopt,

					   "file \"%s\" is neither a directory"

					   " nor a symbolic link. mode %d",

					   buf, st.st_mode);

					return -1;

				}

			}

			/*

			 *  If we fail to remove a directory for any reason,

			 *  we need to return an error.

			 */

			return -1;

		}

		first = 0;

	} while ((cp = strrchr(buf, '/')) != NULL && cp != buf);

	return 0;

}

/* Like ftw, except fn gets called twice: before a directory is

   entered, and after.  If the before call returns 0, the directory

   isn't entered. */

static int walk_tree(const char *base, int (*fn) (struct autofs_point *ap,

						  const char *file,

						  const struct stat * st,

						  int, void *), int incl,

						  struct autofs_point *ap,

						  void *arg)

{

	char buf[PATH_MAX + 1];

	struct stat st, *pst = &st;

	int ret;

	if (!is_mounted(_PATH_MOUNTED, base, MNTS_REAL))

		ret = lstat(base, pst);

	else {

		pst = NULL;

		ret = 0;

	}

	if (ret != -1 && (fn) (ap, base, pst, 0, arg)) {

		if (S_ISDIR(st.st_mode)) {

			struct dirent **de;

			int n;

			n = scandir(base, &de, 0, alphasort);

			if (n < 0)

				return -1;

			while (n--) {

				if (strcmp(de[n]->d_name, ".") == 0 ||

				    strcmp(de[n]->d_name, "..") == 0) {

					free(de[n]);

					continue;

				}

				if (!cat_path(buf, sizeof(buf), base, de[n]->d_name)) {

					do {

						free(de[n]);

					} while (n--);

					free(de);

					return -1;

				}

				walk_tree(buf, fn, 1, ap, arg);

				free(de[n]);

			}

			free(de);

		}

		if (incl)

			(fn) (ap, base, pst, 1, arg);

	}

	return 0;

}

static int rm_unwanted_fn(struct autofs_point *ap,

			  const char *file, const struct stat *st,

			  int when, void *arg)

{

	dev_t dev = *(dev_t *) arg;

	char buf[MAX_ERR_BUF];

	struct stat newst;

	if (!st)

		return 0;

	if (when == 0) {

		if (st->st_dev != dev)

			return 0;

		return 1;

	}

	if (lstat(file, &newst)) {

		crit(ap->logopt,

		     "unable to stat file, possible race condition");

		return 0;

	}

	if (newst.st_dev != dev) {

		crit(ap->logopt,

		     "file %s has the wrong device, possible race condition",

		     file);

		return 0;

	}

	if (S_ISDIR(newst.st_mode)) {

		debug(ap->logopt, "removing directory %s", file);

		if (rmdir(file)) {

			char *estr = strerror_r(errno, buf, MAX_ERR_BUF);

			warn(ap->logopt,

			      "unable to remove directory %s: %s", file, estr);

			return 0;

		}

	} else if (S_ISREG(newst.st_mode)) {

		crit(ap->logopt, "attempting to remove files from a mounted "

		     "directory. file %s", file);

		return 0;

	} else if (S_ISLNK(newst.st_mode)) {

		debug(ap->logopt, "removing symlink %s", file);

		unlink(file);

	}

	return 1;

}

void rm_unwanted(struct autofs_point *ap, const char *path, int incl)

{

	walk_tree(path, rm_unwanted_fn, incl, ap, &ap->dev);

}

struct counter_args {

	unsigned int count;

	dev_t dev;

};

static int counter_fn(struct autofs_point *ap, const char *file,

		      const struct stat *st, int when, void *arg)

{

	struct counter_args *counter = (struct counter_args *) arg;

	if (!st || (S_ISLNK(st->st_mode) || (S_ISDIR(st->st_mode)

		&& st->st_dev != counter->dev))) {

		counter->count++;

		return 0;

	}

	return 1;

}

/* Count mounted filesystems and symlinks */

int count_mounts(struct autofs_point *ap, const char *path, dev_t dev)

{

	struct counter_args counter;

	counter.count = 0;

	counter.dev = dev;

	if (walk_tree(path, counter_fn, 1, ap, &counter) == -1)

		return -1;

	return counter.count;

}

static void check_rm_dirs(struct autofs_point *ap, const char *path, int incl)

{

	/*

	 * If we're a submount the kernel can't know we're trying to

	 * shutdown and so cannot block processes walking into the

	 * mount point directory. If this is the call to umount_multi()

	 * made during shutdown (incl == 0) we have to leave any mount

	 * point directories in place so we can recover if needed. The

	 * umount itself will clean these directories up for us

	 * automagically.

	 */

	if (!incl && ap->submount)

		return;

	if ((!(ap->flags & MOUNT_FLAG_GHOST)) ||

	    (ap->state == ST_SHUTDOWN_PENDING ||

	     ap->state == ST_SHUTDOWN_FORCE ||

	     ap->state == ST_SHUTDOWN))

		rm_unwanted(ap, path, incl);

	else if ((ap->flags & MOUNT_FLAG_GHOST) && (ap->type == LKP_INDIRECT))

		rm_unwanted(ap, path, 0);

}

/* Try to purge cache entries kept around due to existing mounts */

static void update_map_cache(struct autofs_point *ap, const char *path)

{

	struct map_source *map;

	struct mapent_cache *mc;

	const char *key;

	if (ap->type == LKP_INDIRECT)

		key = strrchr(path, '/') + 1;

	else

		key = path;

	map = ap->entry->maps;

	while (map) {

		struct mapent *me = NULL;

		/* Skip current, in-use cache */

		if (ap->entry->age <= map->age) {

			map = map->next;

			continue;

		}

		mc = map->mc;

		/* If the lock is busy try later */

		if (cache_try_writelock(mc)) {

			me = cache_lookup_distinct(mc, key);

			if (me && me->ioctlfd == -1)

				cache_delete(mc, key);

			cache_unlock(mc);

		}

		map = map->next;

	}

	return;

}

static int umount_subtree_mounts(struct autofs_point *ap, const char *path, unsigned int is_autofs_fs)

{

	struct mapent_cache *mc;

	struct mapent *me;

	unsigned int is_mm_root = 0;

	int left;

	me = lookup_source_mapent(ap, path, LKP_DISTINCT);

	if (!me) {

		char *ind_key;

		ind_key = strrchr(path, '/');

		if (ind_key)

			ind_key++;

		me = lookup_source_mapent(ap, ind_key, LKP_NORMAL);

	}

	if (me) {

		mc = me->mc;

		is_mm_root = (me->multi == me);

	}

	left = 0;

	if (me && me->multi) {

		char root[PATH_MAX];

		char *base;

		int cur_state;

		pthread_cleanup_push(cache_lock_cleanup, mc);

		if (!strchr(me->multi->key, '/'))

			/* Indirect multi-mount root */

			/* sprintf okay - if it's mounted, it's

			 * PATH_MAX or less bytes */

			sprintf(root, "%s/%s", ap->path, me->multi->key);

		else

			strcpy(root, me->multi->key);

		if (is_mm_root)

			base = NULL;

		else

			base = me->key + strlen(root);

		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);

		/* Lock the closest parent nesting point for umount */

		cache_multi_writelock(me->parent);

		if (umount_multi_triggers(ap, me, root, base)) {

			warn(ap->logopt,

			     "some offset mounts still present under %s", path);

			left++;

		}

		cache_multi_unlock(me->parent);

		if (ap->entry->maps &&

		    (ap->entry->maps->flags & MAP_FLAG_FORMAT_AMD))

			cache_pop_mapent(me);

		pthread_setcancelstate(cur_state, NULL);

		pthread_cleanup_pop(0);

	}

	if (me)

		cache_unlock(mc);

	if (left || is_autofs_fs)

		return left;

	/*

	 * If this is the root of a multi-mount we've had to umount

	 * it already to ensure it's ok to remove any offset triggers.

	 */

	if (!is_mm_root && is_mounted(_PATH_MOUNTED, path, MNTS_REAL)) {

		struct amd_entry *entry;

		debug(ap->logopt, "unmounting dir = %s", path);

		if (umount_ent(ap, path) &&

		    is_mounted(_PATH_MOUNTED, path, MNTS_REAL)) {

			warn(ap->logopt, "could not umount dir %s", path);

			left++;

			goto done;

		}

		/* Check for an external mount and umount if possible */

		mounts_mutex_lock(ap);

		entry = __master_find_amdmount(ap, path);

		if (!entry) {

			mounts_mutex_unlock(ap);

			goto done;

		}

		list_del(&entry->entries);

		mounts_mutex_unlock(ap);

		umount_amd_ext_mount(ap, entry);

		free_amd_entry(entry);

	}

done:

	return left;

}

/* umount all filesystems mounted under path.  If incl is true, then

   it also tries to umount path itself */

int umount_multi(struct autofs_point *ap, const char *path, int incl)

{

	int is_autofs_fs;

	struct stat st;

	int left;

	debug(ap->logopt, "path %s incl %d", path, incl);

	if (lstat(path, &st)) {

		warn(ap->logopt,

		     "failed to stat directory or symlink %s", path);

		return 1;

	}

	/* if this is a symlink we can handle it now */

	if (S_ISLNK(st.st_mode)) {

		struct amd_entry *entry;

		if (st.st_dev != ap->dev) {

			crit(ap->logopt,

			     "symlink %s has the wrong device, "

			     "possible race condition", path);

			return 1;

		}

		debug(ap->logopt, "removing symlink %s", path);

		if (unlink(path)) {

			error(ap->logopt,

			      "failed to remove symlink %s", path);

			return 1;

		}

		/* Check for an external mount and attempt umount if needed */

		mounts_mutex_lock(ap);

		entry = __master_find_amdmount(ap, path);

		if (!entry) {

			mounts_mutex_unlock(ap);

			return 0;

		}

		list_del(&entry->entries);

		mounts_mutex_unlock(ap);

		umount_amd_ext_mount(ap, entry);

		free_amd_entry(entry);

		return 0;

	}

	is_autofs_fs = 0;

	if (master_find_submount(ap, path))

		is_autofs_fs = 1;

	left = 0;

	/*

	 * If we are a submount we need to umount any offsets our

	 * parent may have mounted over top of us.

	 */

	if (ap->submount)

		left += umount_subtree_mounts(ap->parent, path, 1);

	left += umount_subtree_mounts(ap, path, is_autofs_fs);

	/* Delete detritus like unwanted mountpoints and symlinks */

	if (left == 0 &&

	    ap->state != ST_READMAP &&

	    !count_mounts(ap, path, ap->dev)) {

		update_map_cache(ap, path);

		check_rm_dirs(ap, path, incl);

	}

	return left;

}

static int umount_all(struct autofs_point *ap, int force)

{

	int left;

	left = umount_multi(ap, ap->path, 0);

	if (force && left)

		warn(ap->logopt, "could not unmount %d dirs under %s",

		     left, ap->path);

	return left;

}

int umount_autofs(struct autofs_point *ap, const char *root, int force)

{

	int ret = 0;

	if (ap->state == ST_INIT)

		return -1;

	/*

	 * Since lookup.c is lazy about closing lookup modules

	 * to prevent unneeded opens, we need to clean them up

	 * before umount.

	 */

	lookup_close_lookup(ap);

	if (ap->type == LKP_INDIRECT) {

		if (umount_all(ap, force) && !force)

			return -1;

		ret = umount_autofs_indirect(ap, root);

	} else

		ret = umount_autofs_direct(ap);

	return ret;

}

static size_t get_kpkt_len(void)

{

	size_t pkt_len = sizeof(struct autofs_v5_packet);

	struct utsname un;

	int kern_vers;

	kern_vers = linux_version_code();

	if (kern_vers >= KERNEL_VERSION(3, 3, 0))

		return pkt_len;

	uname(&un;;

	if (pkt_len % 8) {

		if (strcmp(un.machine, "alpha") == 0 ||

		    strcmp(un.machine, "ia64") == 0 ||

		    strcmp(un.machine, "x86_64") == 0 ||

		    strcmp(un.machine, "parisc64") == 0 ||

		    strcmp(un.machine, "ppc64") == 0)

			pkt_len += 4;

	}

	return pkt_len;

}

static int fullread(int fd, void *ptr, size_t len)

{

	char *buf = (char *) ptr;

	while (len > 0) {

		ssize_t r = read(fd, buf, len);

		if (r == -1) {

			if (errno == EINTR)

				continue;

			break;

		}

		buf += r;

		len -= r;

	}

	return len;

}

static char *automount_path_to_fifo(unsigned logopt, const char *path)

{

	char *fifo_name, *p;

	int  name_len = strlen(path) + strlen(fifodir) + 1;

	int ret;

	fifo_name = malloc(name_len);

	if (!fifo_name)

		return NULL;

	ret = snprintf(fifo_name, name_len, "%s%s", fifodir, path);

	if (ret >= name_len) {

		info(logopt,

		     "fifo path for \"%s\" truncated to \"%s\".  This may "

		     "lead to --set-log-priority commands being sent to the "

		     "wrong automount daemon.", path, fifo_name);

	}

	/*

	 *  An automount path can be made up of subdirectories.  So, to

	 *  create the fifo name, we will just replace instances of '/' with

	 *  '-'. 

	 */

	p = fifo_name + strlen(fifodir);

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

		if (*p == '/')

			*p = '-';

		p++;

	}

	debug(logopt, "fifo name %s",fifo_name);

	return fifo_name;

}

static int create_logpri_fifo(struct autofs_point *ap)

{

	int ret = -1;

	int fd;

	char *fifo_name;

	char buf[MAX_ERR_BUF];

	fifo_name = automount_path_to_fifo(ap->logopt, ap->path);

	if (!fifo_name) {

		crit(ap->logopt, "Failed to allocate memory!");

		goto out_free; /* free(NULL) is okay */

	}

	ret = unlink(fifo_name);

	if (ret != 0 && errno != ENOENT) {

		crit(ap->logopt,

		     "Failed to unlink FIFO. Is the automount daemon "

		     "already running?");

		goto out_free;

	}

	ret = mkfifo(fifo_name, S_IRUSR|S_IWUSR);

	if (ret != 0) {

		char *estr = strerror_r(errno, buf, MAX_ERR_BUF);

		crit(ap->logopt,

		     "mkfifo for %s failed: %s", fifo_name, estr);

		goto out_free;

	}

	fd = open_fd(fifo_name, O_RDWR|O_NONBLOCK);

	if (fd < 0) {

		char *estr = strerror_r(errno, buf, MAX_ERR_BUF);

		crit(ap->logopt,

		     "Failed to open %s: %s", fifo_name, estr);

		unlink(fifo_name);

		ret = -1;

		goto out_free;

	}

	ap->logpri_fifo = fd;

out_free:

	free(fifo_name);

	return ret;

}

int destroy_logpri_fifo(struct autofs_point *ap)

{

	int ret = -1;

	int fd = ap->logpri_fifo;

	char *fifo_name;

	char buf[MAX_ERR_BUF];

	if (fd == -1)

		return 0;

	fifo_name = automount_path_to_fifo(ap->logopt, ap->path);

	if (!fifo_name) {

		crit(ap->logopt, "Failed to allocate memory!");

		goto out_free; /* free(NULL) is okay */

	}

	ap->logpri_fifo = -1;

	ret = close(fd);

	if (ret != 0) {

		char *estr = strerror_r(errno, buf, MAX_ERR_BUF);

		warn(ap->logopt,

		     "close for fifo %s: %s", fifo_name, estr);

	}

	ret = unlink(fifo_name);

	if (ret != 0) {