/*

 *	Argument parser

 *	Copyright © Jan Engelhardt, 2011

 *

 *	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; either version 2 of

 *	the License, or (at your option) any later version.

 */

#include <ctype.h>

#include <errno.h>

#include <getopt.h>

#include <limits.h>

#include <netdb.h>

#include <stdbool.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <syslog.h>

#include <arpa/inet.h>

#include <netinet/ip.h>

#include "xtables.h"

#include "xshared.h"

#ifndef IPTOS_NORMALSVC

#	define IPTOS_NORMALSVC 0

#endif

#define XTOPT_MKPTR(cb) \

	((void *)((char *)(cb)->data + (cb)->entry->ptroff))

/**

 * Simple key-value pairs for syslog levels

 */

struct syslog_level {

	char name[8];

	uint8_t level;

};

struct tos_value_mask {

	uint8_t value, mask;

};

static const size_t xtopt_psize[] = {

	/*

	 * All types not listed here, and thus essentially being initialized to

	 * zero have zero on purpose.

	 */

	[XTTYPE_UINT8]       = sizeof(uint8_t),

	[XTTYPE_UINT16]      = sizeof(uint16_t),

	[XTTYPE_UINT32]      = sizeof(uint32_t),

	[XTTYPE_UINT64]      = sizeof(uint64_t),

	[XTTYPE_UINT8RC]     = sizeof(uint8_t[2]),

	[XTTYPE_UINT16RC]    = sizeof(uint16_t[2]),

	[XTTYPE_UINT32RC]    = sizeof(uint32_t[2]),

	[XTTYPE_UINT64RC]    = sizeof(uint64_t[2]),

	[XTTYPE_DOUBLE]      = sizeof(double),

	[XTTYPE_STRING]      = -1,

	[XTTYPE_SYSLOGLEVEL] = sizeof(uint8_t),

	[XTTYPE_HOST]        = sizeof(union nf_inet_addr),

	[XTTYPE_HOSTMASK]    = sizeof(union nf_inet_addr),

	[XTTYPE_PROTOCOL]    = sizeof(uint8_t),

	[XTTYPE_PORT]        = sizeof(uint16_t),

	[XTTYPE_PORTRC]      = sizeof(uint16_t[2]),

	[XTTYPE_PLENMASK]    = sizeof(union nf_inet_addr),

	[XTTYPE_ETHERMAC]    = sizeof(uint8_t[6]),

};

/**

 * Creates getopt options from the x6-style option map, and assigns each a

 * getopt id.

 */

struct option *

xtables_options_xfrm(struct option *orig_opts, struct option *oldopts,

		     const struct xt_option_entry *entry, unsigned int *offset)

{

	unsigned int num_orig, num_old = 0, num_new, i;

	struct option *merge, *mp;

	if (entry == NULL)

		return oldopts;

	for (num_orig = 0; orig_opts[num_orig].name != NULL; ++num_orig)

		;

	if (oldopts != NULL)

		for (num_old = 0; oldopts[num_old].name != NULL; ++num_old)

			;

	for (num_new = 0; entry[num_new].name != NULL; ++num_new)

		;

	/*

	 * Since @oldopts also has @orig_opts already (and does so at the

	 * start), skip these entries.

	 */

	if (oldopts != NULL) {

		oldopts += num_orig;

		num_old -= num_orig;

	}

	merge = malloc(sizeof(*mp) * (num_orig + num_old + num_new + 1));

	if (merge == NULL)

		return NULL;

	/* Let the base options -[ADI...] have precedence over everything */

	memcpy(merge, orig_opts, sizeof(*mp) * num_orig);

	mp = merge + num_orig;

	/* Second, the new options */

	xt_params->option_offset += XT_OPTION_OFFSET_SCALE;

	*offset = xt_params->option_offset;

	for (i = 0; i < num_new; ++i, ++mp, ++entry) {

		mp->name         = entry->name;

		mp->has_arg      = entry->type != XTTYPE_NONE;

		mp->flag         = NULL;

		mp->val          = entry->id + *offset;

	}

	/* Third, the old options */

	if (oldopts != NULL) {

		memcpy(mp, oldopts, sizeof(*mp) * num_old);

		mp += num_old;

	}

	xtables_free_opts(0);

	/* Clear trailing entry */

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

	return merge;

}

/**

 * Give the upper limit for a certain type.

 */

static uintmax_t xtopt_max_by_type(enum xt_option_type type)

{

	switch (type) {

	case XTTYPE_UINT8:

	case XTTYPE_UINT8RC:

		return UINT8_MAX;

	case XTTYPE_UINT16:

	case XTTYPE_UINT16RC:

		return UINT16_MAX;

	case XTTYPE_UINT32:

	case XTTYPE_UINT32RC:

		return UINT32_MAX;

	case XTTYPE_UINT64:

	case XTTYPE_UINT64RC:

		return UINT64_MAX;

	default:

		return 0;

	}

}

/**

 * Return the size of a single entity based upon a type - predominantly an

 * XTTYPE_UINT*RC type.

 */

static size_t xtopt_esize_by_type(enum xt_option_type type)

{

	switch (type) {

	case XTTYPE_UINT8RC:

		return xtopt_psize[XTTYPE_UINT8];

	case XTTYPE_UINT16RC:

		return xtopt_psize[XTTYPE_UINT16];

	case XTTYPE_UINT32RC:

		return xtopt_psize[XTTYPE_UINT32];

	case XTTYPE_UINT64RC:

		return xtopt_psize[XTTYPE_UINT64];

	default:

		return xtopt_psize[type];

	}

}

/**

 * Require a simple integer.

 */

static void xtopt_parse_int(struct xt_option_call *cb)

{

	const struct xt_option_entry *entry = cb->entry;

	uintmax_t lmin = 0, lmax = xtopt_max_by_type(entry->type);

	uintmax_t value;

	if (cb->entry->min != 0)

		lmin = cb->entry->min;

	if (cb->entry->max != 0)

		lmax = cb->entry->max;

	if (!xtables_strtoul(cb->arg, NULL, &value, lmin, lmax))

		xt_params->exit_err(PARAMETER_PROBLEM,

			"%s: bad value for option \"--%s\", "

			"or out of range (%ju-%ju).\n",

			cb->ext_name, entry->name, lmin, lmax);

	if (entry->type == XTTYPE_UINT8) {

		cb->val.u8 = value;

		if (entry->flags & XTOPT_PUT)

			*(uint8_t *)XTOPT_MKPTR(cb) = cb->val.u8;

	} else if (entry->type == XTTYPE_UINT16) {

		cb->val.u16 = value;

		if (entry->flags & XTOPT_PUT)

			*(uint16_t *)XTOPT_MKPTR(cb) = cb->val.u16;

	} else if (entry->type == XTTYPE_UINT32) {

		cb->val.u32 = value;

		if (entry->flags & XTOPT_PUT)

			*(uint32_t *)XTOPT_MKPTR(cb) = cb->val.u32;

	} else if (entry->type == XTTYPE_UINT64) {

		cb->val.u64 = value;

		if (entry->flags & XTOPT_PUT)

			*(uint64_t *)XTOPT_MKPTR(cb) = cb->val.u64;

	}

}

/**

 * Require a simple floating point number.

 */

static void xtopt_parse_float(struct xt_option_call *cb)

{

	const struct xt_option_entry *entry = cb->entry;

	double value;

	char *end;

	value = strtod(cb->arg, &end;;

	if (end == cb->arg || *end != '\0' ||

	    (entry->min != entry->max &&

	    (value < entry->min || value > entry->max)))

		xt_params->exit_err(PARAMETER_PROBLEM,

			"%s: bad value for option \"--%s\", "

			"or out of range (%u-%u).\n",

			cb->ext_name, entry->name, entry->min, entry->max);

	cb->val.dbl = value;

	if (entry->flags & XTOPT_PUT)

		*(double *)XTOPT_MKPTR(cb) = cb->val.dbl;

}

/**

 * Copy the parsed value to the appropriate entry in cb->val.

 */

static void xtopt_mint_value_to_cb(struct xt_option_call *cb, uintmax_t value)

{

	const struct xt_option_entry *entry = cb->entry;

	if (cb->nvals >= ARRAY_SIZE(cb->val.u32_range))

		return;

	if (entry->type == XTTYPE_UINT8RC)

		cb->val.u8_range[cb->nvals] = value;

	else if (entry->type == XTTYPE_UINT16RC)

		cb->val.u16_range[cb->nvals] = value;

	else if (entry->type == XTTYPE_UINT32RC)

		cb->val.u32_range[cb->nvals] = value;

	else if (entry->type == XTTYPE_UINT64RC)

		cb->val.u64_range[cb->nvals] = value;

}

/**

 * Copy the parsed value to the data area, using appropriate type access.

 */

static void xtopt_mint_value_to_ptr(struct xt_option_call *cb, void **datap,

				    uintmax_t value)

{

	const struct xt_option_entry *entry = cb->entry;

	void *data = *datap;

	if (!(entry->flags & XTOPT_PUT))

		return;

	if (entry->type == XTTYPE_UINT8RC)

		*(uint8_t *)data = value;

	else if (entry->type == XTTYPE_UINT16RC)

		*(uint16_t *)data = value;

	else if (entry->type == XTTYPE_UINT32RC)

		*(uint32_t *)data = value;

	else if (entry->type == XTTYPE_UINT64RC)

		*(uint64_t *)data = value;

	data += xtopt_esize_by_type(entry->type);

	*datap = data;

}

/**

 * Multiple integer parse routine.

 *

 * This function is capable of parsing any number of fields. Only the first

 * two values from the string will be put into @cb however (and as such,

 * @cb->val.uXX_range is just that large) to cater for the few extensions that

 * do not have a range[2] field, but {min, max}, and which cannot use

 * XTOPT_POINTER.

 */

static void xtopt_parse_mint(struct xt_option_call *cb)

{

	const struct xt_option_entry *entry = cb->entry;

	const char *arg;

	size_t esize = xtopt_esize_by_type(entry->type);

	const uintmax_t lmax = xtopt_max_by_type(entry->type);

	void *put = XTOPT_MKPTR(cb);

	unsigned int maxiter;

	uintmax_t value;

	char *end = "";

	char sep = ':';

	maxiter = entry->size / esize;

	if (maxiter == 0)

		maxiter = ARRAY_SIZE(cb->val.u32_range);

	if (entry->size % esize != 0)

		xt_params->exit_err(OTHER_PROBLEM, "%s: memory block does "

			"not have proper size\n", __func__);

	cb->nvals = 0;

	for (arg = cb->arg, end = (char *)arg; ; arg = end + 1) {

		if (cb->nvals == maxiter)

			xt_params->exit_err(PARAMETER_PROBLEM, "%s: Too many "

				"components for option \"--%s\" (max: %u)\n",

				cb->ext_name, entry->name, maxiter);

		if (*arg == '\0' || *arg == sep) {

			/* Default range components when field not spec'd. */

			end = (char *)arg;

			value = (cb->nvals == 1) ? lmax : 0;

		} else {

			if (!xtables_strtoul(arg, &end, &value, 0, lmax))

				xt_params->exit_err(PARAMETER_PROBLEM,

					"%s: bad value for option \"--%s\" near "

					"\"%s\", or out of range (0-%ju).\n",

					cb->ext_name, entry->name, arg, lmax);

			if (*end != '\0' && *end != sep)

				xt_params->exit_err(PARAMETER_PROBLEM,

					"%s: Argument to \"--%s\" has "

					"unexpected characters near \"%s\".\n",

					cb->ext_name, entry->name, end);

		}

		xtopt_mint_value_to_cb(cb, value);

		++cb->nvals;

		xtopt_mint_value_to_ptr(cb, &put, value);

		if (*end == '\0')

			break;

	}

}

static void xtopt_parse_string(struct xt_option_call *cb)

{

	const struct xt_option_entry *entry = cb->entry;

	size_t z = strlen(cb->arg);

	char *p;

	if (entry->min != 0 && z < entry->min)

		xt_params->exit_err(PARAMETER_PROBLEM,

			"Argument must have a minimum length of "

			"%u characters\n", entry->min);

	if (entry->max != 0 && z > entry->max)

		xt_params->exit_err(PARAMETER_PROBLEM,

			"Argument must have a maximum length of "

			"%u characters\n", entry->max);

	if (!(entry->flags & XTOPT_PUT))

		return;

	if (z >= entry->size)

		z = entry->size - 1;

	p = XTOPT_MKPTR(cb);

	strncpy(p, cb->arg, z);

	p[z] = '\0';

}

static const struct tos_symbol_info {

	unsigned char value;

	const char *name;

} tos_symbol_names[] = {

	{IPTOS_LOWDELAY,    "Minimize-Delay"},

	{IPTOS_THROUGHPUT,  "Maximize-Throughput"},

	{IPTOS_RELIABILITY, "Maximize-Reliability"},

	{IPTOS_MINCOST,     "Minimize-Cost"},

	{IPTOS_NORMALSVC,   "Normal-Service"},

	{},

};

/*

 * tos_parse_numeric - parse a string like "15/255"

 *

 * @str:	input string

 * @tvm:	(value/mask) tuple

 * @max:	maximum allowed value (must be pow(2,some_int)-1)

 */

static bool tos_parse_numeric(const char *str, struct xt_option_call *cb,

                              unsigned int max)

{

	unsigned int value;

	char *end;

	xtables_strtoui(str, &end, &value, 0, max);

	cb->val.tos_value = value;

	cb->val.tos_mask  = max;

	if (*end == '/') {

		const char *p = end + 1;

		if (!xtables_strtoui(p, &end, &value, 0, max))

			xtables_error(PARAMETER_PROBLEM, "Illegal value: \"%s\"",

			           str);

		cb->val.tos_mask = value;

	}

	if (*end != '\0')

		xtables_error(PARAMETER_PROBLEM, "Illegal value: \"%s\"", str);

	return true;

}

/**

 * @str:	input string

 * @tvm:	(value/mask) tuple

 * @def_mask:	mask to force when a symbolic name is used

 */

static void xtopt_parse_tosmask(struct xt_option_call *cb)

{

	const struct tos_symbol_info *symbol;

	char *tmp;

	if (xtables_strtoui(cb->arg, &tmp, NULL, 0, UINT8_MAX)) {

		tos_parse_numeric(cb->arg, cb, UINT8_MAX);

		return;

	}

	/*

	 * This is our way we deal with different defaults

	 * for different revisions.

	 */

	cb->val.tos_mask = cb->entry->max;

	for (symbol = tos_symbol_names; symbol->name != NULL; ++symbol)

		if (strcasecmp(cb->arg, symbol->name) == 0) {

			cb->val.tos_value = symbol->value;

			return;

		}

	xtables_error(PARAMETER_PROBLEM, "Symbolic name \"%s\" is unknown",

		      cb->arg);

}

/**

 * Validate the input for being conformant to "mark[/mask]".

 */

static void xtopt_parse_markmask(struct xt_option_call *cb)

{

	xtables_parse_mark_mask(cb, &cb->val.mark, &cb->val.mask);

}

static int xtopt_sysloglvl_compare(const void *a, const void *b)

{

	const char *name = a;

	const struct syslog_level *entry = b;

	return strcmp(name, entry->name);

}

static void xtopt_parse_sysloglevel(struct xt_option_call *cb)

{

	static const struct syslog_level log_names[] = { /* must be sorted */

		{"alert",   LOG_ALERT},

		{"crit",    LOG_CRIT},

		{"debug",   LOG_DEBUG},

		{"emerg",   LOG_EMERG},

		{"error",   LOG_ERR}, /* deprecated */

		{"info",    LOG_INFO},

		{"notice",  LOG_NOTICE},

		{"panic",   LOG_EMERG}, /* deprecated */

		{"warning", LOG_WARNING},

	};

	const struct syslog_level *e;

	unsigned int num = 0;

	if (!xtables_strtoui(cb->arg, NULL, &num, 0, 7)) {

		e = bsearch(cb->arg, log_names, ARRAY_SIZE(log_names),

			    sizeof(*log_names), xtopt_sysloglvl_compare);

		if (e == NULL)

			xt_params->exit_err(PARAMETER_PROBLEM,

				"log level \"%s\" unknown\n", cb->arg);

		num = e->level;

	}

	cb->val.syslog_level = num;

	if (cb->entry->flags & XTOPT_PUT)

		*(uint8_t *)XTOPT_MKPTR(cb) = num;

}

static void *xtables_sa_host(const void *sa, unsigned int afproto)

{

	if (afproto == AF_INET6)

		return &((struct sockaddr_in6 *)sa)->sin6_addr;

	else if (afproto == AF_INET)

		return &((struct sockaddr_in *)sa)->sin_addr;

	return (void *)sa;

}

static socklen_t xtables_sa_hostlen(unsigned int afproto)

{

	if (afproto == AF_INET6)

		return sizeof(struct in6_addr);

	else if (afproto == AF_INET)

		return sizeof(struct in_addr);

	return 0;

}

/**

 * Accepts: a hostname (DNS), or a single inetaddr - without any mask. The

 * result is stored in @cb->val.haddr. Additionally, @cb->val.hmask and

 * @cb->val.hlen are set for completeness to the appropriate values.

 */

static void xtopt_parse_host(struct xt_option_call *cb)

{

	struct addrinfo hints = {.ai_family = afinfo->family};

	unsigned int adcount = 0;

	struct addrinfo *res, *p;

	int ret;

	ret = getaddrinfo(cb->arg, NULL, &hints, &res;;

	if (ret != 0)

		xt_params->exit_err(PARAMETER_PROBLEM,

			"getaddrinfo: %s\n", gai_strerror(ret));

	memset(&cb->val.hmask, 0xFF, sizeof(cb->val.hmask));

	cb->val.hlen = (afinfo->family == NFPROTO_IPV4) ? 32 : 128;

	for (p = res; p != NULL; p = p->ai_next) {

		if (adcount == 0) {

			memset(&cb->val.haddr, 0, sizeof(cb->val.haddr));

			memcpy(&cb->val.haddr,

			       xtables_sa_host(p->ai_addr, p->ai_family),

			       xtables_sa_hostlen(p->ai_family));

			++adcount;

			continue;

		}

		if (memcmp(&cb->val.haddr,

		    xtables_sa_host(p->ai_addr, p->ai_family),

		    xtables_sa_hostlen(p->ai_family)) != 0)

			xt_params->exit_err(PARAMETER_PROBLEM,

				"%s resolves to more than one address\n",

				cb->arg);

	}

	freeaddrinfo(res);

	if (cb->entry->flags & XTOPT_PUT)

		/* Validation in xtables_option_metavalidate */

		memcpy(XTOPT_MKPTR(cb), &cb->val.haddr,

		       sizeof(cb->val.haddr));

}

/**

 * @name:	port name, or number as a string (e.g. "http" or "80")

 *

 * Resolve a port name to a number. Returns the port number in integral

 * form on success, or <0 on error. (errno will not be set.)

 */

static int xtables_getportbyname(const char *name)

{

	struct addrinfo *res = NULL, *p;

	int ret;

	ret = getaddrinfo(NULL, name, NULL, &res;;

	if (ret != 0)

		return -1;

	ret = -1;

	for (p = res; p != NULL; p = p->ai_next) {

		if (p->ai_family == AF_INET6) {

			ret = ((struct sockaddr_in6 *)p->ai_addr)->sin6_port;

			break;

		} else if (p->ai_family == AF_INET) {

			ret = ((struct sockaddr_in *)p->ai_addr)->sin_port;

			break;

		}

	}

	freeaddrinfo(res);

	if (ret < 0)

		return ret;

	return ntohs(ret);

}

/**

 * Validate and parse a protocol specification (number or name) by use of

 * /etc/protocols and put the result into @cb->val.protocol.

 */

static void xtopt_parse_protocol(struct xt_option_call *cb)

{

	cb->val.protocol = xtables_parse_protocol(cb->arg);

	if (cb->entry->flags & XTOPT_PUT)

		*(uint8_t *)XTOPT_MKPTR(cb) = cb->val.protocol;

}

/**

 * Validate and parse a port specification and put the result into

 * @cb->val.port.

 */

static void xtopt_parse_port(struct xt_option_call *cb)

{

	const struct xt_option_entry *entry = cb->entry;

	int ret;

	ret = xtables_getportbyname(cb->arg);

	if (ret < 0)

		xt_params->exit_err(PARAMETER_PROBLEM,

			"Port \"%s\" does not resolve to anything.\n",

			cb->arg);

	if (entry->flags & XTOPT_NBO)

		ret = htons(ret);

	cb->val.port = ret;

	if (entry->flags & XTOPT_PUT)

		*(uint16_t *)XTOPT_MKPTR(cb) = cb->val.port;

}

static void xtopt_parse_mport(struct xt_option_call *cb)

{

	static const size_t esize = sizeof(uint16_t);

	const struct xt_option_entry *entry = cb->entry;

	char *lo_arg, *wp_arg, *arg;

	unsigned int maxiter;

	int value;

	wp_arg = lo_arg = strdup(cb->arg);

	if (lo_arg == NULL)

		xt_params->exit_err(RESOURCE_PROBLEM, "strdup");

	maxiter = entry->size / esize;

	if (maxiter == 0)

		maxiter = 2; /* ARRAY_SIZE(cb->val.port_range) */

	if (entry->size % esize != 0)

		xt_params->exit_err(OTHER_PROBLEM, "%s: memory block does "

			"not have proper size\n", __func__);

	cb->val.port_range[0] = 0;

	cb->val.port_range[1] = UINT16_MAX;

	cb->nvals = 0;

	while ((arg = strsep(&wp_arg, ":")) != NULL) {

		if (cb->nvals == maxiter)

			xt_params->exit_err(PARAMETER_PROBLEM, "%s: Too many "

				"components for option \"--%s\" (max: %u)\n",

				cb->ext_name, entry->name, maxiter);

		if (*arg == '\0') {

			++cb->nvals;

			continue;

		}

		value = xtables_getportbyname(arg);

		if (value < 0)

			xt_params->exit_err(PARAMETER_PROBLEM,

				"Port \"%s\" does not resolve to "

				"anything.\n", arg);

		if (entry->flags & XTOPT_NBO)

			value = htons(value);

		if (cb->nvals < ARRAY_SIZE(cb->val.port_range))

			cb->val.port_range[cb->nvals] = value;

		++cb->nvals;

	}

	if (cb->nvals == 1) {

		cb->val.port_range[1] = cb->val.port_range[0];

		++cb->nvals;

	}

	if (entry->flags & XTOPT_PUT)

		memcpy(XTOPT_MKPTR(cb), cb->val.port_range, sizeof(uint16_t) *

		       (cb->nvals <= maxiter ? cb->nvals : maxiter));

	free(lo_arg);

}

static int xtopt_parse_mask(struct xt_option_call *cb)

{

	struct addrinfo hints = {.ai_family = afinfo->family,

				 .ai_flags = AI_NUMERICHOST };

	struct addrinfo *res;

	int ret;

	ret = getaddrinfo(cb->arg, NULL, &hints, &res;;

	if (ret != 0)

		return 0;

	memcpy(&cb->val.hmask, xtables_sa_host(res->ai_addr, res->ai_family),

	       xtables_sa_hostlen(res->ai_family));

	switch(afinfo->family) {

	case AF_INET:

		cb->val.hlen = xtables_ipmask_to_cidr(&cb->val.hmask.in);

		break;

	case AF_INET6:

		cb->val.hlen = xtables_ip6mask_to_cidr(&cb->val.hmask.in6);

		break;

	}

	freeaddrinfo(res);

	return 1;

}

/**

 * Parse an integer and ensure it is within the address family's prefix length

 * limits. The result is stored in @cb->val.hlen.

 */

static void xtopt_parse_plen(struct xt_option_call *cb)

{

	const struct xt_option_entry *entry = cb->entry;

	unsigned int prefix_len = 128; /* happiness is a warm gcc */

	cb->val.hlen = (afinfo->family == NFPROTO_IPV4) ? 32 : 128;

	if (!xtables_strtoui(cb->arg, NULL, &prefix_len, 0, cb->val.hlen)) {

		/* Is this mask expressed in full format? e.g. 255.255.255.0 */

		if (xtopt_parse_mask(cb))

			return;

		xt_params->exit_err(PARAMETER_PROBLEM,

			"%s: bad value for option \"--%s\", "

			"neither a valid network mask "

			"nor valid CIDR (%u-%u).\n",

			cb->ext_name, entry->name, 0, cb->val.hlen);

	}

	cb->val.hlen = prefix_len;

}

/**

 * Reuse xtopt_parse_plen for testing the integer. Afterwards convert this to

 * a bitmask, and make it available through @cb->val.hmask (hlen remains

 * valid). If %XTOPT_PUT is used, hmask will be copied to the target area.

 */

static void xtopt_parse_plenmask(struct xt_option_call *cb)

{

	const struct xt_option_entry *entry = cb->entry;

	uint32_t *mask = cb->val.hmask.all;

	xtopt_parse_plen(cb);

	memset(mask, 0xFF, sizeof(union nf_inet_addr));

	/* This shifting is AF-independent. */

	if (cb->val.hlen == 0) {

		mask[0] = mask[1] = mask[2] = mask[3] = 0;

	} else if (cb->val.hlen <= 32) {

		mask[0] <<= 32 - cb->val.hlen;

		mask[1] = mask[2] = mask[3] = 0;

	} else if (cb->val.hlen <= 64) {

		mask[1] <<= 32 - (cb->val.hlen - 32);

		mask[2] = mask[3] = 0;

	} else if (cb->val.hlen <= 96) {

		mask[2] <<= 32 - (cb->val.hlen - 64);

		mask[3] = 0;

	} else if (cb->val.hlen <= 128) {

		mask[3] <<= 32 - (cb->val.hlen - 96);

	}

	mask[0] = htonl(mask[0]);

	mask[1] = htonl(mask[1]);

	mask[2] = htonl(mask[2]);

	mask[3] = htonl(mask[3]);

	if (entry->flags & XTOPT_PUT)

		memcpy(XTOPT_MKPTR(cb), mask, sizeof(union nf_inet_addr));

}

static void xtopt_parse_hostmask(struct xt_option_call *cb)

{

	const char *orig_arg = cb->arg;

	char *work, *p;

	if (strchr(cb->arg, '/') == NULL) {

		xtopt_parse_host(cb);

		return;

	}

	work = strdup(orig_arg);

	if (work == NULL)

		xt_params->exit_err(PARAMETER_PROBLEM, "strdup");

	p = strchr(work, '/'); /* by def this can't be NULL now */

	*p++ = '\0';

	/*

	 * Because xtopt_parse_host and xtopt_parse_plenmask would store

	 * different things in the same target area, XTTYPE_HOSTMASK must

	 * disallow XTOPT_PUT, which it does by forcing its absence,

	 * cf. not being listed in xtopt_psize.

	 */

	cb->arg = work;

	xtopt_parse_host(cb);

	cb->arg = p;

	xtopt_parse_plenmask(cb);

	cb->arg = orig_arg;

}

static void xtopt_parse_ethermac(struct xt_option_call *cb)

{

	const char *arg = cb->arg;

	unsigned int i;

	char *end;

	for (i = 0; i < ARRAY_SIZE(cb->val.ethermac) - 1; ++i) {

		cb->val.ethermac[i] = strtoul(arg, &end, 16);

		if (*end != ':' || end - arg > 2)

			goto out;

		arg = end + 1;

	}

	i = ARRAY_SIZE(cb->val.ethermac) - 1;

	cb->val.ethermac[i] = strtoul(arg, &end, 16);

	if (*end != '\0' || end - arg > 2)

		goto out;

	if (cb->entry->flags & XTOPT_PUT)

		memcpy(XTOPT_MKPTR(cb), cb->val.ethermac,

		       sizeof(cb->val.ethermac));

	return;

 out:

	xt_params->exit_err(PARAMETER_PROBLEM, "Invalid MAC address specified.");

}

static void (*const xtopt_subparse[])(struct xt_option_call *) = {

	[XTTYPE_UINT8]       = xtopt_parse_int,

	[XTTYPE_UINT16]      = xtopt_parse_int,

	[XTTYPE_UINT32]      = xtopt_parse_int,

	[XTTYPE_UINT64]      = xtopt_parse_int,

	[XTTYPE_UINT8RC]     = xtopt_parse_mint,

	[XTTYPE_UINT16RC]    = xtopt_parse_mint,

	[XTTYPE_UINT32RC]    = xtopt_parse_mint,

	[XTTYPE_UINT64RC]    = xtopt_parse_mint,

	[XTTYPE_DOUBLE]      = xtopt_parse_float,

	[XTTYPE_STRING]      = xtopt_parse_string,

	[XTTYPE_TOSMASK]     = xtopt_parse_tosmask,

	[XTTYPE_MARKMASK32]  = xtopt_parse_markmask,

	[XTTYPE_SYSLOGLEVEL] = xtopt_parse_sysloglevel,

	[XTTYPE_HOST]        = xtopt_parse_host,

	[XTTYPE_HOSTMASK]    = xtopt_parse_hostmask,

	[XTTYPE_PROTOCOL]    = xtopt_parse_protocol,

	[XTTYPE_PORT]        = xtopt_parse_port,

	[XTTYPE_PORTRC]      = xtopt_parse_mport,

	[XTTYPE_PLEN]        = xtopt_parse_plen,

	[XTTYPE_PLENMASK]    = xtopt_parse_plenmask,

	[XTTYPE_ETHERMAC]    = xtopt_parse_ethermac,

};

/**

 * The master option parsing routine. May be used for the ".x6_parse"

 * function pointer in extensions if fully automatic parsing is desired.

 * It may be also called manually from a custom x6_parse function.

 */

void xtables_option_parse(struct xt_option_call *cb)

{

	const struct xt_option_entry *entry = cb->entry;

	unsigned int eflag = 1 << cb->entry->id;

	/*

	 * With {.id = P_FOO, .excl = P_FOO} we can have simple double-use

	 * prevention. Though it turned out that this is too much typing (most

	 * of the options are one-time use only), so now we also have

	 * %XTOPT_MULTI.

	 */

	if ((!(entry->flags & XTOPT_MULTI) || (entry->excl & eflag)) &&

	    cb->xflags & eflag)

		xt_params->exit_err(PARAMETER_PROBLEM,

			"%s: option \"--%s\" can only be used once.\n",

			cb->ext_name, cb->entry->name);

	if (cb->invert && !(entry->flags & XTOPT_INVERT))

		xt_params->exit_err(PARAMETER_PROBLEM,

			"%s: option \"--%s\" cannot be inverted.\n",

			cb->ext_name, entry->name);

	if (entry->type != XTTYPE_NONE && optarg == NULL)

		xt_params->exit_err(PARAMETER_PROBLEM,

			"%s: option \"--%s\" requires an argument.\n",

			cb->ext_name, entry->name);

	/*

	 * Fill in fallback value for "nvals", in case an extension (as it

	 * happened with libxt_conntrack.2) tries to read it, despite not using

	 * a *RC option type.

	 */

	cb->nvals = 1;

	if (entry->type < ARRAY_SIZE(xtopt_subparse) &&

	    xtopt_subparse[entry->type] != NULL)

		xtopt_subparse[entry->type](cb);

	/* Exclusion with other flags tested later in finalize. */

	cb->xflags |= 1 << entry->id;

}

/**

 * Verifies that an extension's option map descriptor is valid, and ought to

 * be called right after the extension has been loaded, and before option

 * merging/xfrm.

 */

void xtables_option_metavalidate(const char *name,

				 const struct xt_option_entry *entry)

{

	for (; entry->name != NULL; ++entry) {

		if (entry->id >= CHAR_BIT * sizeof(unsigned int) ||

		    entry->id >= XT_OPTION_OFFSET_SCALE)

			xt_params->exit_err(OTHER_PROBLEM,

				"Extension %s uses invalid ID %u\n",

				name, entry->id);

		if (!(entry->flags & XTOPT_PUT)) {

			if (entry->ptroff != 0)

				xt_params->exit_err(OTHER_PROBLEM,

					"%s: ptroff for \"--%s\" is non-"

					"zero but no XTOPT_PUT is specified. "

					"Oversight?", name, entry->name);

			continue;

		}

		if (entry->type >= ARRAY_SIZE(xtopt_psize) ||