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

 *

 *  mount_autofs.c - Module for recursive autofs mounts.

 *

 *   Copyright 1997 Transmeta Corporation - All Rights Reserved

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

 *

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

#include <stdio.h>

#include <stdlib.h>

#include <malloc.h>

#include <string.h>

#include <signal.h>

#include <sys/param.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/wait.h>

#define MODULE_MOUNT

#include "automount.h"

#define MODPREFIX "mount(autofs): "

/* Attribute to create detached thread */

extern pthread_attr_t th_attr_detached;

extern struct startup_cond suc;

int mount_version = AUTOFS_MOUNT_VERSION;	/* Required by protocol */

int mount_init(void **context)

{

	return 0;

}

int mount_reinit(void **context)

{

	return 0;

}

int mount_mount(struct autofs_point *ap, const char *root, const char *name,

		int name_len, const char *what, const char *fstype,

		const char *c_options, void *context)

{

	struct startup_cond suc;

	pthread_t thid;

	char realpath[PATH_MAX];

	char mountpoint[PATH_MAX];

	const char **argv;

	int argc, status;

	int nobind = ap->flags & MOUNT_FLAG_NOBIND;

	int ghost = ap->flags & MOUNT_FLAG_GHOST;

	int symlnk = ap->flags & MOUNT_FLAG_SYMLINK;

	int strictexpire = ap->flags & MOUNT_FLAG_STRICTEXPIRE;

	time_t timeout = get_exp_timeout(ap, ap->entry->maps);

	unsigned logopt = ap->logopt;

	struct map_type_info *info;

	struct master *master;

	struct master_mapent *entry;

	struct map_source *source;

	struct autofs_point *nap;

	char buf[MAX_ERR_BUF];

	char *options, *p;

	int len, ret;

	int hosts = 0;

	/* Root offset of multi-mount */

	len = strlen(root);

	if (root[len - 1] == '/') {

		strcpy(realpath, ap->path);

		strcat(realpath, "/");

		strcat(realpath, name);

		len--;

		strncpy(mountpoint, root, len);

		mountpoint[len] = '\0';

	} else if (*name == '/') {

		if (ap->flags & MOUNT_FLAG_REMOUNT) {

			strcpy(mountpoint, name);

			strcpy(realpath, name);

		} else {

			strcpy(mountpoint, root);

			strcpy(realpath, name);

		}

	} else {

		strcpy(mountpoint, root);

		strcat(mountpoint, "/");

		strcpy(realpath, mountpoint);

		strcat(mountpoint, name);

		strcat(realpath, name);

	}

	options = NULL;

	if (c_options) {

		char *noptions;

		const char *comma;

		char *np;

		int len = strlen(c_options) + 1;

		noptions = np = alloca(len);

		if (!np) {

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

			error(ap->logopt, MODPREFIX "alloca: %s", estr);

			return 1;

		}

		memset(np, 0, len);

		/* Grab the autofs specific options */

		for (comma = c_options; *comma != '\0';) {

			const char *cp;

			while (*comma == ',')

				comma++; 

			cp = comma;

			while (*comma != '\0' && *comma != ',')

				comma++;

			if (_strncmp("nobrowse", cp, 8) == 0 ||

			    _strncmp("nobrowsable", cp, 11) == 0)

				ghost = 0;

			else if (_strncmp("nobind", cp, 6) == 0)

				nobind = 1;

			else if (_strncmp("browse", cp, 6) == 0 ||

				 _strncmp("browsable", cp, 9) == 0)

				ghost = 1;

			else if (_strncmp("symlink", cp, 7) == 0)

				symlnk = 1;

			else if (_strncmp("strictexpire", cp, 12) == 0)

				strictexpire = 1;

			else if (_strncmp("hosts", cp, 5) == 0)

				hosts = 1;

			else if (_strncmp("timeout=", cp, 8) == 0) {

				char *val = strchr(cp, '=');

				unsigned tout;

				if (val) {

					int ret = sscanf(cp, "timeout=%u", &tout);

					if (ret)

						timeout = tout;

				}

			} else {

				memcpy(np, cp, comma - cp + 1);

				np += comma - cp + 1;

			}

		}

		options = noptions;

	}

	debug(ap->logopt,

	      MODPREFIX "mountpoint=%s what=%s options=%s",

	      mountpoint, what, options);

	master = ap->entry->master;

	entry = master_new_mapent(master, realpath, ap->entry->age);

	if (!entry) {

		error(ap->logopt,

		      MODPREFIX "failed to malloc master_mapent struct");

		return 1;

	}

	ret = master_add_autofs_point(entry, logopt, nobind, ghost, 1);

	if (!ret) {

		error(ap->logopt,

		      MODPREFIX "failed to add autofs_point to entry");

		master_free_mapent(entry);

		return 1;

	}

	nap = entry->ap;

	nap->parent = ap;

	if (symlnk)

		nap->flags |= MOUNT_FLAG_SYMLINK;

	if (strictexpire)

		nap->flags |= MOUNT_FLAG_STRICTEXPIRE;

	if (hosts)

		argc = 0;

	else

		argc = 1;

	if (options) {

		char *t = options;

		do {

			argc++;

			if (*t == ',')

				t++;

		} while ((t = strchr(t, ',')) != NULL);

	}

	argv = (const char **) alloca((argc + 1) * sizeof(char *));

	if (hosts)

		argc = 0;

	else

		argc = 1;

	/*

	 * If a mount of a hosts map is being requested it will come

	 * ro us via the options. Catch that below when processing the

	 * option and create type info struct then.

	 */

	if (hosts)

		info = parse_map_type_info("hosts:");

	else

		info = parse_map_type_info(what);

	if (!info) {

		error(ap->logopt, MODPREFIX "failed to parse map info");

		master_free_mapent(entry);

		return 1;

	}

	if (info->map)

		argv[0] = info->map;

	if (options) {

		p = options;

		do {

			if (*p == ',') {

				*p = '\0';

				p++;

			}

			argv[argc++] = p;

		} while ((p = strchr(p, ',')) != NULL);

	}

	argv[argc] = NULL;

	/*

	 * For amd type "auto" the map is often re-used so check

	 * if the the parent map can be used and use it if it

	 * matches.

	 *

	 * Also if the parent map format is amd and the format

	 * isn't specified in the map entry set it from the parent

	 * map source.

	 */

	source = NULL;

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

		struct map_source *s = ap->entry->maps;

		/*

		 * For amd maps, if the format and source type aren't

		 * specified try and set them from the parent.

		 */

		if (!info->format) {

			info->format = strdup("amd");

			if (!info->format)

				warn(ap->logopt, MODPREFIX

				     "failed to set amd map format");

			if (!info->type && s->type) {

				info->type = strdup(s->type);

				if (!info->type)

					warn(ap->logopt, MODPREFIX

					     "failed to set amd map type");

			}

		}

		source = master_get_map_source(ap->entry,

					       info->type, info->format,

					       argc, argv);

		if (source)

			entry->maps = source;

	}

	if (!source)

		source = master_add_map_source(entry,

					       info->type, info->format,

					       monotonic_time(NULL),

					       argc, argv);

	if (!source) {

		error(ap->logopt,

		      MODPREFIX "failed to add map source to entry");

		master_free_mapent(entry);

		free_map_type_info(info);

		return 1;

	}

	free_map_type_info(info);

	set_exp_timeout(nap, NULL, timeout);

	nap->exp_runfreq = (timeout + CHECK_RATIO - 1) / CHECK_RATIO;

	mounts_mutex_lock(ap);

	if (source->flags & MAP_FLAG_FORMAT_AMD) {

		struct amd_entry *am_entry = __master_find_amdmount(ap, entry->path);

		if (am_entry) {

			if (am_entry->pref) {

				nap->pref = am_entry->pref;

				am_entry->pref = NULL;

			}

			if (am_entry->cache_opts & AMD_CACHE_OPTION_ALL)

				nap->flags |= MOUNT_FLAG_AMD_CACHE_ALL;

		}

	}

	if (handle_mounts_startup_cond_init(&suc)) {

		crit(ap->logopt, MODPREFIX

		     "failed to init startup cond for mount %s", entry->path);

		mounts_mutex_unlock(ap);

		master_free_map_source(source, 1);

		master_free_mapent(entry);

		return 1;

	}

	suc.ap = nap;

	suc.root = mountpoint;

	suc.done = 0;

	suc.status = 0;

	if (pthread_create(&thid, &th_attr_detached, handle_mounts, &suc)) {

		crit(ap->logopt,

		     MODPREFIX

		     "failed to create mount handler thread for %s",

		     realpath);

		handle_mounts_startup_cond_destroy(&suc);

		mounts_mutex_unlock(ap);

		master_free_map_source(source, 1);

		master_free_mapent(entry);

		return 1;

	}

	while (!suc.done) {

		status = pthread_cond_wait(&suc.cond, &suc.mutex);

		if (status) {

			handle_mounts_startup_cond_destroy(&suc);

			mounts_mutex_unlock(ap);

			master_free_map_source(source, 1);

			master_free_mapent(entry);

			fatal(status);

		}

	}

	if (suc.status) {

		crit(ap->logopt,

		     MODPREFIX "failed to create submount for %s", realpath);

		handle_mounts_startup_cond_destroy(&suc);

		mounts_mutex_unlock(ap);

		master_free_map_source(source, 1);

		master_free_mapent(entry);

		return 1;

	}

	nap->thid = thid;

	ap->submnt_count++;

	list_add(&nap->mounts, &ap->submounts);

	handle_mounts_startup_cond_destroy(&suc);

	mounts_mutex_unlock(ap);

	return 0;

}

int mount_done(void *context)

{

	return 0;

}