[linux.git] / net / netfilter / xt_u32.c

/*
 *	xt_u32 - kernel module to match u32 packet content
 *
 *	Original author: Don Cohen <[email protected]>
 *	(C) CC Computer Consultants GmbH, 2007
 */

#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;

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

		if (skb_copy_bits(skb, pos, &n, sizeof(n)) < 0)
			BUG();
		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;

				if (skb_copy_bits(skb, at + pos, &n,
						    sizeof(n)) < 0)
					BUG();
				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, struct xt_action_param *par)
{
	const struct xt_u32 *data = par->matchinfo;
	bool ret;

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

static struct xt_match xt_u32_mt_reg __read_mostly = {
	.name       = "u32",
	.revision   = 0,
	.family     = NFPROTO_UNSPEC,
	.match      = u32_mt,
	.matchsize  = sizeof(struct xt_u32),
	.me         = THIS_MODULE,
};

static int __init u32_mt_init(void)
{
	return xt_register_match(&xt_u32_mt_reg);
}

static void __exit u32_mt_exit(void)
{
	xt_unregister_match(&xt_u32_mt_reg);
}

module_init(u32_mt_init);
module_exit(u32_mt_exit);
MODULE_AUTHOR("Jan Engelhardt <[email protected]>");
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 <[email protected]>
ba5dc275	5	* (C) CC Computer Consultants GmbH, 2007
1b50b8a3 JE	6	*/
	7
	8	#include <linux/module.h>
	9	#include <linux/moduleparam.h>
	10	#include <linux/spinlock.h>
	11	#include <linux/skbuff.h>
	12	#include <linux/types.h>
	13	#include <linux/netfilter/x_tables.h>
	14	#include <linux/netfilter/xt_u32.h>
	15
	16	static bool u32_match_it(const struct xt_u32 *data,
	17	const struct sk_buff *skb)
	18	{
	19	const struct xt_u32_test *ct;
	20	unsigned int testind;
	21	unsigned int nnums;
	22	unsigned int nvals;
	23	unsigned int i;
a34c4589	24	__be32 n;
1b50b8a3 JE	25	u_int32_t pos;
	26	u_int32_t val;
	27	u_int32_t at;
1b50b8a3 JE	28
	29	/*
	30	* Small example: "0 >> 28 == 4 && 8 & 0xFF0000 >> 16 = 6, 17"
	31	* (=IPv4 and (TCP or UDP)). Outer loop runs over the "&&" operands.
	32	*/
	33	for (testind = 0; testind < data->ntests; ++testind) {
	34	ct = &data->tests[testind];
	35	at = 0;
	36	pos = ct->location[0].number;
	37
35019539	38	if (skb->len < 4 \|\| pos > skb->len - 4)
1b50b8a3 JE	39	return false;
1b50b8a3 JE	40
f449b3b5 PE	41	if (skb_copy_bits(skb, pos, &n, sizeof(n)) < 0)
f449b3b5 PE	42	BUG();
a34c4589	43	val = ntohl(n);
1b50b8a3 JE	44	nnums = ct->nnums;
	45
	46	/* Inner loop runs over "&", "<<", ">>" and "@" operands */
	47	for (i = 1; i < nnums; ++i) {
	48	u_int32_t number = ct->location[i].number;
	49	switch (ct->location[i].nextop) {
	50	case XT_U32_AND:
	51	val &= number;
	52	break;
	53	case XT_U32_LEFTSH:
	54	val <<= number;
	55	break;
	56	case XT_U32_RIGHTSH:
	57	val >>= number;
	58	break;
	59	case XT_U32_AT:
	60	if (at + val < at)
	61	return false;
	62	at += val;
	63	pos = number;
	64	if (at + 4 < at \|\| skb->len < at + 4 \|\|
	65	pos > skb->len - at - 4)
	66	return false;
	67
f449b3b5 PE	68	if (skb_copy_bits(skb, at + pos, &n,
	69	sizeof(n)) < 0)
	70	BUG();
a34c4589	71	val = ntohl(n);
1b50b8a3 JE	72	break;
	73	}
	74	}
	75
	76	/* Run over the "," and ":" operands */
	77	nvals = ct->nvalues;
	78	for (i = 0; i < nvals; ++i)
	79	if (ct->value[i].min <= val && val <= ct->value[i].max)
	80	break;
	81
	82	if (i >= ct->nvalues)
	83	return false;
	84	}
	85
	86	return true;
	87	}
	88
62fc8051	89	static bool u32_mt(const struct sk_buff skb, struct xt_action_param par)
1b50b8a3	90	{
f7108a20	91	const struct xt_u32 *data = par->matchinfo;
1b50b8a3 JE	92	bool ret;
	93
	94	ret = u32_match_it(data, skb);
	95	return ret ^ data->invert;
	96	}
	97
55b69e91 JE	98	static struct xt_match xt_u32_mt_reg __read_mostly = {
	99	.name = "u32",
	100	.revision = 0,
	101	.family = NFPROTO_UNSPEC,
	102	.match = u32_mt,
	103	.matchsize = sizeof(struct xt_u32),
	104	.me = THIS_MODULE,
1b50b8a3 JE	105	};
1b50b8a3 JE	106
d3c5ee6d	107	static int __init u32_mt_init(void)
1b50b8a3	108	{
55b69e91	109	return xt_register_match(&xt_u32_mt_reg);
1b50b8a3 JE	110	}
1b50b8a3 JE	111
d3c5ee6d	112	static void __exit u32_mt_exit(void)
1b50b8a3	113	{
55b69e91	114	xt_unregister_match(&xt_u32_mt_reg);
1b50b8a3 JE	115	}
1b50b8a3 JE	116
d3c5ee6d JE	117	module_init(u32_mt_init);
d3c5ee6d JE	118	module_exit(u32_mt_exit);
408ffaa4	119	MODULE_AUTHOR("Jan Engelhardt <[email protected]>");
2ae15b64	120	MODULE_DESCRIPTION("Xtables: arbitrary byte matching");
1b50b8a3 JE	121	MODULE_LICENSE("GPL");
	122	MODULE_ALIAS("ipt_u32");
	123	MODULE_ALIAS("ip6t_u32");