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

 *   

 *  mounts.c - module for mount utilities.

 *

 *   Copyright 2002-2005 Ian Kent <raven@themaw.net> - All Rights Reserved

 *

 *   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; incorporated herein by reference.

 *

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

#include <stdlib.h>

#include <string.h>

#include <limits.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/ioctl.h>

#include <sys/mount.h>

#include <sys/wait.h>

#include <ctype.h>

#include <stdio.h>

#include <dirent.h>

#include <sys/vfs.h>

#include <pwd.h>

#include <grp.h>

#include <libgen.h>

#include "automount.h"

#define MAX_OPTIONS_LEN		80

#define MAX_MNT_NAME_LEN	30

#define MAX_ENV_NAME		15

#define EBUFSIZ 1024

const unsigned int t_indirect = AUTOFS_TYPE_INDIRECT;

const unsigned int t_direct = AUTOFS_TYPE_DIRECT;

const unsigned int t_offset = AUTOFS_TYPE_OFFSET;

const unsigned int type_count = 3;

static const char options_template[]       = "fd=%d,pgrp=%u,minproto=5,maxproto=%d";

static const char options_template_extra[] = "fd=%d,pgrp=%u,minproto=5,maxproto=%d,%s";

static const char mnt_name_template[]      = "automount(pid%u)";

static struct kernel_mod_version kver = {0, 0};

static const char kver_options_template[]  = "fd=%d,pgrp=%u,minproto=3,maxproto=5";

extern size_t detached_thread_stack_size;

static size_t maxgrpbuf = 0;

#define EXT_MOUNTS_HASH_SIZE    50

struct ext_mount {

	char *mountpoint;

	unsigned int umount;

	struct list_head mount;

	struct list_head mounts;

};

static struct list_head ext_mounts_hash[EXT_MOUNTS_HASH_SIZE];

static unsigned int ext_mounts_hash_init_done = 0;

static pthread_mutex_t ext_mount_hash_mutex = PTHREAD_MUTEX_INITIALIZER;

unsigned int linux_version_code(void)

{

	struct utsname my_utsname;

	unsigned int p, q, r;

	char *tmp, *save;

	if (uname(&my_utsname))

		return 0;

	p = q = r = 0;

	tmp = strtok_r(my_utsname.release, ".", &save);

	if (!tmp)

		return 0;

	p = (unsigned int ) atoi(tmp);

	tmp = strtok_r(NULL, ".", &save);

	if (!tmp)

		return KERNEL_VERSION(p, 0, 0);

	q = (unsigned int) atoi(tmp);

	tmp = strtok_r(NULL, ".", &save);

	if (!tmp)

		return KERNEL_VERSION(p, q, 0);

	r = (unsigned int) atoi(tmp);

	return KERNEL_VERSION(p, q, r);

}

unsigned int query_kproto_ver(void)

{

	struct ioctl_ops *ops;

	char dir[] = "/tmp/autoXXXXXX", *t_dir;

	char options[MAX_OPTIONS_LEN + 1];

	pid_t pgrp = getpgrp();

	int pipefd[2], ioctlfd, len;

	struct stat st;

	t_dir = mkdtemp(dir);

	if (!t_dir)

		return 0;

	if (pipe(pipefd) == -1) {

		rmdir(t_dir);

		return 0;

	}

	len = snprintf(options, MAX_OPTIONS_LEN,

		       kver_options_template, pipefd[1], (unsigned) pgrp);

	if (len < 0) {

		close(pipefd[0]);

		close(pipefd[1]);

		rmdir(t_dir);

		return 0;

	}

	if (mount("automount", t_dir, "autofs", MS_MGC_VAL, options)) {

		close(pipefd[0]);

		close(pipefd[1]);

		rmdir(t_dir);

		return 0;

	}

	close(pipefd[1]);

	if (stat(t_dir, &st) == -1) {

		umount(t_dir);

		close(pipefd[0]);

		rmdir(t_dir);

		return 0;

	}

	ops = get_ioctl_ops();

	if (!ops) {

		umount(t_dir);

		close(pipefd[0]);

		rmdir(t_dir);

		return 0;

	}

	ops->open(LOGOPT_NONE, &ioctlfd, st.st_dev, t_dir);

	if (ioctlfd == -1) {

		umount(t_dir);

		close(pipefd[0]);

		close_ioctl_ctl();

		rmdir(t_dir);

		return 0;

	}

	ops->catatonic(LOGOPT_NONE, ioctlfd);

	/* If this ioctl() doesn't work, it is kernel version 2 */

	if (ops->protover(LOGOPT_NONE, ioctlfd, &kver.major)) {

		ops->close(LOGOPT_NONE, ioctlfd);

		umount(t_dir);

		close(pipefd[0]);

		close_ioctl_ctl();

		rmdir(t_dir);

		return 0;

	}

	/* If this ioctl() doesn't work, version is 4 or less */

	if (ops->protosubver(LOGOPT_NONE, ioctlfd, &kver.minor)) {

		ops->close(LOGOPT_NONE, ioctlfd);

		umount(t_dir);

		close(pipefd[0]);

		close_ioctl_ctl();

		rmdir(t_dir);

		return 0;

	}

	ops->close(LOGOPT_NONE, ioctlfd);

	umount(t_dir);

	close(pipefd[0]);

	close_ioctl_ctl();

	rmdir(t_dir);

	return 1;

}

unsigned int get_kver_major(void)

{

	return kver.major;

}

unsigned int get_kver_minor(void)

{

	return kver.minor;

}

#ifdef HAVE_MOUNT_NFS

static int extract_version(char *start, struct nfs_mount_vers *vers)

{

	char *s_ver = strchr(start, ' ');

	if (!s_ver)

		return 0;

	while (*s_ver && !isdigit(*s_ver)) {

		s_ver++;

		if (!*s_ver)

			return 0;

		break;

	}

	vers->major = atoi(strtok(s_ver, "."));

	vers->minor = (unsigned int) atoi(strtok(NULL, "."));

	vers->fix = (unsigned int) atoi(strtok(NULL, "."));

	return 1;

}

int check_nfs_mount_version(struct nfs_mount_vers *vers,

			    struct nfs_mount_vers *check)

{

	pid_t f;

	int ret, status, pipefd[2];

	char errbuf[EBUFSIZ + 1], *p, *sp;

	int errp, errn;

	sigset_t allsigs, tmpsig, oldsig;

	char *s_ver;

	int cancel_state;

	if (open_pipe(pipefd))

		return -1;

	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cancel_state);

	sigfillset(&allsigs);

	pthread_sigmask(SIG_BLOCK, &allsigs, &oldsig);

	open_mutex_lock();

	f = fork();

	if (f == 0) {

		reset_signals();

		close(pipefd[0]);

		dup2(pipefd[1], STDOUT_FILENO);

		dup2(pipefd[1], STDERR_FILENO);

		close(pipefd[1]);

		execl(PATH_MOUNT_NFS, PATH_MOUNT_NFS, "-V", (char *) NULL);

		_exit(255);	/* execv() failed */

	}

	ret = 0;

	tmpsig = oldsig;

	sigaddset(&tmpsig, SIGCHLD);

	pthread_sigmask(SIG_SETMASK, &tmpsig, NULL);

	open_mutex_unlock();

	close(pipefd[1]);

	if (f < 0) {

		close(pipefd[0]);

		pthread_sigmask(SIG_SETMASK, &oldsig, NULL);

		pthread_setcancelstate(cancel_state, NULL);

		return -1;

	}

	errp = 0;

	do {

		while (1) {

			errn = read(pipefd[0], errbuf + errp, EBUFSIZ - errp);

			if (errn == -1 && errno == EINTR)

				continue;

			break;

		}

		if (errn > 0) {

			errp += errn;

			sp = errbuf;

			while (errp && (p = memchr(sp, '\n', errp))) {

				*p++ = '\0';

				errp -= (p - sp);

				sp = p;

			}

			if (errp && sp != errbuf)

				memmove(errbuf, sp, errp);

			if (errp >= EBUFSIZ) {

				/* Line too long, split */

				errbuf[errp] = '\0';

				if ((s_ver = strstr(errbuf, "nfs-utils"))) {

					if (extract_version(s_ver, vers))

						ret = 1;

				}

				errp = 0;

			}

			if ((s_ver = strstr(errbuf, "nfs-utils"))) {

				if (extract_version(s_ver, vers))

					ret = 1;

			}

		}

	} while (errn > 0);

	close(pipefd[0]);

	if (errp > 0) {

		/* End of file without \n */

		errbuf[errp] = '\0';

		if ((s_ver = strstr(errbuf, "nfs-utils"))) {

			if (extract_version(s_ver, vers))

				ret = 1;

		}

	}

	if (ret) {

		if ((vers->major < check->major) ||

		    ((vers->major == check->major) && (vers->minor < check->minor)) ||

		    ((vers->major == check->major) && (vers->minor == check->minor) &&

		     (vers->fix < check->fix)))

			ret = 0;

	}

	if (waitpid(f, &status, 0) != f)

		debug(LOGOPT_NONE, "no process found to wait for");

	pthread_sigmask(SIG_SETMASK, &oldsig, NULL);

	pthread_setcancelstate(cancel_state, NULL);

	return ret;

}

#else

int check_nfs_mount_version(struct nfs_mount_vers *vers,

			    struct nfs_mount_vers *check)

{

	return 0;

}

#endif

static char *set_env_name(const char *prefix, const char *name, char *buf)

{

	size_t len;

	len = strlen(name);

	if (prefix)

		len += strlen(prefix);

	len++;

	if (len > MAX_ENV_NAME)

		return NULL;

	if (!prefix)

		strcpy(buf, name);

	else {

		strcpy(buf, prefix);

		strcat(buf, name);

	}

	return buf;

}

static struct substvar *do_macro_addvar(struct substvar *list,

					const char *prefix,

					const char *name,

					const char *val)

{

	char buf[MAX_ENV_NAME + 1];

	char *new;

	size_t len;

	new = set_env_name(prefix, name, buf);

	if (new) {

		len = strlen(new);

		list = macro_addvar(list, new, len, val);

	}

	return list;

}

static struct substvar *do_macro_removevar(struct substvar *list,

					   const char *prefix,

					   const char *name)

{

	char buf[MAX_ENV_NAME + 1];

	char *new;

	size_t len;

	new = set_env_name(prefix, name, buf);

	if (new) {

		len = strlen(new);

		list = macro_removevar(list, new, len);

	}

	return list;

}

struct substvar *addstdenv(struct substvar *sv, const char *prefix)

{

	struct substvar *list = sv;

	struct thread_stdenv_vars *tsv;

	char numbuf[16];

	tsv = pthread_getspecific(key_thread_stdenv_vars);

	if (tsv) {

		const struct substvar *mv;

		int ret;

		long num;

		num = (long) tsv->uid;

		ret = sprintf(numbuf, "%ld", num);

		if (ret > 0)

			list = do_macro_addvar(list, prefix, "UID", numbuf);

		num = (long) tsv->gid;

		ret = sprintf(numbuf, "%ld", num);

		if (ret > 0)

			list = do_macro_addvar(list, prefix, "GID", numbuf);

		list = do_macro_addvar(list, prefix, "USER", tsv->user);

		list = do_macro_addvar(list, prefix, "GROUP", tsv->group);

		list = do_macro_addvar(list, prefix, "HOME", tsv->home);

		mv = macro_findvar(list, "HOST", 4);

		if (mv) {

			char *shost = strdup(mv->val);

			if (shost) {

				char *dot = strchr(shost, '.');

				if (dot)

					*dot = '\0';

				list = do_macro_addvar(list,

						       prefix, "SHOST", shost);

				free(shost);

			}

		}

	}

	return list;

}

struct substvar *removestdenv(struct substvar *sv, const char *prefix)

{

	struct substvar *list = sv;

	list = do_macro_removevar(list, prefix, "UID");

	list = do_macro_removevar(list, prefix, "USER");

	list = do_macro_removevar(list, prefix, "HOME");

	list = do_macro_removevar(list, prefix, "GID");

	list = do_macro_removevar(list, prefix, "GROUP");

	list = do_macro_removevar(list, prefix, "SHOST");

	return list;

}

void add_std_amd_vars(struct substvar *sv)

{

	char *tmp;

	tmp = conf_amd_get_arch();

	if (tmp) {

		macro_global_addvar("arch", 4, tmp);

		free(tmp);

	}

	tmp = conf_amd_get_karch();

	if (tmp) {

		macro_global_addvar("karch", 5, tmp);

		free(tmp);

	}

	tmp = conf_amd_get_os();

	if (tmp) {

		macro_global_addvar("os", 2, tmp);

		free(tmp);

	}

	tmp = conf_amd_get_full_os();

	if (tmp) {

		macro_global_addvar("full_os", 7, tmp);

		free(tmp);

	}

	tmp = conf_amd_get_os_ver();

	if (tmp) {

		macro_global_addvar("osver", 5, tmp);

		free(tmp);

	}

	tmp = conf_amd_get_vendor();

	if (tmp) {

		macro_global_addvar("vendor", 6, tmp);

		free(tmp);

	}

	/* Umm ... HP_UX cluster name, probably not used */

	tmp = conf_amd_get_cluster();

	if (tmp) {

		macro_global_addvar("cluster", 7, tmp);

		free(tmp);

	} else {

		const struct substvar *v = macro_findvar(sv, "domain", 4);

		if (v && *v->val) {

			tmp = strdup(v->val);

			if (tmp) {

				macro_global_addvar("cluster", 7, tmp);

				free(tmp);

			}

		}

	}

	tmp = conf_amd_get_auto_dir();

	if (tmp) {

		macro_global_addvar("autodir", 7, tmp);

		free(tmp);

	}

	return;

}

void remove_std_amd_vars(void)

{

	macro_global_removevar("autodir", 7);

	macro_global_removevar("cluster", 7);

	macro_global_removevar("vendor", 6);

	macro_global_removevar("osver", 5);

	macro_global_removevar("full_os", 7);

	macro_global_removevar("os", 2);

	macro_global_removevar("karch", 5);

	macro_global_removevar("arch", 4);

	return;

 }

struct amd_entry *new_amd_entry(const struct substvar *sv)

{

	struct amd_entry *new;

	const struct substvar *v;

	char *path;

	v = macro_findvar(sv, "path", 4);

	if (!v)

		return NULL;

	path = strdup(v->val);

	if (!path)

		return NULL;

	new = malloc(sizeof(struct amd_entry));

	if (!new) {

		free(path);

		return NULL;

	}

	memset(new, 0, sizeof(*new));

	new->path = path;

	INIT_LIST_HEAD(&new->list);

	INIT_LIST_HEAD(&new->entries);

	INIT_LIST_HEAD(&new->ext_mount);

	return new;

}

void clear_amd_entry(struct amd_entry *entry)

{

	if (!entry)

		return;

	if (entry->path)

		free(entry->path);

	if (entry->map_type)

		free(entry->map_type);

	if (entry->pref)

		free(entry->pref);

	if (entry->fs)

		free(entry->fs);

	if (entry->rhost)

		free(entry->rhost);

	if (entry->rfs)

		free(entry->rfs);

	if (entry->opts)

		free(entry->opts);

	if (entry->addopts)

		free(entry->addopts);

	if (entry->remopts)

		free(entry->remopts);

	if (entry->sublink)

		free(entry->sublink);

	if (entry->selector)

		free_selector(entry->selector);

	return;

}

void free_amd_entry(struct amd_entry *entry)

{

	clear_amd_entry(entry);

	free(entry);

	return;

}

void free_amd_entry_list(struct list_head *entries)

{

	if (!list_empty(entries)) {

		struct list_head *head = entries;

		struct amd_entry *this;

		struct list_head *p;

		p = head->next;

		while (p != head) {

			this = list_entry(p, struct amd_entry, list);

			p = p->next;

			free_amd_entry(this);

		}

	}

}

/*

 * Make common autofs mount options string

 */

char *make_options_string(char *path, int pipefd, const char *extra)

{

	char *options;

	int len;

	options = malloc(MAX_OPTIONS_LEN + 1);

	if (!options) {

		logerr("can't malloc options string");

		return NULL;

	}

	if (extra) 

		len = snprintf(options, MAX_OPTIONS_LEN,

				options_template_extra,

				pipefd, (unsigned) getpgrp(),

				AUTOFS_MAX_PROTO_VERSION, extra);

	else

		len = snprintf(options, MAX_OPTIONS_LEN, options_template,

			pipefd, (unsigned) getpgrp(),

			AUTOFS_MAX_PROTO_VERSION);

	if (len >= MAX_OPTIONS_LEN) {

		logerr("buffer to small for options - truncated");

		len = MAX_OPTIONS_LEN - 1;

	}

	if (len < 0) {

		logerr("failed to malloc autofs mount options for %s", path);

		free(options);

		return NULL;

	}

	options[len] = '\0';

	return options;

}

char *make_mnt_name_string(char *path)

{

	char *mnt_name;

	int len;

	mnt_name = malloc(MAX_MNT_NAME_LEN + 1);

	if (!mnt_name) {

		logerr("can't malloc mnt_name string");

		return NULL;

	}

	len = snprintf(mnt_name, MAX_MNT_NAME_LEN,

			mnt_name_template, (unsigned) getpid());

	if (len >= MAX_MNT_NAME_LEN) {

		logerr("buffer to small for mnt_name - truncated");

		len = MAX_MNT_NAME_LEN - 1;

	}

	if (len < 0) {

		logerr("failed setting up mnt_name for autofs path %s", path);

		free(mnt_name);

		return NULL;

	}

	mnt_name[len] = '\0';

	return mnt_name;

}

static void ext_mounts_hash_init(void)

{

	int i;

	for (i = 0; i < EXT_MOUNTS_HASH_SIZE; i++)

		INIT_LIST_HEAD(&ext_mounts_hash[i]);

	ext_mounts_hash_init_done = 1;

}

static struct ext_mount *ext_mount_lookup(const char *mountpoint)

{

	u_int32_t hval = hash(mountpoint, EXT_MOUNTS_HASH_SIZE);

	struct list_head *p, *head;

	if (!ext_mounts_hash_init_done)

		ext_mounts_hash_init();

	if (list_empty(&ext_mounts_hash[hval]))

		return NULL;

	head = &ext_mounts_hash[hval];

	list_for_each(p, head) {

		struct ext_mount *this = list_entry(p, struct ext_mount, mount);

		if (!strcmp(this->mountpoint, mountpoint))

			return this;

	}

	return NULL;

}

int ext_mount_add(struct list_head *entry, const char *path, unsigned int umount)

{

	struct ext_mount *em;

	u_int32_t hval;

	int ret = 0;

	pthread_mutex_lock(&ext_mount_hash_mutex);

	em = ext_mount_lookup(path);

	if (em) {

		struct list_head *p, *head;

		head = &em->mounts;

		list_for_each(p, head) {

			if (p == entry)

				goto done;

		}

		list_add_tail(entry, &em->mounts);

		ret = 1;

		goto done;

	}

	em = malloc(sizeof(struct ext_mount));

	if (!em)

		goto done;

	em->mountpoint = strdup(path);

	if (!em->mountpoint) {

		free(em);

		goto done;

	}

	em->umount = umount;

	INIT_LIST_HEAD(&em->mount);

	INIT_LIST_HEAD(&em->mounts);

	hval = hash(path, EXT_MOUNTS_HASH_SIZE);

	list_add_tail(&em->mount, &ext_mounts_hash[hval]);

	list_add_tail(entry, &em->mounts);

	ret = 1;

done:

	pthread_mutex_unlock(&ext_mount_hash_mutex);

	return ret;

}

int ext_mount_remove(struct list_head *entry, const char *path)

{

	struct ext_mount *em;

	int ret = 0;

	pthread_mutex_lock(&ext_mount_hash_mutex);

	em = ext_mount_lookup(path);

	if (!em)

		goto done;

	list_del_init(entry);

	if (!list_empty(&em->mounts))

		goto done;

	else {

		list_del_init(&em->mount);

		if (em->umount)

			ret = 1;

		if (list_empty(&em->mount)) {

			free(em->mountpoint);

			free(em);

		}

	}

done:

	pthread_mutex_unlock(&ext_mount_hash_mutex);

	return ret;

}

int ext_mount_inuse(const char *path)

{

	struct ext_mount *em;

	int ret = 0;

	pthread_mutex_lock(&ext_mount_hash_mutex);

	em = ext_mount_lookup(path);

	if (!em)

		goto done;

	if (!list_empty(&em->mounts))

		ret = 1;

done:

	pthread_mutex_unlock(&ext_mount_hash_mutex);

	return ret;

}

/* From glibc decode_name() */

/* Since the values in a line are separated by spaces, a name cannot

 * contain a space.  Therefore some programs encode spaces in names

 * by the strings "\040".  We undo the encoding when reading an entry.

 * The decoding happens in place.

 */

static char *local_decode_name(char *buf)

{

	char *rp = buf;

	char *wp = buf;

	do {

		if (rp[0] == '\\' && rp[1] == '0' &&

		    rp[2] == '4' && rp[3] == '0') {

			/* \040 is a SPACE.  */

			*wp++ = ' ';

			rp += 3;

		} else if (rp[0] == '\\' && rp[1] == '0' &&

			   rp[2] == '1' && rp[3] == '1') {

			/* \011 is a TAB.  */

			*wp++ = '\t';

			rp += 3;

		} else if (rp[0] == '\\' && rp[1] == '0' &&

			   rp[2] == '1' && rp[3] == '2') {

			/* \012 is a NEWLINE.  */

			*wp++ = '\n';

			rp += 3;

		} else if (rp[0] == '\\' && rp[1] == '\\') {

			/*

			 * We have to escape \\ to be able to represent

			 * all characters.

			 */

			*wp++ = '\\';

			rp += 1;

		} else if (rp[0] == '\\' && rp[1] == '1' &&

			   rp[2] == '3' && rp[3] == '4') {

			/* \134 is also \\.  */

			*wp++ = '\\';

			rp += 3;

		} else

			*wp++ = *rp;

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

	return buf;

}

/* From glibc getmntent_r() */

static struct mntent *

local_getmntent_r(FILE *tab, struct mntent *mnt, char *buf, int size)

{

	char *cp, *head;

	do {

		char *end_ptr;

		if (fgets(buf, size, tab) == NULL)

			return 0;

		end_ptr = strchr(buf, '\n');

		if (end_ptr != NULL) {

			while (end_ptr[-1] == ' ' || end_ptr[-1] == '\t')

				end_ptr--;

			*end_ptr = '\0';

		} else {

			/* Whole line was not read. Do it now but forget it. */

			char tmp[1024];

			while (fgets(tmp, sizeof tmp, tab) != NULL)

				if (strchr(tmp, '\n') != NULL)

					break;

		}

		head = buf + strspn(buf, " \t");

	/* skip empty lines and comment lines */

	} while (head[0] == '\0' || head[0] == '#');

	cp = strsep(&head, " \t");

	mnt->mnt_fsname = cp != NULL ? local_decode_name(cp) : (char *) "";

	if (head)

		head += strspn(head, " \t");

	cp = strsep(&head, " \t");

	mnt->mnt_dir = cp != NULL ? local_decode_name (cp) : (char *) "";

	if (head)

		head += strspn(head, " \t");

	cp = strsep(&head, " \t");

	mnt->mnt_type = cp != NULL ? local_decode_name (cp) : (char *) "";

	if (head)

		head += strspn (head, " \t");

	cp = strsep (&head, " \t");

	mnt->mnt_opts = cp != NULL ? local_decode_name (cp) : (char *) "";

	/* autofs doesn't need freq or passno */