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

 *

 *  Copyright 2013 Ian Kent <raven@themaw.net>

 *  Copyright 2013 Red Hat, Inc.

 *  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 <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"

#include "nsswitch.h"

#define MODPREFIX "parse(amd): "

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 */

};

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 */

};

/* 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);

}

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

{

	struct parse_context *ctxt;

	char buf[MAX_ERR_BUF];

	sel_hash_init();

	/* Set up context and escape chain */

	if (!(ctxt = (struct parse_context *) malloc(sizeof(struct parse_context)))) {

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

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

		*context = NULL;

		return 1;

	}

	*context = (void *) ctxt;

	*ctxt = default_context;

	/* 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);

			*context = NULL;

			instance_mutex_unlock();

			return 1;

		}

	}

	instance_mutex_unlock();

	return 0;

}

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

{

	return 0;

}

static struct substvar *add_lookup_vars(struct autofs_point *ap,

					const char *key, int key_len,

					struct map_source *source,

					struct substvar *sv)

{

	struct substvar *list = sv;

	struct thread_stdenv_vars *tsv;

	char lkp_key[PATH_MAX + 1];

	char path[PATH_MAX + 1];

	struct mapent *me;

	int len;

	len = strlen(ap->path) + 1 + key_len + 1;

	if (len > PATH_MAX) {

		error(ap->logopt, MODPREFIX

		      "error: lookup key is greater than PATH_MAX");

		return NULL;

	}

	if (ap->pref) {

		if (snprintf(lkp_key, sizeof(lkp_key), "%s%s",

			     ap->pref, key) >= sizeof(lkp_key)) {

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

			return NULL;

		}

	} else {

		if (snprintf(lkp_key, sizeof(lkp_key), "%s",

			     key) >= sizeof(lkp_key)) {

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

			return NULL;

		}

	}

	if (*key == '/')

		strcpy(path, key);

	else {

		strcpy(path, ap->path);

		strcat(path, "/");

		strcat(path, key);

	}

	list = macro_addvar(list, "path", 4, path);

	me = cache_lookup_distinct(source->mc, lkp_key);

	if (me)

		list = macro_addvar(list, "key", 3, me->key);

	while (!me) {

		char match[PATH_MAX + 1];

		char *prefix;

		strcpy(match, lkp_key);

		while ((prefix = strrchr(match, '/'))) {

			*prefix = '\0';

			me = cache_partial_match_wild(source->mc, match);

			if (me) {

				list = macro_addvar(list, "key", 3, lkp_key);

				break;

			}

		}

		if (!me) {

			me = cache_lookup_distinct(source->mc, "*");

			if (me)

				list = macro_addvar(list, "key", 3, lkp_key);

		}

		break;

	}

	if (source->name)

		list = macro_addvar(list, "map", 3, source->name);

	else if (source->argv[0][0])

		list = macro_addvar(list, "map", 3, source->argv[0]);

	tsv = pthread_getspecific(key_thread_stdenv_vars);

	if (tsv) {

		char numbuf[16];

		long num;

		int ret;

		num = (long) tsv->uid;

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

		if (ret > 0)

			list = macro_addvar(list, "uid", 3, numbuf);

		num = (long) tsv->gid;

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

		if (ret > 0)

			list = macro_addvar(list, "gid", 3, numbuf);

	}

	list = macro_addvar(list, "fs", 2, "${autodir}/${rhost}${rfs}");

	list = macro_addvar(list, "rfs", 3, path);

	return list;

}

static int match_my_name(unsigned int logopt, const char *name, struct substvar *sv)

{

	struct addrinfo hints, *cni, *ni, *haddr;

	char host[NI_MAXHOST + 1], numeric[NI_MAXHOST + 1];

	const struct substvar *v;

	int rv = 0, ret;

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

	if (v) {

		if (!strcmp(v->val, name))

			return 1;

	}

	if (!v || !v->val) {

		error(logopt, MODPREFIX "error: ${host} not set");

		goto out;

	}

	/* Check if comparison value is an alias */

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

	hints.ai_flags = AI_CANONNAME;

	hints.ai_family = AF_UNSPEC;

	hints.ai_socktype = SOCK_DGRAM;

	/* Get host canonical name */

	ret = getaddrinfo(v->val, NULL, &hints, &cni);

	if (ret) {

		error(logopt, MODPREFIX

		      "hostname lookup failed: %s\n", gai_strerror(ret));

		goto out;

	}

	hints.ai_flags = AI_V4MAPPED | AI_ADDRCONFIG | AI_CANONNAME;

	/* Resolve comparison name to its names and compare */

	ret = getaddrinfo(name, NULL, &hints, &ni);

	if (ret) {

		error(logopt, MODPREFIX

		      "hostname lookup failed: %s\n", gai_strerror(ret));

		freeaddrinfo(cni);

		goto out;

	}

	haddr = ni;

	while (haddr) {

		/* Translate the host address into a numeric string form */

		ret = getnameinfo(haddr->ai_addr, haddr->ai_addrlen,

				  numeric, sizeof(numeric), NULL, 0,

				  NI_NUMERICHOST);

		if (ret) {

			error(logopt, MODPREFIX

			      "host address info lookup failed: %s\n",

			      gai_strerror(ret));

			goto next;

		}

		/* Try to resolve back again to get the canonical name */

		ret = getnameinfo(haddr->ai_addr, haddr->ai_addrlen,

				  host, NI_MAXHOST, NULL, 0, 0);

		if (ret) {

			error(logopt, MODPREFIX

			      "host address info lookup failed: %s\n",

			      gai_strerror(ret));

			goto next;

		}

		if (!strcmp(host, cni->ai_canonname)) {

			rv = 1;

			break;

		}

next:

		haddr = haddr->ai_next;

	}

	freeaddrinfo(ni);

	freeaddrinfo(cni);

out:

	return rv;

}

static int eval_selector(unsigned int logopt,

			 struct amd_entry *this, struct substvar *sv)

{

	struct selector *s = this->selector;

	const struct substvar *v;

	unsigned int s_type;

	unsigned int v_type;

	struct stat st;

	char *host;

	int res, val, ret = 0;

	s_type = s->sel->flags & SEL_FLAGS_TYPE_MASK;

	switch (s_type) {

	case SEL_FLAG_MACRO:

		v = macro_findvar(sv, s->sel->name, strlen(s->sel->name));

		if (!v) {

			error(logopt, MODPREFIX

			      "failed to get selector %s", s->sel->name);

			return 0;

		}

		v_type = s->sel->flags & SEL_FLAGS_VALUE_MASK;

		switch (v_type) {

		case SEL_FLAG_STR:

			res = strcmp(v->val, s->comp.value);

			if (s->compare & SEL_COMP_EQUAL && !res) {

				debug(logopt, MODPREFIX

				      "matched selector %s(%s) == %s",

				      v->def, v->val, s->comp.value);

				ret = 1;

				break;

			} else if (s->compare & SEL_COMP_NOTEQUAL && res) {

				debug(logopt, MODPREFIX

				      "matched selector %s(%s) != %s",

				      v->def, v->val, s->comp.value);

				ret = 1;

				break;

			}

			debug(logopt, MODPREFIX

				      "did not match selector %s(%s) %s %s",

				      v->def, v->val,

				      (s->compare & SEL_COMP_EQUAL ? "==" : "!="),

				      s->comp.value);

			break;

		case SEL_FLAG_NUM:

			if (!*s->comp.value) {

				res = 1;

				val = 0;

			} else {

				res = atoi(v->val);

				val = atoi(s->comp.value);

			}

			if (s->compare & SEL_COMP_EQUAL && res == val) {

				debug(logopt, MODPREFIX

				      "matched selector %s(%s) equal to %s",

				      v->def, v->val, s->comp.value);

				ret = 1;

				break;

			} else if (s->compare & SEL_COMP_NOTEQUAL && res != val) {

				debug(logopt, MODPREFIX

				      "matched selector %s(%s) not equal to %s",

				      v->def, v->val, s->comp.value);

				ret = 1;

				break;

			}

			debug(logopt, MODPREFIX

				      "did not match selector %s(%s) %s %s",

				      v->def, v->val,

				      (s->compare & SEL_COMP_EQUAL ? "==" : "!="),

				      s->comp.value);

			break;

		default:

			break;

		}

		break;

	case SEL_FLAG_FUNC1:

		if (s->sel->selector != SEL_TRUE &&

		    s->sel->selector != SEL_FALSE &&

		    !s->func.arg1) {

			error(logopt, MODPREFIX

			      "expected argument missing for selector %s",

			      s->sel->name);

			break;

		}

		switch (s->sel->selector) {

		case SEL_TRUE:

			ret = 1;

			if (s->compare == SEL_COMP_NOT)

				ret = !ret;

			if (ret)

				debug(logopt, MODPREFIX

				      "matched selector %s(%s)",

				      s->sel->name, s->func.arg1);

			else

				debug(logopt, MODPREFIX

				      "did not match selector %s(%s)",

				      s->sel->name, s->func.arg1);

			break;

		case SEL_FALSE:

			if (s->compare == SEL_COMP_NOT)

				ret = !ret;

			if (ret)

				debug(logopt, MODPREFIX

				      "matched selector %s(%s)",

				      s->sel->name, s->func.arg1);

			else

				debug(logopt, MODPREFIX

				      "did not match selector %s(%s)",

				      s->sel->name, s->func.arg1);

			break;

		case SEL_XHOST:

			ret = match_my_name(logopt, s->func.arg1, sv);

			if (s->compare == SEL_COMP_NOT)

				ret = !ret;

			if (ret)

				debug(logopt, MODPREFIX

				      "matched selector %s(%s) to host name",

				      s->sel->name, s->func.arg1);

			else

				debug(logopt, MODPREFIX

				      "did not match selector %s(%s) to host name",

				      s->sel->name, s->func.arg1);

			break;

		case SEL_EXISTS:

			/* Sould be OK to fail on any error here */

			ret = !lstat(s->func.arg1, &st);

			if (s->compare == SEL_COMP_NOT)

				ret = !ret;

			if (ret)

				debug(logopt, MODPREFIX

				      "matched selector %s(%s)",

				      s->sel->name, s->func.arg1);

			else

				debug(logopt, MODPREFIX

				      "did not match selector %s(%s)",

				      s->sel->name, s->func.arg1);

			break;

		case SEL_IN_NETWORK:

			ret = in_network(s->func.arg1);

			if (s->compare == SEL_COMP_NOT)

				ret = !ret;

			if (ret)

				debug(logopt, MODPREFIX

				      "matched selector %s(%s)",

				      s->sel->name, s->func.arg1);

			else

				debug(logopt, MODPREFIX

				      "did not match selector %s(%s)",

				      s->sel->name, s->func.arg1);

			break;

		default:

			break;

		}

		break;

	case SEL_FLAG_FUNC2:

		if (!s->func.arg1) {

			error(logopt, MODPREFIX

			      "expected argument missing for selector %s",

			      s->sel->name);

			break;

		}

		switch (s->sel->selector) {

		case SEL_NETGRP:

		case SEL_NETGRPD:

			if (s->func.arg2)

				host = s->func.arg2;

			else {

				if (s->sel->selector == SEL_NETGRP)

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

				else

					v = macro_findvar(sv, "hostd", 5);

				if (!v || !*v->val) {

					error(logopt, MODPREFIX

					     "failed to get value of ${host}");

					break;

				}

				host = v->val;

			}

			ret = innetgr(s->func.arg1, host, NULL, NULL);

			if (s->compare == SEL_COMP_NOT)

				ret = !ret;

			if (ret) {

				if (!s->func.arg2)

					debug(logopt, MODPREFIX

					      "matched selector %s(%s)",

					      s->sel->name, s->func.arg1);

				else

					debug(logopt, MODPREFIX

					      "matched selector %s(%s,%s)",

					      s->sel->name, s->func.arg1,

					      s->func.arg2);

			} else {

				if (!s->func.arg2)

					debug(logopt, MODPREFIX

					      "did not match selector %s(%s)",

					      s->sel->name, s->func.arg1);

				else

					debug(logopt, MODPREFIX

					      "did not match selector %s(%s,%s)",

					      s->sel->name, s->func.arg1, s->func.arg2);

			}

			break;

		default:

			break;

		}

		break;

	default:

		break;

	}

	return ret;

}

static void update_with_defaults(struct amd_entry *defaults,

				 struct amd_entry *entry,

				 struct substvar *sv)

{

	const struct substvar *v;

	unsigned long fstype = entry->flags & AMD_MOUNT_TYPE_MASK;

	char *tmp;

	if (fstype == AMD_MOUNT_TYPE_NONE) {

		unsigned long deftype = defaults->flags & AMD_MOUNT_TYPE_MASK;

		if (deftype != AMD_MOUNT_TYPE_NONE)

			entry->flags |= (defaults->flags & AMD_MOUNT_TYPE_MASK);

		else {

			entry->flags = AMD_MOUNT_TYPE_NFS;

			tmp = strdup("nfs");

			if (tmp)

				entry->type = tmp;

		}

	}

	if (!entry->type && defaults->type) {

		tmp = strdup(defaults->type);

		if (tmp)

			entry->type = tmp;

	}

	if (!entry->map_type && defaults->map_type) {

		tmp = strdup(defaults->map_type);

		if (tmp)

			entry->map_type = tmp;

	}

	if (!entry->pref && defaults->pref) {

		tmp = strdup(defaults->pref);

		if (tmp)

			entry->pref = tmp;

	}

	if (!entry->fs) {

		if (defaults->fs) {

			tmp = strdup(defaults->fs);

			if (tmp)

				entry->fs = tmp;

		} else {

			v = macro_findvar(sv, "fs", 2);

			if (v)

				entry->fs = strdup(v->val);

		}

	}

	if (!entry->rfs) {

		if (defaults->rfs) {

			tmp = strdup(defaults->rfs);

			if (tmp)

				entry->rfs = tmp;

		} else {

			v = macro_findvar(sv, "rfs", 3);

			if (v)

				entry->rfs = strdup(v->val);

		}

	}

	if (!entry->rhost) {

		if (defaults->rhost) {

			tmp = strdup(defaults->rhost);

			if (tmp)

				entry->rhost = tmp;

		} else {

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

			if (v)

				entry->rhost = strdup(v->val);

		}

	}

	if (!entry->dev && defaults->dev) {

		tmp = strdup(defaults->dev);

		if (tmp)

			entry->dev = tmp;

	}

	if (!entry->opts && defaults->opts) {

		tmp = merge_options(defaults->opts, entry->opts);

		if (tmp)

			entry->opts = tmp;

	}

	if (!entry->addopts && defaults->addopts) {

		tmp = merge_options(defaults->addopts, entry->addopts);

		if (tmp)

			entry->addopts = tmp;

	}

	if (!entry->remopts) {

		if (defaults->remopts) {

			tmp = strdup(defaults->remopts);

			if (tmp)

				entry->remopts = tmp;

		} else {

			v = macro_findvar(sv, "remopts", 7);

			if (v)

				entry->remopts = strdup(v->val);

		}

	}

	return;

}

static char *normalize_hostname(unsigned int logopt, const char *host,

				unsigned int flags, struct substvar *sv)

{

	struct addrinfo hints, *ni;

	char *name;

	int ret;

	if (!(flags & CONF_NORMALIZE_HOSTNAMES))

		name = strdup(host);

	else {

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

		hints.ai_flags = AI_CANONNAME;

		hints.ai_family = AF_UNSPEC;

		hints.ai_socktype = SOCK_DGRAM;

		ret = getaddrinfo(host, NULL, &hints, &ni);

		if (ret) {

			error(logopt, MODPREFIX

			      "hostname lookup failed: %s", gai_strerror(ret));

			return NULL;

		}

		name = strdup(ni->ai_canonname);

		freeaddrinfo(ni);

	}

	if (!name)

		return NULL;

	if (flags & CONF_DOMAIN_STRIP) {

		const struct substvar *v = macro_findvar(sv, "hostd", 5);

		if (v) {

			char *d1 = strchr(name, '.');

			if (d1) {

				char *d2 = strchr(v->val, '.');

				if (d2 && !strcmp(d1, d2))

					*d1 = '\0';

			}

		}

	}

	return name;

}

static struct substvar *expand_entry(struct autofs_point *ap,

				     struct amd_entry *entry,

				     unsigned int flags,

				     struct substvar *sv)

{

	unsigned int logopt = ap->logopt;

	char *expand;

	if (entry->rhost && *entry->rhost) {

		char *host = strdup(entry->rhost);

		char *nn;

		if (!host) {

			error(ap->logopt, MODPREFIX

			      "failed to allocate storage for rhost");

			goto next;

		}

		if (expand_selectors(ap, host, &expand, sv)) {

			free(host);

			host = expand;

		}

		nn = normalize_hostname(ap->logopt, host, flags, sv);

		if (!nn)

			sv = macro_addvar(sv, "rhost", 5, host);

		else {

			sv = macro_addvar(sv, "rhost", 5, nn);

			free(host);

			host = nn;

		}

		debug(logopt, MODPREFIX

		      "rhost expand(\"%s\") -> %s", entry->rhost, host);

		free(entry->rhost);

		entry->rhost = host;

	}

next:

	if (entry->sublink) {

		if (expand_selectors(ap, entry->sublink, &expand, sv)) {

			debug(logopt, MODPREFIX

			      "sublink expand(\"%s\") -> %s",

			      entry->sublink, expand);

			free(entry->sublink);

			entry->sublink = expand;

		}

		sv = macro_addvar(sv, "sublink", 7, entry->sublink);

	}

	if (entry->rfs && *entry->rfs) {

		if (expand_selectors(ap, entry->rfs, &expand, sv)) {

			debug(logopt, MODPREFIX

			      "rfs expand(\"%s\") -> %s", entry->rfs, expand);

			free(entry->rfs);

			entry->rfs = expand;

		}

		sv = macro_addvar(sv, "rfs", 3, entry->rfs);

	}

	if (entry->fs && *entry->fs) {

		if (expand_selectors(ap, entry->fs, &expand, sv)) {

			debug(logopt, MODPREFIX

			      "fs expand(\"%s\") -> %s", entry->fs, expand);

			free(entry->fs);

			entry->fs = expand;

		}

		sv = macro_addvar(sv, "fs", 2, entry->fs);

	}

	if (entry->opts && *entry->opts) {

		if (expand_selectors(ap, entry->opts, &expand, sv)) {

			debug(logopt, MODPREFIX

			      "ops expand(\"%s\") -> %s", entry->opts, expand);

			free(entry->opts);

			entry->opts = expand;

		}

		sv = macro_addvar(sv, "opts", 4, entry->opts);

	}

	if (entry->addopts && *entry->addopts) {

		if (expand_selectors(ap, entry->addopts, &expand, sv)) {

			debug(logopt, MODPREFIX

			      "addopts expand(\"%s\") -> %s",

			      entry->addopts, expand);

			free(entry->addopts);

			entry->addopts = expand;

		}

		sv = macro_addvar(sv, "addopts", 7, entry->addopts);

	}

	if (entry->remopts && *entry->remopts) {

		if (expand_selectors(ap, entry->remopts, &expand, sv)) {

			debug(logopt, MODPREFIX

			      "remopts expand(\"%s\") -> %s",

			      entry->remopts, expand);

			free(entry->remopts);

			entry->remopts = expand;

		}

		sv = macro_addvar(sv, "remopts", 7, entry->remopts);

	}

	if (entry->mount) {

		if (!expand_selectors(ap, entry->mount, &expand, sv)) {

			free(entry->mount);

			if (entry->umount)

				free(entry->umount);

			entry->mount = NULL;

			entry->umount = NULL;

			goto done;

		}

		debug(logopt, MODPREFIX

		      "mount expand(\"%s\") -> %s", entry->mount, expand);

		free(entry->mount);

		entry->mount = expand;

		sv = macro_addvar(sv, "mount", 5, entry->mount);

	}

	if (entry->umount) {

		if (!expand_selectors(ap, entry->umount, &expand, sv)) {

			free(entry->umount);

			entry->umount = NULL;

			goto done;

		}

		debug(logopt, MODPREFIX

		      "umount expand(\"%s\") -> %s", entry->umount, expand);

		free(entry->umount);

		entry->umount = expand;

		sv = macro_addvar(sv, "umount", 5, entry->umount);

	}

done:

	return sv;

}

static void expand_merge_options(struct autofs_point *ap,

				 struct amd_entry *entry,

				 struct substvar *sv)

{

	char *tmp;

	if (entry->opts && *entry->opts) {

		if (!expand_selectors(ap, entry->opts, &tmp, sv))

			error(ap->logopt, MODPREFIX "failed to expand opts");

		else {

			free(entry->opts);

			entry->opts = tmp;

		}

	}

	if (entry->addopts && *entry->addopts) {

		if (!expand_selectors(ap, entry->addopts, &tmp, sv))

			error(ap->logopt, MODPREFIX "failed to expand addopts");

		else {

			free(entry->addopts);

			entry->addopts = tmp;

		}

	}

	if (entry->remopts && *entry->remopts) {

		if (!expand_selectors(ap, entry->remopts, &tmp, sv))

			error(ap->logopt, MODPREFIX "failed to expand remopts");

		else {

			free(entry->remopts);

			entry->remopts = tmp;

		}

	}

	return;

}

static struct substvar *merge_entry_options(struct autofs_point *ap,

					    struct amd_entry *entry,

				            struct substvar *sv)

{

	char *tmp;

	if (!entry->addopts)

		return sv;

	if (entry->opts && entry->remopts &&

	    !strcmp(entry->opts, entry->remopts)) {

		expand_merge_options(ap, entry, sv);

		tmp = merge_options(entry->opts, entry->addopts);

		if (tmp) {

			info(ap->logopt, MODPREFIX

			     "merge remopts \"%s\" addopts \"%s\" => \"%s\"",

			      entry->opts, entry->addopts, tmp);

			free(entry->opts);

			entry->opts = tmp;

			sv = macro_addvar(sv, "opts", 4, entry->opts);

		}

		if (*entry->opts) {