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

 *   

 *  parse_subs.c - misc parser subroutines

 *                automounter map

 * 

 *   Copyright 1997 Transmeta Corporation - All Rights Reserved

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

 *   Copyright 2004-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 <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <ifaddrs.h>

#include <libgen.h>

#include <net/if.h>

#include <arpa/inet.h>

#include <netdb.h>

#include "automount.h"

#define MAX_OPTIONS_LEN		256

#define MAX_OPTION_LEN		40

#define MAX_NETWORK_LEN		255

#define MAX_IFC_BUF		2048

static int volatile ifc_buf_len = MAX_IFC_BUF;

static int volatile ifc_last_len = 0;

#define MASK_A  0x7F000000

#define MASK_B  0xBFFF0000

#define MASK_C  0xDFFFFF00

/* Get numeric value of the n bits starting at position p */

#define getbits(x, p, n)	((x >> (p + 1 - n)) & ~(~0 << n))

#define EXPAND_LEADING_SLASH	0x0001

#define EXPAND_TRAILING_SLASH	0x0002

#define EXPAND_LEADING_DOT	0x0004

#define EXPAND_TRAILING_DOT	0x0008

#define SELECTOR_HASH_SIZE	20

static struct sel sel_table[] = {

	{ SEL_ARCH,	  "arch",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_KARCH,	  "karch",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_OS,	  "os",		SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_OSVER,	  "osver",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_FULL_OS,	  "full_os",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_VENDOR,	  "vendor",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_HOST,	  "host",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_HOSTD,	  "hostd",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_XHOST,	  "xhost",	SEL_FLAG_FUNC1|SEL_FLAG_BOOL, NULL },

	{ SEL_DOMAIN,	  "domain",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_BYTE,	  "byte",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_CLUSTER,	  "cluster",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_NETGRP,	  "netgrp",	SEL_FLAG_FUNC2|SEL_FLAG_BOOL, NULL },

	{ SEL_NETGRPD,	  "netgrpd",	SEL_FLAG_FUNC2|SEL_FLAG_BOOL, NULL },

	{ SEL_IN_NETWORK, "in_network",	SEL_FLAG_FUNC1|SEL_FLAG_BOOL, NULL },

	{ SEL_IN_NETWORK, "netnumber",	SEL_FLAG_FUNC1|SEL_FLAG_BOOL, NULL },

	{ SEL_IN_NETWORK, "network",	SEL_FLAG_FUNC1|SEL_FLAG_BOOL, NULL },

	{ SEL_IN_NETWORK, "wire",	SEL_FLAG_FUNC1|SEL_FLAG_BOOL, NULL },

	{ SEL_UID,	  "uid",	SEL_FLAG_MACRO|SEL_FLAG_NUM, NULL },

	{ SEL_GID,	  "gid",	SEL_FLAG_MACRO|SEL_FLAG_NUM, NULL },

	{ SEL_KEY,	  "key",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_MAP,	  "map",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_PATH,	  "path",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_EXISTS,	  "exists",	SEL_FLAG_FUNC1|SEL_FLAG_BOOL, NULL },

	{ SEL_AUTODIR,	  "autodir",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_DOLLAR,	  "dollar",	SEL_FLAG_MACRO|SEL_FLAG_STR, NULL },

	{ SEL_TRUE,	  "true",	SEL_FLAG_FUNC1|SEL_FLAG_BOOL, NULL },

	{ SEL_FALSE,	  "false",	SEL_FLAG_FUNC1|SEL_FLAG_BOOL, NULL },

};

static unsigned int sel_count = sizeof(sel_table)/sizeof(struct sel);

static struct sel *sel_hash[SELECTOR_HASH_SIZE];

static unsigned int sel_hash_init_done = 0;

static pthread_mutex_t sel_hash_mutex = PTHREAD_MUTEX_INITIALIZER;

struct types {

	char *type;

	unsigned int len;

};

static struct types map_type[] = {

	{ "file", 4 },

	{ "program", 7 },

	{ "yp", 2 },

	{ "nis", 3 },

	{ "nisplus", 7 },

	{ "ldap", 4 },

	{ "ldaps", 5 },

	{ "hesiod", 6 },

	{ "userdir", 7 },

	{ "hosts", 5 },

};

static unsigned int map_type_count = sizeof(map_type)/sizeof(struct types);

static struct types format_type[] = {

	{ "sun", 3 },

	{ "hesiod", 6 },

	{ "amd", 3},

};

static unsigned int format_type_count = sizeof(format_type)/sizeof(struct types);

static void sel_add(struct sel *sel)

{

	u_int32_t hval = hash(sel->name, SELECTOR_HASH_SIZE);

	struct sel *old;

	old = sel_hash[hval];

	sel_hash[hval] = sel;

	sel_hash[hval]->next = old;

}

void sel_hash_init(void)

{

	int i;

	pthread_mutex_lock(&sel_hash_mutex);

	if (sel_hash_init_done) {

		pthread_mutex_unlock(&sel_hash_mutex);

		return;

	}

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

		sel_hash[i] = NULL;

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

		sel_add(&sel_table[i]);

	sel_hash_init_done = 1;

	pthread_mutex_unlock(&sel_hash_mutex);

}

struct sel *sel_lookup(const char *name)

{

	u_int32_t hval = hash(name, SELECTOR_HASH_SIZE);

	struct sel *sel;

	pthread_mutex_lock(&sel_hash_mutex);

	for (sel = sel_hash[hval]; sel != NULL; sel = sel->next) {

		if (strcmp(name, sel->name) == 0) {

			pthread_mutex_unlock(&sel_hash_mutex);

			return sel;

		}

	}

	pthread_mutex_unlock(&sel_hash_mutex);

	return NULL;

}

struct selector *get_selector(char *name)

{

	struct sel *sel;

	sel = sel_lookup(name);

	if (sel) {

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

		if (!new)

			return NULL;

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

		new->sel = sel;

		return new;

	}

	return NULL;

}

void free_selector(struct selector *selector)

{

	struct selector *s = selector;

	struct selector *next = s;

	while (s) {

		next = s->next;

		if (s->sel->flags & SEL_FREE_VALUE_MASK)

			free(s->comp.value);

		if (s->sel->flags & SEL_FREE_ARG1_MASK)

			free(s->func.arg1);

		if (s->sel->flags & SEL_FREE_ARG2_MASK)

			free(s->func.arg2);

		s = next;

	}

	free(selector);

	return;

}

static unsigned int ipv6_mask_cmp(uint32_t *host, uint32_t *iface, uint32_t *mask)

{

	unsigned int ret = 1;

	unsigned int i;

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

		if ((host[i] & mask[i]) != (iface[i] & mask[i])) {

			ret = 0;

			break;

		}

	}

	return ret;

}

unsigned int get_proximity(struct sockaddr *host_addr)

{

	struct ifaddrs *ifa = NULL;

	struct ifaddrs *this;

	struct sockaddr_in *addr, *msk_addr, *if_addr;

	struct sockaddr_in6 *addr6, *msk6_addr, *if6_addr;

	struct in_addr *hst_addr;

	struct in6_addr *hst6_addr;

	int addr_len;

	char buf[MAX_ERR_BUF];

	uint32_t mask, ha, ia, *mask6, *ha6, *ia6;

	int ret;

	addr = NULL;

	addr6 = NULL;

	hst_addr = NULL;

	hst6_addr = NULL;

	mask6 = NULL;

	ha6 = NULL;

	ia6 = NULL;

	ha = 0;

	switch (host_addr->sa_family) {

	case AF_INET:

		addr = (struct sockaddr_in *) host_addr;

		hst_addr = (struct in_addr *) &addr->sin_addr;

		ha = ntohl((uint32_t) hst_addr->s_addr);

		addr_len = sizeof(*hst_addr);

		break;

	case AF_INET6:

#ifndef WITH_LIBTIRPC

		return PROXIMITY_UNSUPPORTED;

#else

		addr6 = (struct sockaddr_in6 *) host_addr;

		hst6_addr = (struct in6_addr *) &addr6->sin6_addr;

		ha6 = &hst6_addr->s6_addr32[0];

		addr_len = sizeof(*hst6_addr);

		break;

#endif

	default:

		return PROXIMITY_ERROR;

	}

	ret = getifaddrs(&ifa;;

	if (ret) {

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

		logerr("getifaddrs: %s", estr);

		return PROXIMITY_ERROR;

	}

	this = ifa;

	while (this) {

		if (!(this->ifa_flags & IFF_UP) ||

		    this->ifa_flags & IFF_POINTOPOINT ||

		    this->ifa_addr == NULL) {

			this = this->ifa_next;

			continue;

		}

		switch (this->ifa_addr->sa_family) {

		case AF_INET:

			if (host_addr->sa_family == AF_INET6)

				break;

			if_addr = (struct sockaddr_in *) this->ifa_addr;

			ret = memcmp(&if_addr->sin_addr, hst_addr, addr_len);

			if (!ret) {

				freeifaddrs(ifa);

				return PROXIMITY_LOCAL;

			}

			break;

		case AF_INET6:

#ifdef WITH_LIBTIRPC

			if (host_addr->sa_family == AF_INET)

				break;

			if6_addr = (struct sockaddr_in6 *) this->ifa_addr;

			ret = memcmp(&if6_addr->sin6_addr, hst6_addr, addr_len);

			if (!ret) {

				freeifaddrs(ifa);

				return PROXIMITY_LOCAL;

			}

#endif

		default:

			break;

		}

		this = this->ifa_next;

	}

	this = ifa;

	while (this) {

		if (!(this->ifa_flags & IFF_UP) ||

		    this->ifa_flags & IFF_POINTOPOINT ||

		    this->ifa_addr == NULL) {

			this = this->ifa_next;

			continue;

		}

		switch (this->ifa_addr->sa_family) {

		case AF_INET:

			if (host_addr->sa_family == AF_INET6)

				break;

			if_addr = (struct sockaddr_in *) this->ifa_addr;

			ia =  ntohl((uint32_t) if_addr->sin_addr.s_addr);

			/* Is the address within a localy attached subnet */

			msk_addr = (struct sockaddr_in *) this->ifa_netmask;

			mask = ntohl((uint32_t) msk_addr->sin_addr.s_addr);

			if ((ia & mask) == (ha & mask)) {

				freeifaddrs(ifa);

				return PROXIMITY_SUBNET;

			}

			/*

			 * Is the address within a local ipv4 network.

			 *

			 * Bit position 31 == 0 => class A.

			 * Bit position 30 == 0 => class B.

			 * Bit position 29 == 0 => class C.

			 */

			if (!getbits(ia, 31, 1))

				mask = MASK_A;

			else if (!getbits(ia, 30, 1))

				mask = MASK_B;

			else if (!getbits(ia, 29, 1))

				mask = MASK_C;

			else

				break;

			if ((ia & mask) == (ha & mask)) {

				freeifaddrs(ifa);

				return PROXIMITY_NET;

			}

			break;

		case AF_INET6:

#ifdef WITH_LIBTIRPC

			if (host_addr->sa_family == AF_INET)

				break;

			if6_addr = (struct sockaddr_in6 *) this->ifa_addr;

			ia6 = &if6_addr->sin6_addr.s6_addr32[0];

			/* Is the address within the network of the interface */

			msk6_addr = (struct sockaddr_in6 *) this->ifa_netmask;

			mask6 = &msk6_addr->sin6_addr.s6_addr32[0];

			if (ipv6_mask_cmp(ha6, ia6, mask6)) {

				freeifaddrs(ifa);

				return PROXIMITY_SUBNET;

			}

			/* How do we define "local network" in ipv6? */

#endif

		default:

			break;

		}

		this = this->ifa_next;

	}

	freeifaddrs(ifa);

	return PROXIMITY_OTHER;

}

static char *inet_fill_net(const char *net_num, char *net)

{

	char *np;

	int dots = 3;

	if (strlen(net_num) > INET_ADDRSTRLEN)

		return NULL;

	if (!isdigit(*net_num))

		return NULL;

	*net = '\0';

	strcpy(net, net_num);

	np = net;

	while (*np++) {

		if (*np == '.') {

			np++;

			dots--;

			if (!*np && dots)

				strcat(net, "0");

			continue;

		}

		if ((*np && !isdigit(*np)) || dots < 0) {

			*net = '\0';

			return NULL;

		}

	}

	while (dots--)

		strcat(net, ".0");

	return net;

}

static char *get_network_number(const char *network)

{

	struct netent *netent;

	char cnet[MAX_NETWORK_LEN];

	uint32_t h_net;

	size_t len;

	len = strlen(network) + 1;

	if (len > MAX_NETWORK_LEN)

		return NULL;

	netent = getnetbyname(network);

	if (!netent)

		return NULL;

	h_net = ntohl(netent->n_net);

	if (!inet_ntop(AF_INET, &h_net, cnet, INET_ADDRSTRLEN))

		return NULL;

	return strdup(cnet);

}

unsigned int get_network_proximity(const char *name)

{

	struct addrinfo hints;

	struct addrinfo *ni, *this;

	char name_or_num[NI_MAXHOST + 1];

	unsigned int proximity;

	char *net;

	int ret;

	if (!name)

		return PROXIMITY_ERROR;

	net = get_network_number(name);

	if (net) {

		strcpy(name_or_num, net);

		free(net);

	} else {

		char this[NI_MAXHOST + 1];

		char *mask;

		if (strlen(name) > NI_MAXHOST)

			return PROXIMITY_ERROR;

		strcpy(this, name);

		if ((mask = strchr(this, '/')))

			*mask++ = '\0';

		if (!strchr(this, '.'))

			strcpy(name_or_num, this);

		else {

			char buf[NI_MAXHOST + 1], *new;

			new = inet_fill_net(this, buf);

			if (!new)

				return PROXIMITY_ERROR;

			strcpy(name_or_num, new);

		}

	}

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

	hints.ai_family = AF_UNSPEC;

	hints.ai_socktype = SOCK_DGRAM;

	hints.ai_flags = AI_V4MAPPED | AI_ADDRCONFIG | AI_CANONNAME;

	ni = NULL;

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

	if (ret) {

		logerr("hostname lookup for %s failed: %s",

		       name_or_num, gai_strerror(ret));

		return PROXIMITY_ERROR;

	}

	proximity = PROXIMITY_OTHER;

	this = ni;

	while (this) {

		unsigned int prx = get_proximity(this->ai_addr);

		if (prx < proximity)

			proximity = prx;

		this = this->ai_next;

	}

	freeaddrinfo(ni);

	return proximity;

}

unsigned int in_network(char *network)

{

	unsigned int proximity = get_network_proximity(network);

	if (proximity == PROXIMITY_ERROR ||

	    proximity > PROXIMITY_SUBNET)

		return 0;

	return 1;

}

struct mapent *match_cached_key(struct autofs_point *ap,

				const char *err_prefix,

				struct map_source *source,

				const char *key)

{

	char buf[MAX_ERR_BUF];

	struct mapent_cache *mc;

	struct mapent *me;

	mc = source->mc;

	if (!(source->flags & MAP_FLAG_FORMAT_AMD)) {

		int ret;

		me = cache_lookup(mc, key);

		/*

		 * Stale mapent => check for entry in alternate source or

		 * wildcard. Note, plus included direct mount map entries

		 * are included as an instance (same map entry cache), not

		 * in a distinct source.

		 */

		if (me && (!me->mapent ||

		   (me->source != source && *me->key != '/'))) {

			while ((me = cache_lookup_key_next(me)))

				if (me->source == source)

					break;

			if (!me)

				me = cache_lookup_distinct(mc, "*");

		}

		if (!me)

			goto done;

		/*

		 * If this is a lookup add wildcard match for later validation

		 * checks and negative cache lookups.

		 */

		if (!(ap->flags & MOUNT_FLAG_REMOUNT) &&

		    ap->type == LKP_INDIRECT && *me->key == '*') {

			ret = cache_update(mc, source, key, me->mapent, me->age);

			if (!(ret & (CHE_OK | CHE_UPDATED)))

				me = NULL;

		}

	} else {

		char *lkp_key = strdup(key);

		if (!lkp_key) {

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

			error(ap->logopt, "%s strdup: %s", err_prefix, estr);

			return NULL;

		}

		/* If it's found we're done */

		me = cache_lookup_distinct(mc, lkp_key);

		if (me)

			goto free;

		/*

		 * Otherwise strip successive directory components and try

		 * a match against map entries ending with a wildcard and

		 * finally try the wilcard entry itself.

		*/

		while (!me) {

			char *prefix;

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

				*prefix = '\0';

				me = cache_partial_match_wild(mc, lkp_key);

				if (me)

					goto free;

			}

			me = cache_lookup_distinct(mc, "*");

			if (me)

				goto free;

			break;

		}

free:

		free(lkp_key);

	}

done:

	return me;

}

/*

 * Skip whitespace in a string; if we hit a #, consider the rest of the

 * entry a comment.

 */

const char *skipspace(const char *whence)

{

	while (1) {

		switch (*whence) {

		case ' ':

		case '\b':

		case '\t':

		case '\n':

		case '\v':

		case '\f':

		case '\r':

			whence++;

			break;

		case '#':	/* comment: skip to end of string */

			while (*whence != '\0')

				whence++;

			/* FALLTHROUGH */

		default:

			return whence;

		}

	}

}

/*

 * Check a string to see if a colon appears before the next '/'.

 */

int check_colon(const char *str)

{

	char *ptr = (char *) str;

	/* Colon escape */

	if (!strncmp(ptr, ":/", 2))

		return 1;

	while (*ptr && strncmp(ptr, ":/", 2))

		ptr++;

	if (!*ptr)

		return 0;

	return 1;

}

/* Get the length of a chunk delimitered by whitespace */

int chunklen(const char *whence, int expect_colon)

{

	char *str = (char *) whence;

	int n = 0;

	int quote = 0;

	for (; *str; str++, n++) {

		switch (*str) {

		case '\\':

			if( quote ) {

				break;

			} else {

				quote = 1;

				continue;

			}

		case '"':

			if (quote)

				break;

			while (*str) {

				str++;

				n++;

				if (*str == '"')

					break;

				if (!strncmp(str, ":/", 2))

					expect_colon = 0;

			}

			break;

		case ':':

			if (expect_colon && !strncmp(str, ":/", 2))

				expect_colon = 0;

			continue;

		case ' ':

		case '\t':

			/* Skip space or tab if we expect a colon */

			if (expect_colon)

				continue;

		case '\b':

		case '\n':

		case '\v':

		case '\f':

		case '\r':

		case '\0':

			if (!quote)

				return n;

			/* FALLTHROUGH */

		default:

			break;

		}

		quote = 0;

	}

	return n;

}

/*

 * Compare str with pat.  Return 0 if compare equal or

 * str is an abbreviation of pat of no less than mchr characters.

 */

int strmcmp(const char *str, const char *pat, int mchr)

{

	int nchr = 0;

	while (*str == *pat) {

		if (!*str)

			return 0;

		str++;

		pat++;

		nchr++;

	}

	if (!*str && nchr > mchr)

		return 0;

	return *pat - *str;

}

char *dequote(const char *str, int origlen, unsigned int logopt)

{

	char *ret = malloc(origlen + 1);

	char *cp = ret;

	const char *scp;

	int len = origlen;

	int quote = 0, dquote = 0;

	int i, j;

	if (ret == NULL)

		return NULL;

	/* first thing to do is strip white space from the end */

	i = len - 1;

	while (isspace(str[i])) {

		/* of course, we have to keep escaped white-space */

		j = i - 1;

		if (j > 0 && (str[j] == '\\' || str[j] == '"'))

			break;

		i--;

		len--;

	}

	for (scp = str; len > 0 && *scp; scp++, len--) {

		if (!quote) {

			if (*scp == '"') {

				if (dquote)

					dquote = 0;

				else

					dquote = 1;

				continue;

			}

			if (!dquote) {

				if (*scp == '\\') {

					quote = 1;

					continue;

				}

			}

		}

		quote = 0;

		*cp++ = *scp;

	}

	*cp = '\0';

	if (dquote) {

		debug(logopt, "unmatched quote in %.*s", origlen, str);

		free(ret);

		return NULL;

	}

	return ret;

}

int span_space(const char *str, unsigned int maxlen)

{

	const char *p = str;

	unsigned int len = 0;

	while (*p && !isblank(*p) && len < maxlen) {

		if (*p == '"') {

			while (*p++ && len++ < maxlen) {

				if (*p == '"')

					break;

			}

		} else if (*p == '\\') {

			p += 2;

			len += 2;

			continue;

		}

		p++;

		len++;

	}

	return len;

}

char *sanitize_path(const char *path, int origlen, unsigned int type, unsigned int logopt)

{

	char *slash, *cp, *s_path;

	const char *scp;

	int len = origlen;

	unsigned int seen_slash = 0, quote = 0, dquote = 0;

	if (type & (LKP_INDIRECT | LKP_DIRECT)) {

		const char *tmp = path;

		if (*tmp == '"')

			tmp++;

		slash = strchr(tmp, '/');

		if (slash) {

			if (type == LKP_INDIRECT)

				return NULL;

			if (*tmp != '/')

				return NULL;

		} else {

			if (type == LKP_DIRECT)

				return NULL;

		}

	}

	s_path = malloc(origlen + 1);

	if (!s_path)

		return NULL;

	for (cp = s_path, scp = path; len > 0; scp++, len--) {

		if (!quote) {

			if (*scp == '"') {

				if (dquote)

					dquote = 0;

				else

					dquote = 1;

				continue;

			}

			if (!dquote) {

				/* Badness in string - go away */

				if (*scp < 32) {

					free(s_path);

					return NULL;

				}

				if (*scp == '\\') {

					quote = 1;

					continue;

				} 

			}

			/*

			 * Not really proper but we get problems with

			 * paths with multiple slashes. The kernel

			 * compresses them so when we get a query there

			 * should be only single slashes.

			 */

			if (*scp == '/') {

				if (seen_slash)

					continue;

				seen_slash = 1;

			} else

				seen_slash = 0;

		}

		quote = 0;

		*cp++ = *scp;

	}

	*cp = '\0';

	if (dquote) {

		debug(logopt, "unmatched quote in %.*s", origlen, path);

		free(s_path);

		return NULL;

	}

	/* Remove trailing / but watch out for a quoted / alone */

	if (strlen(cp) > 1 && origlen > 1 && *(cp - 1) == '/')

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

	return s_path;

}

static char *hasopt(const char *str, const char *opt)

{

	const size_t optlen = strlen(opt);

	char *rest = (char *) str, *p;