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

 *   

 *  parse_sun.c - module for Linux automountd to parse a Sun-format

 *                automounter map

 * 

 *   Copyright 1997 Transmeta Corporation - All Rights Reserved

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

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

 *

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

#include <stdio.h>

#include <malloc.h>

#include <netdb.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <limits.h>

#include <sys/param.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/vfs.h>

#include <sys/utsname.h>

#include <netinet/in.h>

#include <sys/mount.h>

#include <linux/fs.h>

#define MODULE_PARSE

#include "automount.h"

#define MODPREFIX "parse(sun): "

int parse_version = AUTOFS_PARSE_VERSION;	/* Required by protocol */

static struct mount_mod *mount_nfs = NULL;

static int init_ctr = 0;

static pthread_mutex_t instance_mutex = PTHREAD_MUTEX_INITIALIZER;

static void instance_mutex_lock(void)

{

	int status = pthread_mutex_lock(&instance_mutex);

	if (status)

		fatal(status);

}

static void instance_mutex_unlock(void)

{

	int status = pthread_mutex_unlock(&instance_mutex);

	if (status)

		fatal(status);

}

extern const char *global_options;

struct parse_context {

	char *optstr;		/* Mount options */

	char *macros;		/* Map wide macro defines */

	struct substvar *subst;	/* $-substitutions */

	int slashify_colons;	/* Change colons to slashes? */

};

struct multi_mnt {

	char *path;

	char *options;

	char *location;

	struct multi_mnt *next;

};

/* Default context */

static struct parse_context default_context = {

	NULL,			/* No mount options */

	NULL,			/* No map wide macros */

	NULL,			/* The substvar local vars table */

	1			/* Do slashify_colons */

};

int destroy_logpri_fifo(struct autofs_point *ap);

static char *concat_options(char *left, char *right);

/* Free all storage associated with this context */

static void kill_context(struct parse_context *ctxt)

{

	macro_lock();

	macro_free_table(ctxt->subst);

	macro_unlock();

	if (ctxt->optstr)

		free(ctxt->optstr);

	if (ctxt->macros)

		free(ctxt->macros);

	free(ctxt);

}

/* 

 * $- and &-expand a Sun-style map entry and return the length of the entry.

 * If "dst" is NULL, just count the length.

 */

int expandsunent(const char *src, char *dst, const char *key,

		 const struct substvar *svc, int slashify_colons)

{

	const struct substvar *sv;

	int len, l, seen_colons;

	const char *p;

	char ch;

	len = 0;

	seen_colons = 0;

	while ((ch = *src++)) {

		switch (ch) {

		case '&':

			l = strlen(key);

			/*

			 * In order to ensure that any isspace() characters

			 * in the key are preserved, we need to escape them

			 * here.

			 */

			const char *keyp = key;

			while (*keyp) {

				if (isspace(*keyp)) {

					if (dst) {

						*dst++ = '\\';

						*dst++ = *keyp++;

					} else

						keyp++;

					l++;

				} else {

					if (dst)

						*dst++ = *keyp++;

					else

						keyp++;

				}

			}

			len += l;

			break;

		case '$':

			if (*src == '{') {

				p = strchr(++src, '}');

				if (!p) {

					/* Ignore rest of string */

					if (dst)

						*dst = '\0';

					return len;

				}

				sv = macro_findvar(svc, src, p - src);

				if (sv) {

					l = strlen(sv->val);

					if (dst) {

						strcpy(dst, sv->val);

						dst += l;

					}

					len += l;

				}

				src = p + 1;

			} else {

				p = src;

				while (isalnum(*p) || *p == '_')

					p++;

				sv = macro_findvar(svc, src, p - src);

				if (sv) {

					l = strlen(sv->val);

					if (dst) {

						strcpy(dst, sv->val);

						dst += l;

					}

					len += l;

				}

				src = p;

			}

			break;

		case '\\':

			len++;

			if (dst)

				*dst++ = ch;

			if (*src) {

				len++;

				if (dst)

					*dst++ = *src;

				src++;

			}

			break;

		case '"':

			len++;

			if (dst)

				*dst++ = ch;

			while (*src && *src != '"') {

				len++;

				if (dst)

					*dst++ = *src;

				src++;

			}

			if (*src && dst) {

				len++;

				*dst++ = *src++;

			}

			break;

		case ':':

			if (dst)

				*(dst++) = 

				  (seen_colons && slashify_colons) ? '/' : ':';

			len++;

			/* Were looking for the colon preceeding a path */

			if (*src == '/')

				seen_colons = 1;

			break;

		default:

			if (isspace(ch))

				seen_colons = 0;

			if (dst)

				*(dst++) = ch;

			len++;

			break;

		}

	}

	if (dst)

		*dst = '\0';

	return len;

}

static int do_init(int argc, const char *const *argv, struct parse_context *ctxt)

{

	char *noptstr, *def, *val, *macros, *gbl_options;

	char buf[MAX_ERR_BUF];

	int optlen, len, offset;

	const char *xopt;

	int i, bval;

	unsigned int append_options;

	optlen = 0;

	/* Look for options and capture, and create new defines if we need to */

	for (i = 0; i < argc; i++) {

		if (argv[i][0] == '-' &&

		   (argv[i][1] == 'D' || argv[i][1] == '-') ) {

			switch (argv[i][1]) {

			case 'D':

				if (argv[i][2])

					def = strdup(argv[i] + 2);

				else if (++i < argc)

					def = strdup(argv[i]);

				else

					break;

				if (!def) {

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

					logerr(MODPREFIX "strdup: %s", estr);

					break;

				}

				val = strchr(def, '=');

				if (val)

					*(val++) = '\0';

				else

					val = "";

				macro_lock();

				ctxt->subst = macro_addvar(ctxt->subst,

							def, strlen(def), val);

				macro_unlock();

				/* we use 5 for the "-D", "=", "," and the null */

				if (ctxt->macros) {

					len = strlen(ctxt->macros) + strlen(def) + strlen(val);

					macros = realloc(ctxt->macros, len + 5);

					if (!macros) {

						free(def);

						break;

					}

					strcat(macros, ",");

				} else { /* No comma, so only +4 */

					len = strlen(def) + strlen(val);

					macros = malloc(len + 4);

					if (!macros) {

						free(def);

						break;

					}

					*macros = '\0';

				}

				ctxt->macros = macros;

				strcat(ctxt->macros, "-D");

				strcat(ctxt->macros, def);

				strcat(ctxt->macros, "=");

				strcat(ctxt->macros, val);

				free(def);

				break;

			case '-':

				if (!strncmp(argv[i] + 2, "no-", 3)) {

					xopt = argv[i] + 5;

					bval = 0;

				} else {

					xopt = argv[i] + 2;

					bval = 1;

				}

				if (!strmcmp(xopt, "slashify-colons", 1))

					ctxt->slashify_colons = bval;

				else

					error(LOGOPT_ANY,

					      MODPREFIX "unknown option: %s",

					      argv[i]);

				break;

			default:

				error(LOGOPT_ANY,

				      MODPREFIX "unknown option: %s", argv[i]);

				break;

			}

		} else {

			offset = (argv[i][0] == '-' ? 1 : 0);

			len = strlen(argv[i] + offset);

			if (ctxt->optstr) {

				noptstr =

				    (char *) realloc(ctxt->optstr, optlen + len + 2);

				if (noptstr) {

					noptstr[optlen] = ',';

					strcpy(noptstr + optlen + 1, argv[i] + offset);

					optlen += len + 1;

				}

			} else {

				noptstr = (char *) malloc(len + 1);

				if (noptstr) {

					strcpy(noptstr, argv[i] + offset);

					optlen = len;

				}

			}

			if (!noptstr) {

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

				logerr(MODPREFIX "%s", estr);

				return 1;

			}

			ctxt->optstr = noptstr;

		}

	}

	gbl_options = NULL;

	if (global_options) {

		if (ctxt->optstr && strstr(ctxt->optstr, global_options))

			goto options_done;

		gbl_options = strdup(global_options);

	}

	if (gbl_options) {

		append_options = defaults_get_append_options();

		if (append_options) {

			char *tmp = concat_options(gbl_options, ctxt->optstr);

			if (!tmp) {

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

				logerr(MODPREFIX "concat_options: %s", estr);

				free(gbl_options);

			} else

				ctxt->optstr = tmp;

		} else {

			if (!ctxt->optstr)

				ctxt->optstr = gbl_options;

			else

				free(gbl_options);

		}

	}

options_done:

	debug(LOGOPT_NONE,

	      MODPREFIX "init gathered global options: %s", ctxt->optstr);

	return 0;

}

int parse_init(int argc, const char *const *argv, void **context)

{

	struct parse_context *ctxt;

	char buf[MAX_ERR_BUF];

	*context = NULL;

	/* Set up context and escape chain */

	ctxt = (struct parse_context *) malloc(sizeof(struct parse_context));

	if (!ctxt) {

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

		logerr(MODPREFIX "malloc: %s", estr);

		return 1;

	}

	*ctxt = default_context;

	if (do_init(argc, argv, ctxt)) {

		free(ctxt);

		return 1;

	}

	/* We only need this once.  NFS mounts are so common that we cache

	   this module. */

	instance_mutex_lock();

	if (mount_nfs)

		init_ctr++;

	else {

		if ((mount_nfs = open_mount("nfs", MODPREFIX))) {

			init_ctr++;

		} else {

			kill_context(ctxt);

			instance_mutex_unlock();

			return 1;

		}

	}

	instance_mutex_unlock();

	*context = (void *) ctxt;

	return 0;

}

int parse_reinit(int argc, const char *const *argv, void **context)

{

	struct parse_context *ctxt = (struct parse_context *) *context;

	struct parse_context *new;

	char buf[MAX_ERR_BUF];

	new = (struct parse_context *) malloc(sizeof(struct parse_context));

	if (!new) {

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

		logerr(MODPREFIX "malloc: %s", estr);

		return 1;

	}

	*new = default_context;

	if (do_init(argc, argv, new)) {

		free(new);

		return 1;

	}

	kill_context(ctxt);

	*context = (void *) new;

	return 0;

}

static const char *parse_options(const char *str, char **ret, unsigned int logopt)

{

	const char *cp = str;

	int len;

	if (*cp++ != '-')

		return str;

	if (*ret != NULL)

		free(*ret);

	len = chunklen(cp, 0);

	*ret = dequote(cp, len, logopt);

	return cp + len;

}

static char *concat_options(char *left, char *right)

{

	char buf[MAX_ERR_BUF];

	char *ret;

	if (left == NULL || *left == '\0') {

		ret = strdup(right);

		free(right);

		return ret;

	}

	if (right == NULL || *right == '\0') {

		ret = strdup(left);

		free(left);

		return ret;

	}

	ret = malloc(strlen(left) + strlen(right) + 2);

	if (ret == NULL) {

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

		logerr(MODPREFIX "malloc: %s", estr);

		return NULL;

	}

	strcpy(ret, left);

	strcat(ret, ",");

	strcat(ret, right);

	free(left);

	free(right);

	return ret;

}

static int sun_mount(struct autofs_point *ap, const char *root,

			const char *name, int namelen,

			const char *loc, int loclen, const char *options,

			struct parse_context *ctxt)

{

	char *fstype = "nfs";	/* Default filesystem type */

	int nonstrict = 1;

	int use_weight_only = ap->flags & MOUNT_FLAG_USE_WEIGHT_ONLY;

	int rv, cur_state;

	char *mountpoint;

	char *what;

	char *type;

	if (*options == '\0')

		options = NULL;

	if (options) {

		char *noptions;

		const char *comma;

		char *np;

		int len = strlen(options) + 1;

		noptions = np = alloca(len);

		*np = '\0';

		/* Extract fstype= pseudo option */

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

			const char *cp;

			while (*comma == ',')

				comma++;

			cp = comma;

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

				comma++;

			if (_strncmp("fstype=", cp, 7) == 0) {

				int typelen = comma - (cp + 7);

				fstype = alloca(typelen + 1);

				memcpy(fstype, cp + 7, typelen);

				fstype[typelen] = '\0';

			} else if (_strncmp("nonstrict", cp, 9) == 0) {

				nonstrict = 1;

			} else if (_strncmp("strict", cp, 6) == 0 &&

				   comma - cp == 6) {

				nonstrict = 0;

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

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

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

				if (strcmp(fstype, "autofs") == 0 ||

				    strstr(cp, "fstype=autofs")) {

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

					np += comma - cp + 1;

				}

			} else if (_strncmp("no-use-weight-only", cp, 18) == 0) {

				use_weight_only = -1;

			} else if (_strncmp("use-weight-only", cp, 15) == 0) {

				use_weight_only = MOUNT_FLAG_USE_WEIGHT_ONLY;

			} else if (_strncmp("bg", cp, 2) == 0 ||

				   _strncmp("nofg", cp, 4) == 0) {

				continue;

			} else {

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

				np += comma - cp + 1;

			}

		}

		if (np > noptions + len) {

			warn(ap->logopt, MODPREFIX "options string truncated");

			np[len] = '\0';

		} else

			*(np - 1) = '\0';

		options = noptions;

	}

	if (!strcmp(fstype, "autofs") && ctxt->macros) {

		char *noptions = NULL;

		if (!options || *options == '\0') {

			noptions = alloca(strlen(ctxt->macros) + 1);

			*noptions = '\0';

		} else {

			int len = strlen(options) + strlen(ctxt->macros) + 2;

			noptions = alloca(len);

			if (noptions) {

				strcpy(noptions, options);

				strcat(noptions, ",");

			}

		}

		if (noptions && *noptions != '\0') {

			strcat(noptions, ctxt->macros);

			options = noptions;

		} else {

			error(ap->logopt,

			      MODPREFIX "alloca failed for options");

		}

	}

	mountpoint = alloca(namelen + 1);

	sprintf(mountpoint, "%.*s", namelen, name);

	type = ap->entry->maps->type;

	if (type && !strcmp(type, "hosts")) {

		if (options && *options != '\0') {

			int len = strlen(options);

			int suid = strstr(options, "suid") ? 0 : 7;

			int dev = strstr(options, "dev") ? 0 : 6;

			int nointr = strstr(options, "nointr") ? 0 : 5;

			if (suid || dev || nointr) {

				char *tmp = alloca(len + suid + dev + nointr + 1);

				if (!tmp) {

					error(ap->logopt, MODPREFIX

					      "alloca failed for options");

					if (nonstrict)

						return -1;

					return 1;

				}

				strcpy(tmp, options);

				if (suid)

					strcat(tmp, ",nosuid");

				if (dev)

					strcat(tmp, ",nodev");

				if (nointr)

					strcat(tmp, ",intr");

				options = tmp;

			}

		} else {

			char *tmp = alloca(18);

			if (!tmp) {

				error(ap->logopt,

				      MODPREFIX "alloca failed for options");

				if (nonstrict)

					return -1;

				return 1;

			}

			strcpy(tmp, "nosuid,nodev,intr");

			options = tmp;

		}

	}

	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);

	if (!strcmp(fstype, "nfs") || !strcmp(fstype, "nfs4")) {

		what = alloca(loclen + 1);

		memcpy(what, loc, loclen);

		what[loclen] = '\0';

		/* Add back "[no-]use-weight-only" for NFS mounts only */

		if (use_weight_only) {

			char *tmp;

			int len;

			if (options && *options != '\0') {

				len = strlen(options) + 19;

				tmp = alloca(len);

				strcpy(tmp, options);

				strcat(tmp, ",");

				if (use_weight_only == MOUNT_FLAG_USE_WEIGHT_ONLY)

					strcat(tmp, "use-weight-only");

				else

					strcat(tmp, "no-use-weight-only");

			} else {

				tmp = alloca(19);

				if (use_weight_only == MOUNT_FLAG_USE_WEIGHT_ONLY)

					strcpy(tmp, "use-weight-only");

				else

					strcpy(tmp, "no-use-weight-only");

			}

			options = tmp;

		}

		debug(ap->logopt, MODPREFIX

		      "mounting root %s, mountpoint %s, "

		      "what %s, fstype %s, options %s",

		      root, mountpoint, what, fstype, options);

		rv = mount_nfs->mount_mount(ap, root, mountpoint, strlen(mountpoint),

					    what, fstype, options, mount_nfs->context);

	} else {

		if (!loclen)

			what = NULL;

		else {

			what = alloca(loclen + 1);

			if (*loc == ':') {

				loclen--;

				memcpy(what, loc + 1, loclen);

				what[loclen] = '\0';

			} else {

				memcpy(what, loc, loclen);

				what[loclen] = '\0';

			}

		}

		debug(ap->logopt, MODPREFIX

		      "mounting root %s, mountpoint %s, "

		      "what %s, fstype %s, options %s",

		      root, mountpoint, what, fstype, options);

		/* Generic mount routine */

		rv = do_mount(ap, root, mountpoint, strlen(mountpoint), what, fstype,

			      options);

	}

	pthread_setcancelstate(cur_state, NULL);

	if (nonstrict && rv)

		return -rv;

	return rv;

}

/*

 * Scan map entry looking for evidence it has multiple key/mapent

 * pairs.

 */

static int check_is_multi(const char *mapent)

{

	const char *p = mapent;

	int multi = 0;

	int not_first_chunk = 0;

	if (!p) {

		logerr(MODPREFIX "unexpected NULL map entry pointer");

		return 0;

	}

	if (*p == '"')

		p++;

	/* If first character is "/" it's a multi-mount */

	if (*p == '/')

		return 1;

	while (*p) {

		p = skipspace(p);

		/*

		 * After the first chunk there can be additional

		 * locations (possibly not multi) or possibly an

		 * options string if the first entry includes the

		 * optional '/' (is multi). Following this any

		 * path that begins with '/' indicates a mutil-mount

		 * entry.

		 */

		if (not_first_chunk) {

			if (*p == '"')

				p++;

			if (*p == '/' || *p == '-') {

				multi = 1;

				break;

			}

		}

		while (*p == '-') {

			p += chunklen(p, 0);

			p = skipspace(p);

		}

		/*

		 * Expect either a path or location

		 * after which it's a multi mount.

		 */

		p += chunklen(p, check_colon(p));

		not_first_chunk++;

	}

	return multi;

}

static int

update_offset_entry(struct autofs_point *ap, const char *name,

		    const char *m_root, int m_root_len,

		    const char *path, const char *myoptions, const char *loc,

		    time_t age)

{

	struct map_source *source;

	struct mapent_cache *mc;

	char m_key[PATH_MAX + 1];

	char m_mapent[MAPENT_MAX_LEN + 1];

	int p_len, m_key_len, m_options_len, m_mapent_len;

	int ret;

	source = ap->entry->current;

	ap->entry->current = NULL;

	master_source_current_signal(ap->entry);

	mc = source->mc;

	memset(m_mapent, 0, MAPENT_MAX_LEN + 1);

	/* Internal hosts map may have loc == NULL */

	if (!*path) {

		error(ap->logopt,

		      MODPREFIX "syntax error in offset %s -> %s", path, loc);

		return CHE_FAIL;

	}

	p_len = strlen(path);

	/* Trailing '/' causes us pain */

	if (p_len > 1) {

		while (p_len > 1 && path[p_len - 1] == '/')

			p_len--;

	}

	m_key_len = m_root_len + p_len;

	if (m_key_len > PATH_MAX) {

		error(ap->logopt, MODPREFIX "multi mount key too long");

		return CHE_FAIL;

	}

	strcpy(m_key, m_root);

	strncat(m_key, path, p_len);

	m_key[m_key_len] = '\0';

	m_options_len = 0;

	if (*myoptions)

		m_options_len = strlen(myoptions) + 2;

	m_mapent_len = loc ? strlen(loc) : 0;

	if (m_mapent_len + m_options_len > MAPENT_MAX_LEN) {

		error(ap->logopt, MODPREFIX "multi mount mapent too long");

		return CHE_FAIL;

	}

	if (*myoptions) {

		strcpy(m_mapent, "-");

		strcat(m_mapent, myoptions);

		if (loc) {

			strcat(m_mapent, " ");

			if (loc)

				strcat(m_mapent, loc);

		}

	} else {

		if (loc)

			strcpy(m_mapent, loc);

	}

	ret = cache_update_offset(mc, name, m_key, m_mapent, age);

	if (ret == CHE_DUPLICATE) {

		warn(ap->logopt, MODPREFIX

		     "syntax error or duplicate offset %s -> %s", path, loc);

		ret = CHE_OK;

	} else if (ret == CHE_FAIL)

		debug(ap->logopt, MODPREFIX

		      "failed to update multi-mount offset %s -> %s", path, m_mapent);

	else {

		ret = CHE_OK;

		debug(ap->logopt, MODPREFIX

		      "updated multi-mount offset %s -> %s", path, m_mapent);

	}

	return ret;

}

static int validate_location(unsigned int logopt, char *loc)

{

	char *ptr = loc;

	/* We don't know much about these */

	if (*ptr == ':')

		return 1;

	/*

	 * If a ':/' is present now it must be a host name, except

	 * for those special file systems like sshfs which use "#"

	 * and "@" in the host name part and ipv6 addresses that

	 * have ":", "[" and "]".

	 */

	if (!check_colon(ptr)) {