extensions/libxt_rateest.c - platform/external/iptables - Gitiles

 /*
  * Copyright (c) 2008-2013 Patrick McHardy <kaber@trash.net>
  */

 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <stddef.h>
 #include <getopt.h>

 #include <xtables.h>
 #include <linux/netfilter/xt_rateest.h>

 static void rateest_help(void)
 {
 	printf(
 "rateest match options:\n"
 " --rateest1 name		Rate estimator name\n"
 " --rateest2 name		Rate estimator name\n"
 " --rateest-delta		Compare difference(s) to given rate(s)\n"
 " --rateest-bps1 [bps]		Compare bps\n"
 " --rateest-pps1 [pps]		Compare pps\n"
 " --rateest-bps2 [bps]		Compare bps\n"
 " --rateest-pps2 [pps]		Compare pps\n"
 " [!] --rateest-lt		Match if rate is less than given rate/estimator\n"
 " [!] --rateest-gt		Match if rate is greater than given rate/estimator\n"
 " [!] --rateest-eq		Match if rate is equal to given rate/estimator\n");
 }

 enum rateest_options {
 	OPT_RATEEST1,
 	OPT_RATEEST2,
 	OPT_RATEEST_BPS1,
 	OPT_RATEEST_PPS1,
 	OPT_RATEEST_BPS2,
 	OPT_RATEEST_PPS2,
 	OPT_RATEEST_DELTA,
 	OPT_RATEEST_LT,
 	OPT_RATEEST_GT,
 	OPT_RATEEST_EQ,
 };

 static const struct option rateest_opts[] = {
 	{.name = "rateest1",      .has_arg = true,  .val = OPT_RATEEST1},
 	{.name = "rateest",       .has_arg = true,  .val = OPT_RATEEST1}, /* alias for absolute mode */
 	{.name = "rateest2",      .has_arg = true,  .val = OPT_RATEEST2},
 	{.name = "rateest-bps1",  .has_arg = false, .val = OPT_RATEEST_BPS1},
 	{.name = "rateest-pps1",  .has_arg = false, .val = OPT_RATEEST_PPS1},
 	{.name = "rateest-bps2",  .has_arg = false, .val = OPT_RATEEST_BPS2},
 	{.name = "rateest-pps2",  .has_arg = false, .val = OPT_RATEEST_PPS2},
 	{.name = "rateest-bps",   .has_arg = false, .val = OPT_RATEEST_BPS2}, /* alias for absolute mode */
 	{.name = "rateest-pps",   .has_arg = false, .val = OPT_RATEEST_PPS2}, /* alias for absolute mode */
 	{.name = "rateest-delta", .has_arg = false, .val = OPT_RATEEST_DELTA},
 	{.name = "rateest-lt",    .has_arg = false, .val = OPT_RATEEST_LT},
 	{.name = "rateest-gt",    .has_arg = false, .val = OPT_RATEEST_GT},
 	{.name = "rateest-eq",    .has_arg = false, .val = OPT_RATEEST_EQ},
 	XT_GETOPT_TABLEEND,
 };

 /* Copied from iproute. See http://physics.nist.gov/cuu/Units/binary.html */
 static const struct rate_suffix {
 	const char *name;
 	double scale;
 } suffixes[] = {
 	{ "bit",	1. },
 	{ "Kibit",	1024. },
 	{ "kbit",	1000. },
 	{ "Mibit",	1024.*1024. },
 	{ "mbit",	1000000. },
 	{ "Gibit",	1024.*1024.*1024. },
 	{ "gbit",	1000000000. },
 	{ "Tibit",	1024.*1024.*1024.*1024. },
 	{ "tbit",	1000000000000. },
 	{ "Bps",	8. },
 	{ "KiBps",	8.*1024. },
 	{ "KBps",	8000. },
 	{ "MiBps",	8.*1024*1024. },
 	{ "MBps",	8000000. },
 	{ "GiBps",	8.*1024.*1024.*1024. },
 	{ "GBps",	8000000000. },
 	{ "TiBps",	8.*1024.*1024.*1024.*1024. },
 	{ "TBps",	8000000000000. },
 	{NULL},
 };

 static int
 rateest_get_rate(uint32_t *rate, const char *str)
 {
 	char *p;
 	double bps = strtod(str, &p);
 	const struct rate_suffix *s;

 	if (p == str)
 		return -1;

 	if (*p == '\0') {
 		*rate = bps / 8.;	/* assume bytes/sec */
 		return 0;
 	}

 	for (s = suffixes; s->name; ++s) {
 		if (strcasecmp(s->name, p) == 0) {
 			*rate = (bps * s->scale) / 8.;
 			return 0;
 		}
 	}

 	return -1;
 }

 static int
 rateest_parse(int c, char **argv, int invert, unsigned int *flags,
 	      const void *entry, struct xt_entry_match **match)
 {
 	struct xt_rateest_match_info *info = (void *)(*match)->data;
 	unsigned int val;

 	switch (c) {
 	case OPT_RATEEST1:
 		if (invert)
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: rateest can't be inverted");

 		if (*flags & (1 << c))
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: can't specify --rateest1 twice");
 		*flags |= 1 << c;

 		strncpy(info->name1, optarg, sizeof(info->name1) - 1);
 		break;

 	case OPT_RATEEST2:
 		if (invert)
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: rateest can't be inverted");

 		if (*flags & (1 << c))
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: can't specify --rateest2 twice");
 		*flags |= 1 << c;

 		strncpy(info->name2, optarg, sizeof(info->name2) - 1);
 		info->flags |= XT_RATEEST_MATCH_REL;
 		break;

 	case OPT_RATEEST_BPS1:
 		if (invert)
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: rateest-bps can't be inverted");

 		if (*flags & (1 << c))
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: can't specify --rateest-bps1 twice");
 		*flags |= 1 << c;

 		info->flags |= XT_RATEEST_MATCH_BPS;

 		/* The rate is optional and only required in absolute mode */
 		if (!argv[optind] || *argv[optind] == '-' || *argv[optind] == '!')
 			break;

 		if (rateest_get_rate(&info->bps1, argv[optind]) < 0)
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: could not parse rate `%s'",
 				   argv[optind]);
 		optind++;
 		break;

 	case OPT_RATEEST_PPS1:
 		if (invert)
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: rateest-pps can't be inverted");

 		if (*flags & (1 << c))
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: can't specify --rateest-pps1 twice");
 		*flags |= 1 << c;

 		info->flags |= XT_RATEEST_MATCH_PPS;

 		/* The rate is optional and only required in absolute mode */
 		if (!argv[optind] || *argv[optind] == '-' || *argv[optind] == '!')
 			break;

 		if (!xtables_strtoui(argv[optind], NULL, &val, 0, UINT32_MAX))
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: could not parse pps `%s'",
 				   argv[optind]);
 		info->pps1 = val;
 		optind++;
 		break;

 	case OPT_RATEEST_BPS2:
 		if (invert)
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: rateest-bps can't be inverted");

 		if (*flags & (1 << c))
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: can't specify --rateest-bps2 twice");
 		*flags |= 1 << c;

 		info->flags |= XT_RATEEST_MATCH_BPS;

 		/* The rate is optional and only required in absolute mode */
 		if (!argv[optind] || *argv[optind] == '-' || *argv[optind] == '!')
 			break;

 		if (rateest_get_rate(&info->bps2, argv[optind]) < 0)
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: could not parse rate `%s'",
 				   argv[optind]);
 		optind++;
 		break;

 	case OPT_RATEEST_PPS2:
 		if (invert)
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: rateest-pps can't be inverted");

 		if (*flags & (1 << c))
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: can't specify --rateest-pps2 twice");
 		*flags |= 1 << c;

 		info->flags |= XT_RATEEST_MATCH_PPS;

 		/* The rate is optional and only required in absolute mode */
 		if (!argv[optind] || *argv[optind] == '-' || *argv[optind] == '!')
 			break;

 		if (!xtables_strtoui(argv[optind], NULL, &val, 0, UINT32_MAX))
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: could not parse pps `%s'",
 				   argv[optind]);
 		info->pps2 = val;
 		optind++;
 		break;

 	case OPT_RATEEST_DELTA:
 		if (invert)
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: rateest-delta can't be inverted");

 		if (*flags & (1 << c))
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: can't specify --rateest-delta twice");
 		*flags |= 1 << c;

 		info->flags |= XT_RATEEST_MATCH_DELTA;
 		break;

 	case OPT_RATEEST_EQ:
 		if (*flags & (1 << c))
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: can't specify lt/gt/eq twice");
 		*flags |= 1 << c;

 		info->mode = XT_RATEEST_MATCH_EQ;
 		if (invert)
 			info->flags |= XT_RATEEST_MATCH_INVERT;
 		break;

 	case OPT_RATEEST_LT:
 		if (*flags & (1 << c))
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: can't specify lt/gt/eq twice");
 		*flags |= 1 << c;

 		info->mode = XT_RATEEST_MATCH_LT;
 		if (invert)
 			info->flags |= XT_RATEEST_MATCH_INVERT;
 		break;

 	case OPT_RATEEST_GT:
 		if (*flags & (1 << c))
 			xtables_error(PARAMETER_PROBLEM,
 				   "rateest: can't specify lt/gt/eq twice");
 		*flags |= 1 << c;

 		info->mode = XT_RATEEST_MATCH_GT;
 		if (invert)
 			info->flags |= XT_RATEEST_MATCH_INVERT;
 		break;
 	}

 	return 1;
 }

 static void rateest_final_check(struct xt_fcheck_call *cb)
 {
 	struct xt_rateest_match_info *info = cb->data;

 	if (info == NULL)
 		xtables_error(PARAMETER_PROBLEM, "rateest match: "
 		           "you need to specify some flags");
 	if (!(info->flags & XT_RATEEST_MATCH_REL))
 		info->flags |= XT_RATEEST_MATCH_ABS;
 }

 static void
 rateest_print_rate(uint32_t rate, int numeric)
 {
 	double tmp = (double)rate*8;

 	if (numeric)
 		printf(" %u", rate);
 	else if (tmp >= 1000.0*1000000.0)
 		printf(" %.0fMbit", tmp/1000000.0);
 	else if (tmp >= 1000.0 * 1000.0)
 		printf(" %.0fKbit", tmp/1000.0);
 	else
 		printf(" %.0fbit", tmp);
 }

 static void
 rateest_print_mode(const struct xt_rateest_match_info *info,
                    const char *prefix)
 {
 	if (info->flags & XT_RATEEST_MATCH_INVERT)
 		printf(" !");

 	switch (info->mode) {
 	case XT_RATEEST_MATCH_EQ:
 		printf(" %seq", prefix);
 		break;
 	case XT_RATEEST_MATCH_LT:
 		printf(" %slt", prefix);
 		break;
 	case XT_RATEEST_MATCH_GT:
 		printf(" %sgt", prefix);
 		break;
 	default:
 		exit(1);
 	}
 }

 static void
 rateest_print(const void *ip, const struct xt_entry_match *match, int numeric)
 {
 	const struct xt_rateest_match_info *info = (const void *)match->data;

 	printf(" rateest match ");

 	printf("%s", info->name1);
 	if (info->flags & XT_RATEEST_MATCH_DELTA)
 		printf(" delta");

 	if (info->flags & XT_RATEEST_MATCH_BPS) {
 		printf(" bps");
 		if (info->flags & XT_RATEEST_MATCH_DELTA)
 			rateest_print_rate(info->bps1, numeric);
 		if (info->flags & XT_RATEEST_MATCH_ABS) {
 			rateest_print_rate(info->bps2, numeric);
 			rateest_print_mode(info, "");
 		}
 	}
 	if (info->flags & XT_RATEEST_MATCH_PPS) {
 		printf(" pps");
 		if (info->flags & XT_RATEEST_MATCH_DELTA)
 			printf(" %u", info->pps1);
 		if (info->flags & XT_RATEEST_MATCH_ABS) {
 			rateest_print_mode(info, "");
 			printf(" %u", info->pps2);
 		}
 	}

 	if (info->flags & XT_RATEEST_MATCH_REL) {
 		rateest_print_mode(info, "");

 		printf(" %s", info->name2);

 		if (info->flags & XT_RATEEST_MATCH_BPS) {
 			printf(" bps");
 			if (info->flags & XT_RATEEST_MATCH_DELTA)
 				rateest_print_rate(info->bps2, numeric);
 		}
 		if (info->flags & XT_RATEEST_MATCH_PPS) {
 			printf(" pps");
 			if (info->flags & XT_RATEEST_MATCH_DELTA)
 				printf(" %u", info->pps2);
 		}
 	}
 }

 static void __rateest_save_rate(const struct xt_rateest_match_info *info,
                                 const char *name, uint32_t r1, uint32_t r2,
                                 int numeric)
 {
 	if (info->flags & XT_RATEEST_MATCH_DELTA) {
 		printf(" --rateest-%s1", name);
 		rateest_print_rate(r1, numeric);
 		rateest_print_mode(info, "--rateest-");
 		printf(" --rateest-%s2", name);
 	} else {
 		rateest_print_mode(info, "--rateest-");
 		printf(" --rateest-%s", name);
 	}

 	if (info->flags & (XT_RATEEST_MATCH_ABS|XT_RATEEST_MATCH_DELTA))
 		rateest_print_rate(r2, numeric);
 }

 static void rateest_save_rates(const struct xt_rateest_match_info *info)
 {
 	if (info->flags & XT_RATEEST_MATCH_BPS)
 		__rateest_save_rate(info, "bps", info->bps1, info->bps2, 0);
 	if (info->flags & XT_RATEEST_MATCH_PPS)
 		__rateest_save_rate(info, "pps", info->pps1, info->pps2, 1);
 }


 static void
 rateest_save(const void *ip, const struct xt_entry_match *match)
 {
 	const struct xt_rateest_match_info *info = (const void *)match->data;

 	if (info->flags & XT_RATEEST_MATCH_DELTA)
 		printf(" --rateest-delta");

 	if (info->flags & XT_RATEEST_MATCH_REL) {
 		printf(" --rateest1 %s", info->name1);
 		rateest_save_rates(info);
 		printf(" --rateest2 %s", info->name2);
 	} else { /* XT_RATEEST_MATCH_ABS */
 		printf(" --rateest %s", info->name1);
 		rateest_save_rates(info);
 	}
 }

 static struct xtables_match rateest_mt_reg = {
 	.family		= NFPROTO_UNSPEC,
 	.name		= "rateest",
 	.version	= XTABLES_VERSION,
 	.size		= XT_ALIGN(sizeof(struct xt_rateest_match_info)),
 	.userspacesize	= XT_ALIGN(offsetof(struct xt_rateest_match_info, est1)),
 	.help		= rateest_help,
 	.parse		= rateest_parse,
 	.x6_fcheck	= rateest_final_check,
 	.print		= rateest_print,
 	.save		= rateest_save,
 	.extra_opts	= rateest_opts,
 };

 void _init(void)
 {
 	xtables_register_match(&rateest_mt_reg);
 }
	/*
	* Copyright (c) 2008-2013 Patrick McHardy <kaber@trash.net>
	*/

	#include <stdbool.h>
	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>
	#include <stddef.h>
	#include <getopt.h>

	#include <xtables.h>
	#include <linux/netfilter/xt_rateest.h>

	static void rateest_help(void)
	{
	printf(
	"rateest match options:\n"
	" --rateest1 name Rate estimator name\n"
	" --rateest2 name Rate estimator name\n"
	" --rateest-delta Compare difference(s) to given rate(s)\n"
	" --rateest-bps1 [bps] Compare bps\n"
	" --rateest-pps1 [pps] Compare pps\n"
	" --rateest-bps2 [bps] Compare bps\n"
	" --rateest-pps2 [pps] Compare pps\n"
	" [!] --rateest-lt Match if rate is less than given rate/estimator\n"
	" [!] --rateest-gt Match if rate is greater than given rate/estimator\n"
	" [!] --rateest-eq Match if rate is equal to given rate/estimator\n");
	}

	enum rateest_options {
	OPT_RATEEST1,
	OPT_RATEEST2,
	OPT_RATEEST_BPS1,
	OPT_RATEEST_PPS1,
	OPT_RATEEST_BPS2,
	OPT_RATEEST_PPS2,
	OPT_RATEEST_DELTA,
	OPT_RATEEST_LT,
	OPT_RATEEST_GT,
	OPT_RATEEST_EQ,
	};

	static const struct option rateest_opts[] = {
	{.name = "rateest1", .has_arg = true, .val = OPT_RATEEST1},
	{.name = "rateest", .has_arg = true, .val = OPT_RATEEST1}, /* alias for absolute mode */
	{.name = "rateest2", .has_arg = true, .val = OPT_RATEEST2},
	{.name = "rateest-bps1", .has_arg = false, .val = OPT_RATEEST_BPS1},
	{.name = "rateest-pps1", .has_arg = false, .val = OPT_RATEEST_PPS1},
	{.name = "rateest-bps2", .has_arg = false, .val = OPT_RATEEST_BPS2},
	{.name = "rateest-pps2", .has_arg = false, .val = OPT_RATEEST_PPS2},
	{.name = "rateest-bps", .has_arg = false, .val = OPT_RATEEST_BPS2}, /* alias for absolute mode */
	{.name = "rateest-pps", .has_arg = false, .val = OPT_RATEEST_PPS2}, /* alias for absolute mode */
	{.name = "rateest-delta", .has_arg = false, .val = OPT_RATEEST_DELTA},
	{.name = "rateest-lt", .has_arg = false, .val = OPT_RATEEST_LT},
	{.name = "rateest-gt", .has_arg = false, .val = OPT_RATEEST_GT},
	{.name = "rateest-eq", .has_arg = false, .val = OPT_RATEEST_EQ},
	XT_GETOPT_TABLEEND,
	};

	/* Copied from iproute. See http://physics.nist.gov/cuu/Units/binary.html */
	static const struct rate_suffix {
	const char *name;
	double scale;
	} suffixes[] = {
	{ "bit", 1. },
	{ "Kibit", 1024. },
	{ "kbit", 1000. },
	{ "Mibit", 1024.*1024. },
	{ "mbit", 1000000. },
	{ "Gibit", 1024.1024.1024. },
	{ "gbit", 1000000000. },
	{ "Tibit", 1024.1024.1024.*1024. },
	{ "tbit", 1000000000000. },
	{ "Bps", 8. },
	{ "KiBps", 8.*1024. },
	{ "KBps", 8000. },
	{ "MiBps", 8.10241024. },
	{ "MBps", 8000000. },
	{ "GiBps", 8.1024.1024.*1024. },
	{ "GBps", 8000000000. },
	{ "TiBps", 8.1024.1024.1024.1024. },
	{ "TBps", 8000000000000. },
	{NULL},
	};

	static int
	rateest_get_rate(uint32_t rate, const char str)
	{
	char *p;
	double bps = strtod(str, &p);
	const struct rate_suffix *s;

	if (p == str)
	return -1;

	if (*p == '\0') {
	rate = bps / 8.; / assume bytes/sec */
	return 0;
	}

	for (s = suffixes; s->name; ++s) {
	if (strcasecmp(s->name, p) == 0) {
	rate = (bps s->scale) / 8.;
	return 0;
	}
	}

	return -1;
	}

	static int
	rateest_parse(int c, char *argv, int invert, unsigned int flags,
	const void entry, struct xt_entry_match *match)
	{
	struct xt_rateest_match_info info = (void )(*match)->data;
	unsigned int val;

	switch (c) {
	case OPT_RATEEST1:
	if (invert)
	xtables_error(PARAMETER_PROBLEM,
	"rateest: rateest can't be inverted");

	if (*flags & (1 << c))
	xtables_error(PARAMETER_PROBLEM,
	"rateest: can't specify --rateest1 twice");
	*flags \|= 1 << c;

	strncpy(info->name1, optarg, sizeof(info->name1) - 1);
	break;

	case OPT_RATEEST2:
	if (invert)
	xtables_error(PARAMETER_PROBLEM,
	"rateest: rateest can't be inverted");

	if (*flags & (1 << c))
	xtables_error(PARAMETER_PROBLEM,
	"rateest: can't specify --rateest2 twice");
	*flags \|= 1 << c;

	strncpy(info->name2, optarg, sizeof(info->name2) - 1);
	info->flags \|= XT_RATEEST_MATCH_REL;
	break;

	case OPT_RATEEST_BPS1:
	if (invert)
	xtables_error(PARAMETER_PROBLEM,
	"rateest: rateest-bps can't be inverted");

	if (*flags & (1 << c))
	xtables_error(PARAMETER_PROBLEM,
	"rateest: can't specify --rateest-bps1 twice");
	*flags \|= 1 << c;

	info->flags \|= XT_RATEEST_MATCH_BPS;

	/* The rate is optional and only required in absolute mode */
	if (!argv[optind] \|\| argv[optind] == '-' \|\| argv[optind] == '!')
	break;

	if (rateest_get_rate(&info->bps1, argv[optind]) < 0)
	xtables_error(PARAMETER_PROBLEM,
	"rateest: could not parse rate `%s'",
	argv[optind]);
	optind++;
	break;

	case OPT_RATEEST_PPS1:
	if (invert)
	xtables_error(PARAMETER_PROBLEM,
	"rateest: rateest-pps can't be inverted");

	if (*flags & (1 << c))
	xtables_error(PARAMETER_PROBLEM,
	"rateest: can't specify --rateest-pps1 twice");
	*flags \|= 1 << c;

	info->flags \|= XT_RATEEST_MATCH_PPS;

	/* The rate is optional and only required in absolute mode */
	if (!argv[optind] \|\| argv[optind] == '-' \|\| argv[optind] == '!')
	break;

	if (!xtables_strtoui(argv[optind], NULL, &val, 0, UINT32_MAX))
	xtables_error(PARAMETER_PROBLEM,
	"rateest: could not parse pps `%s'",
	argv[optind]);
	info->pps1 = val;
	optind++;
	break;

	case OPT_RATEEST_BPS2:
	if (invert)
	xtables_error(PARAMETER_PROBLEM,
	"rateest: rateest-bps can't be inverted");

	if (*flags & (1 << c))
	xtables_error(PARAMETER_PROBLEM,
	"rateest: can't specify --rateest-bps2 twice");
	*flags \|= 1 << c;

	info->flags \|= XT_RATEEST_MATCH_BPS;

	/* The rate is optional and only required in absolute mode */
	if (!argv[optind] \|\| argv[optind] == '-' \|\| argv[optind] == '!')
	break;

	if (rateest_get_rate(&info->bps2, argv[optind]) < 0)
	xtables_error(PARAMETER_PROBLEM,
	"rateest: could not parse rate `%s'",
	argv[optind]);
	optind++;
	break;

	case OPT_RATEEST_PPS2:
	if (invert)
	xtables_error(PARAMETER_PROBLEM,
	"rateest: rateest-pps can't be inverted");

	if (*flags & (1 << c))
	xtables_error(PARAMETER_PROBLEM,
	"rateest: can't specify --rateest-pps2 twice");
	*flags \|= 1 << c;

	info->flags \|= XT_RATEEST_MATCH_PPS;

	/* The rate is optional and only required in absolute mode */
	if (!argv[optind] \|\| argv[optind] == '-' \|\| argv[optind] == '!')
	break;

	if (!xtables_strtoui(argv[optind], NULL, &val, 0, UINT32_MAX))
	xtables_error(PARAMETER_PROBLEM,
	"rateest: could not parse pps `%s'",
	argv[optind]);
	info->pps2 = val;
	optind++;
	break;

	case OPT_RATEEST_DELTA:
	if (invert)
	xtables_error(PARAMETER_PROBLEM,
	"rateest: rateest-delta can't be inverted");

	if (*flags & (1 << c))
	xtables_error(PARAMETER_PROBLEM,
	"rateest: can't specify --rateest-delta twice");
	*flags \|= 1 << c;

	info->flags \|= XT_RATEEST_MATCH_DELTA;
	break;

	case OPT_RATEEST_EQ:
	if (*flags & (1 << c))
	xtables_error(PARAMETER_PROBLEM,
	"rateest: can't specify lt/gt/eq twice");
	*flags \|= 1 << c;

	info->mode = XT_RATEEST_MATCH_EQ;
	if (invert)
	info->flags \|= XT_RATEEST_MATCH_INVERT;
	break;

	case OPT_RATEEST_LT:
	if (*flags & (1 << c))
	xtables_error(PARAMETER_PROBLEM,
	"rateest: can't specify lt/gt/eq twice");
	*flags \|= 1 << c;

	info->mode = XT_RATEEST_MATCH_LT;
	if (invert)
	info->flags \|= XT_RATEEST_MATCH_INVERT;
	break;

	case OPT_RATEEST_GT:
	if (*flags & (1 << c))
	xtables_error(PARAMETER_PROBLEM,
	"rateest: can't specify lt/gt/eq twice");
	*flags \|= 1 << c;

	info->mode = XT_RATEEST_MATCH_GT;
	if (invert)
	info->flags \|= XT_RATEEST_MATCH_INVERT;
	break;
	}

	return 1;
	}

	static void rateest_final_check(struct xt_fcheck_call *cb)
	{
	struct xt_rateest_match_info *info = cb->data;

	if (info == NULL)
	xtables_error(PARAMETER_PROBLEM, "rateest match: "
	"you need to specify some flags");
	if (!(info->flags & XT_RATEEST_MATCH_REL))
	info->flags \|= XT_RATEEST_MATCH_ABS;
	}

	static void
	rateest_print_rate(uint32_t rate, int numeric)
	{
	double tmp = (double)rate*8;

	if (numeric)
	printf(" %u", rate);
	else if (tmp >= 1000.0*1000000.0)
	printf(" %.0fMbit", tmp/1000000.0);
	else if (tmp >= 1000.0 * 1000.0)
	printf(" %.0fKbit", tmp/1000.0);
	else
	printf(" %.0fbit", tmp);
	}

	static void
	rateest_print_mode(const struct xt_rateest_match_info *info,
	const char *prefix)
	{
	if (info->flags & XT_RATEEST_MATCH_INVERT)
	printf(" !");

	switch (info->mode) {
	case XT_RATEEST_MATCH_EQ:
	printf(" %seq", prefix);
	break;
	case XT_RATEEST_MATCH_LT:
	printf(" %slt", prefix);
	break;
	case XT_RATEEST_MATCH_GT:
	printf(" %sgt", prefix);
	break;
	default:
	exit(1);
	}
	}

	static void
	rateest_print(const void ip, const struct xt_entry_match match, int numeric)
	{
	const struct xt_rateest_match_info info = (const void )match->data;

	printf(" rateest match ");

	printf("%s", info->name1);
	if (info->flags & XT_RATEEST_MATCH_DELTA)
	printf(" delta");

	if (info->flags & XT_RATEEST_MATCH_BPS) {
	printf(" bps");
	if (info->flags & XT_RATEEST_MATCH_DELTA)
	rateest_print_rate(info->bps1, numeric);
	if (info->flags & XT_RATEEST_MATCH_ABS) {
	rateest_print_rate(info->bps2, numeric);
	rateest_print_mode(info, "");
	}
	}
	if (info->flags & XT_RATEEST_MATCH_PPS) {
	printf(" pps");
	if (info->flags & XT_RATEEST_MATCH_DELTA)
	printf(" %u", info->pps1);
	if (info->flags & XT_RATEEST_MATCH_ABS) {
	rateest_print_mode(info, "");
	printf(" %u", info->pps2);
	}
	}

	if (info->flags & XT_RATEEST_MATCH_REL) {
	rateest_print_mode(info, "");

	printf(" %s", info->name2);

	if (info->flags & XT_RATEEST_MATCH_BPS) {
	printf(" bps");
	if (info->flags & XT_RATEEST_MATCH_DELTA)
	rateest_print_rate(info->bps2, numeric);
	}
	if (info->flags & XT_RATEEST_MATCH_PPS) {
	printf(" pps");
	if (info->flags & XT_RATEEST_MATCH_DELTA)
	printf(" %u", info->pps2);
	}
	}
	}

	static void __rateest_save_rate(const struct xt_rateest_match_info *info,
	const char *name, uint32_t r1, uint32_t r2,
	int numeric)
	{
	if (info->flags & XT_RATEEST_MATCH_DELTA) {
	printf(" --rateest-%s1", name);
	rateest_print_rate(r1, numeric);
	rateest_print_mode(info, "--rateest-");
	printf(" --rateest-%s2", name);
	} else {
	rateest_print_mode(info, "--rateest-");
	printf(" --rateest-%s", name);
	}

	if (info->flags & (XT_RATEEST_MATCH_ABS\|XT_RATEEST_MATCH_DELTA))
	rateest_print_rate(r2, numeric);
	}

	static void rateest_save_rates(const struct xt_rateest_match_info *info)
	{
	if (info->flags & XT_RATEEST_MATCH_BPS)
	__rateest_save_rate(info, "bps", info->bps1, info->bps2, 0);
	if (info->flags & XT_RATEEST_MATCH_PPS)
	__rateest_save_rate(info, "pps", info->pps1, info->pps2, 1);
	}


	static void
	rateest_save(const void ip, const struct xt_entry_match match)
	{
	const struct xt_rateest_match_info info = (const void )match->data;

	if (info->flags & XT_RATEEST_MATCH_DELTA)
	printf(" --rateest-delta");

	if (info->flags & XT_RATEEST_MATCH_REL) {
	printf(" --rateest1 %s", info->name1);
	rateest_save_rates(info);
	printf(" --rateest2 %s", info->name2);
	} else { /* XT_RATEEST_MATCH_ABS */
	printf(" --rateest %s", info->name1);
	rateest_save_rates(info);
	}
	}

	static struct xtables_match rateest_mt_reg = {
	.family = NFPROTO_UNSPEC,
	.name = "rateest",
	.version = XTABLES_VERSION,
	.size = XT_ALIGN(sizeof(struct xt_rateest_match_info)),
	.userspacesize = XT_ALIGN(offsetof(struct xt_rateest_match_info, est1)),
	.help = rateest_help,
	.parse = rateest_parse,
	.x6_fcheck = rateest_final_check,
	.print = rateest_print,
	.save = rateest_save,
	.extra_opts = rateest_opts,
	};

	void _init(void)
	{
	xtables_register_match(&rateest_mt_reg);
	}