[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / netfilter / xt_u32.c

/*
 *	xt_u32 - kernel module to match u32 packet content
 *
 *	Original author: Don Cohen <don@isis.cs3-inc.com>
 *	(C) CC Computer Consultants GmbH, 2007
 *	Contact: <jengelh@computergmbh.de>
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/spinlock.h>
#include <linux/skbuff.h>
#include <linux/types.h>
#include <linux/netfilter/x_tables.h>
#include <linux/netfilter/xt_u32.h>

static bool u32_match_it(const struct xt_u32 *data,
			 const struct sk_buff *skb)
{
	const struct xt_u32_test *ct;
	unsigned int testind;
	unsigned int nnums;
	unsigned int nvals;
	unsigned int i;
	__be32 n;
	u_int32_t pos;
	u_int32_t val;
	u_int32_t at;
	int ret;

	/*
	 * Small example: "0 >> 28 == 4 && 8 & 0xFF0000 >> 16 = 6, 17"
	 * (=IPv4 and (TCP or UDP)). Outer loop runs over the "&&" operands.
	 */
	for (testind = 0; testind < data->ntests; ++testind) {
		ct  = &data->tests[testind];
		at  = 0;
		pos = ct->location[0].number;

		if (skb->len < 4 || pos > skb->len - 4)
			return false;

		ret   = skb_copy_bits(skb, pos, &n, sizeof(n));
		BUG_ON(ret < 0);
		val   = ntohl(n);
		nnums = ct->nnums;

		/* Inner loop runs over "&", "<<", ">>" and "@" operands */
		for (i = 1; i < nnums; ++i) {
			u_int32_t number = ct->location[i].number;
			switch (ct->location[i].nextop) {
			case XT_U32_AND:
				val &= number;
				break;
			case XT_U32_LEFTSH:
				val <<= number;
				break;
			case XT_U32_RIGHTSH:
				val >>= number;
				break;
			case XT_U32_AT:
				if (at + val < at)
					return false;
				at += val;
				pos = number;
				if (at + 4 < at || skb->len < at + 4 ||
				    pos > skb->len - at - 4)
					return false;

				ret = skb_copy_bits(skb, at + pos, &n,
						    sizeof(n));
				BUG_ON(ret < 0);
				val = ntohl(n);
				break;
			}
		}

		/* Run over the "," and ":" operands */
		nvals = ct->nvalues;
		for (i = 0; i < nvals; ++i)
			if (ct->value[i].min <= val && val <= ct->value[i].max)
				break;

		if (i >= ct->nvalues)
			return false;
	}

	return true;
}

static bool
u32_mt(const struct sk_buff *skb, const struct net_device *in,
       const struct net_device *out, const struct xt_match *match,
       const void *matchinfo, int offset, unsigned int protoff, bool *hotdrop)
{
	const struct xt_u32 *data = matchinfo;
	bool ret;

	ret = u32_match_it(data, skb);
	return ret ^ data->invert;
}

static struct xt_match u32_mt_reg[] __read_mostly = {
	{
		.name       = "u32",
		.family     = AF_INET,
		.match      = u32_mt,
		.matchsize  = sizeof(struct xt_u32),
		.me         = THIS_MODULE,
	},
	{
		.name       = "u32",
		.family     = AF_INET6,
		.match      = u32_mt,
		.matchsize  = sizeof(struct xt_u32),
		.me         = THIS_MODULE,
	},
};

static int __init u32_mt_init(void)
{
	return xt_register_matches(u32_mt_reg, ARRAY_SIZE(u32_mt_reg));
}

static void __exit u32_mt_exit(void)
{
	xt_unregister_matches(u32_mt_reg, ARRAY_SIZE(u32_mt_reg));
}

module_init(u32_mt_init);
module_exit(u32_mt_exit);
MODULE_AUTHOR("Jan Engelhardt <jengelh@computergmbh.de>");
MODULE_DESCRIPTION("Xtables: arbitrary byte matching");
MODULE_LICENSE("GPL");
MODULE_ALIAS("ipt_u32");
MODULE_ALIAS("ip6t_u32");
Commit	Line	Data
1b50b8a3 JE	1	/*
	2	* xt_u32 - kernel module to match u32 packet content
	3	*
	4	* Original author: Don Cohen <don@isis.cs3-inc.com>
ba5dc275 JE	5	* (C) CC Computer Consultants GmbH, 2007
ba5dc275 JE	6	* Contact: <jengelh@computergmbh.de>
1b50b8a3 JE	7	*/
	8
	9	#include <linux/module.h>
	10	#include <linux/moduleparam.h>
	11	#include <linux/spinlock.h>
	12	#include <linux/skbuff.h>
	13	#include <linux/types.h>
	14	#include <linux/netfilter/x_tables.h>
	15	#include <linux/netfilter/xt_u32.h>
	16
	17	static bool u32_match_it(const struct xt_u32 *data,
	18	const struct sk_buff *skb)
	19	{
	20	const struct xt_u32_test *ct;
	21	unsigned int testind;
	22	unsigned int nnums;
	23	unsigned int nvals;
	24	unsigned int i;
a34c4589	25	__be32 n;
1b50b8a3 JE	26	u_int32_t pos;
	27	u_int32_t val;
	28	u_int32_t at;
	29	int ret;
	30
	31	/*
	32	* Small example: "0 >> 28 == 4 && 8 & 0xFF0000 >> 16 = 6, 17"
	33	* (=IPv4 and (TCP or UDP)). Outer loop runs over the "&&" operands.
	34	*/
	35	for (testind = 0; testind < data->ntests; ++testind) {
	36	ct = &data->tests[testind];
	37	at = 0;
	38	pos = ct->location[0].number;
	39
35019539	40	if (skb->len < 4 \|\| pos > skb->len - 4)
1b50b8a3 JE	41	return false;
1b50b8a3 JE	42
a34c4589	43	ret = skb_copy_bits(skb, pos, &n, sizeof(n));
1b50b8a3	44	BUG_ON(ret < 0);
a34c4589	45	val = ntohl(n);
1b50b8a3 JE	46	nnums = ct->nnums;
	47
	48	/* Inner loop runs over "&", "<<", ">>" and "@" operands */
	49	for (i = 1; i < nnums; ++i) {
	50	u_int32_t number = ct->location[i].number;
	51	switch (ct->location[i].nextop) {
	52	case XT_U32_AND:
	53	val &= number;
	54	break;
	55	case XT_U32_LEFTSH:
	56	val <<= number;
	57	break;
	58	case XT_U32_RIGHTSH:
	59	val >>= number;
	60	break;
	61	case XT_U32_AT:
	62	if (at + val < at)
	63	return false;
	64	at += val;
	65	pos = number;
	66	if (at + 4 < at \|\| skb->len < at + 4 \|\|
	67	pos > skb->len - at - 4)
	68	return false;
	69
a34c4589 AV	70	ret = skb_copy_bits(skb, at + pos, &n,
a34c4589 AV	71	sizeof(n));
1b50b8a3	72	BUG_ON(ret < 0);
a34c4589	73	val = ntohl(n);
1b50b8a3 JE	74	break;
	75	}
	76	}
	77
	78	/* Run over the "," and ":" operands */
	79	nvals = ct->nvalues;
	80	for (i = 0; i < nvals; ++i)
	81	if (ct->value[i].min <= val && val <= ct->value[i].max)
	82	break;
	83
	84	if (i >= ct->nvalues)
	85	return false;
	86	}
	87
	88	return true;
	89	}
	90
d3c5ee6d JE	91	static bool
	92	u32_mt(const struct sk_buff skb, const struct net_device in,
	93	const struct net_device out, const struct xt_match match,
	94	const void matchinfo, int offset, unsigned int protoff, bool hotdrop)
1b50b8a3 JE	95	{
	96	const struct xt_u32 *data = matchinfo;
	97	bool ret;
	98
	99	ret = u32_match_it(data, skb);
	100	return ret ^ data->invert;
	101	}
	102
d3c5ee6d	103	static struct xt_match u32_mt_reg[] __read_mostly = {
1b50b8a3 JE	104	{
	105	.name = "u32",
	106	.family = AF_INET,
d3c5ee6d	107	.match = u32_mt,
1b50b8a3 JE	108	.matchsize = sizeof(struct xt_u32),
	109	.me = THIS_MODULE,
	110	},
	111	{
	112	.name = "u32",
	113	.family = AF_INET6,
d3c5ee6d	114	.match = u32_mt,
1b50b8a3 JE	115	.matchsize = sizeof(struct xt_u32),
	116	.me = THIS_MODULE,
	117	},
	118	};
	119
d3c5ee6d	120	static int __init u32_mt_init(void)
1b50b8a3	121	{
d3c5ee6d	122	return xt_register_matches(u32_mt_reg, ARRAY_SIZE(u32_mt_reg));
1b50b8a3 JE	123	}
1b50b8a3 JE	124
d3c5ee6d	125	static void __exit u32_mt_exit(void)
1b50b8a3	126	{
d3c5ee6d	127	xt_unregister_matches(u32_mt_reg, ARRAY_SIZE(u32_mt_reg));
1b50b8a3 JE	128	}
1b50b8a3 JE	129
d3c5ee6d JE	130	module_init(u32_mt_init);
d3c5ee6d JE	131	module_exit(u32_mt_exit);
ba5dc275	132	MODULE_AUTHOR("Jan Engelhardt <jengelh@computergmbh.de>");
2ae15b64	133	MODULE_DESCRIPTION("Xtables: arbitrary byte matching");
1b50b8a3 JE	134	MODULE_LICENSE("GPL");
	135	MODULE_ALIAS("ipt_u32");
	136	MODULE_ALIAS("ip6t_u32");