[deliverable/linux.git] / net / netfilter / xt_MARK.c

/* This is a module which is used for setting the NFMARK field of an skb. */

/* (C) 1999-2001 Marc Boucher <marc@mbsi.ca>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/ip.h>
#include <net/checksum.h>

#include <linux/netfilter/x_tables.h>
#include <linux/netfilter/xt_MARK.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Marc Boucher <marc@mbsi.ca>");
MODULE_DESCRIPTION("ip[6]tables MARK modification module");
MODULE_ALIAS("ipt_MARK");
MODULE_ALIAS("ip6t_MARK");

static unsigned int
target_v0(struct sk_buff **pskb,
	  const struct net_device *in,
	  const struct net_device *out,
	  unsigned int hooknum,
	  const struct xt_target *target,
	  const void *targinfo)
{
	const struct xt_mark_target_info *markinfo = targinfo;

	if((*pskb)->nfmark != markinfo->mark)
		(*pskb)->nfmark = markinfo->mark;

	return XT_CONTINUE;
}

static unsigned int
target_v1(struct sk_buff **pskb,
	  const struct net_device *in,
	  const struct net_device *out,
	  unsigned int hooknum,
	  const struct xt_target *target,
	  const void *targinfo)
{
	const struct xt_mark_target_info_v1 *markinfo = targinfo;
	int mark = 0;

	switch (markinfo->mode) {
	case XT_MARK_SET:
		mark = markinfo->mark;
		break;
		
	case XT_MARK_AND:
		mark = (*pskb)->nfmark & markinfo->mark;
		break;
		
	case XT_MARK_OR:
		mark = (*pskb)->nfmark | markinfo->mark;
		break;
	}

	if((*pskb)->nfmark != mark)
		(*pskb)->nfmark = mark;

	return XT_CONTINUE;
}


static int
checkentry_v0(const char *tablename,
	      const void *entry,
	      const struct xt_target *target,
	      void *targinfo,
	      unsigned int hook_mask)
{
	struct xt_mark_target_info *markinfo = targinfo;

	if (markinfo->mark > 0xffffffff) {
		printk(KERN_WARNING "MARK: Only supports 32bit wide mark\n");
		return 0;
	}
	return 1;
}

static int
checkentry_v1(const char *tablename,
	      const void *entry,
	      const struct xt_target *target,
	      void *targinfo,
	      unsigned int hook_mask)
{
	struct xt_mark_target_info_v1 *markinfo = targinfo;

	if (markinfo->mode != XT_MARK_SET
	    && markinfo->mode != XT_MARK_AND
	    && markinfo->mode != XT_MARK_OR) {
		printk(KERN_WARNING "MARK: unknown mode %u\n",
		       markinfo->mode);
		return 0;
	}
	if (markinfo->mark > 0xffffffff) {
		printk(KERN_WARNING "MARK: Only supports 32bit wide mark\n");
		return 0;
	}
	return 1;
}

static struct xt_target xt_mark_target[] = {
	{
		.name		= "MARK",
		.family		= AF_INET,
		.revision	= 0,
		.checkentry	= checkentry_v0,
		.target		= target_v0,
		.targetsize	= sizeof(struct xt_mark_target_info),
		.table		= "mangle",
		.me		= THIS_MODULE,
	},
	{
		.name		= "MARK",
		.family		= AF_INET,
		.revision	= 1,
		.checkentry	= checkentry_v1,
		.target		= target_v1,
		.targetsize	= sizeof(struct xt_mark_target_info_v1),
		.table		= "mangle",
		.me		= THIS_MODULE,
	},
	{
		.name		= "MARK",
		.family		= AF_INET6,
		.revision	= 0,
		.checkentry	= checkentry_v0,
		.target		= target_v0,
		.targetsize	= sizeof(struct xt_mark_target_info),
		.table		= "mangle",
		.me		= THIS_MODULE,
	},
};

static int __init xt_mark_init(void)
{
	return xt_register_targets(xt_mark_target, ARRAY_SIZE(xt_mark_target));
}

static void __exit xt_mark_fini(void)
{
	xt_unregister_targets(xt_mark_target, ARRAY_SIZE(xt_mark_target));
}

module_init(xt_mark_init);
module_exit(xt_mark_fini);
Commit	Line	Data
1da177e4 LT	1	/* This is a module which is used for setting the NFMARK field of an skb. */
	2
	3	/* (C) 1999-2001 Marc Boucher <marc@mbsi.ca>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundation.
	8	*/
	9
	10	#include <linux/module.h>
	11	#include <linux/skbuff.h>
	12	#include <linux/ip.h>
	13	#include <net/checksum.h>
	14
2e4e6a17 HW	15	#include <linux/netfilter/x_tables.h>
2e4e6a17 HW	16	#include <linux/netfilter/xt_MARK.h>
1da177e4 LT	17
	18	MODULE_LICENSE("GPL");
	19	MODULE_AUTHOR("Marc Boucher <marc@mbsi.ca>");
2e4e6a17 HW	20	MODULE_DESCRIPTION("ip[6]tables MARK modification module");
	21	MODULE_ALIAS("ipt_MARK");
	22	MODULE_ALIAS("ip6t_MARK");
1da177e4 LT	23
	24	static unsigned int
	25	target_v0(struct sk_buff **pskb,
	26	const struct net_device *in,
	27	const struct net_device *out,
	28	unsigned int hooknum,
c4986734	29	const struct xt_target *target,
fe1cb108	30	const void *targinfo)
1da177e4	31	{
2e4e6a17	32	const struct xt_mark_target_info *markinfo = targinfo;
1da177e4	33
6869c4d8	34	if((*pskb)->nfmark != markinfo->mark)
1da177e4	35	(*pskb)->nfmark = markinfo->mark;
6869c4d8	36
2e4e6a17	37	return XT_CONTINUE;
1da177e4 LT	38	}
	39
	40	static unsigned int
	41	target_v1(struct sk_buff **pskb,
	42	const struct net_device *in,
	43	const struct net_device *out,
	44	unsigned int hooknum,
c4986734	45	const struct xt_target *target,
fe1cb108	46	const void *targinfo)
1da177e4	47	{
2e4e6a17	48	const struct xt_mark_target_info_v1 *markinfo = targinfo;
1da177e4 LT	49	int mark = 0;
	50
	51	switch (markinfo->mode) {
2e4e6a17	52	case XT_MARK_SET:
1da177e4 LT	53	mark = markinfo->mark;
	54	break;
	55
2e4e6a17	56	case XT_MARK_AND:
1da177e4 LT	57	mark = (*pskb)->nfmark & markinfo->mark;
	58	break;
	59
2e4e6a17	60	case XT_MARK_OR:
1da177e4 LT	61	mark = (*pskb)->nfmark \| markinfo->mark;
	62	break;
	63	}
	64
6869c4d8	65	if((*pskb)->nfmark != mark)
1da177e4	66	(*pskb)->nfmark = mark;
6869c4d8	67
2e4e6a17	68	return XT_CONTINUE;
1da177e4 LT	69	}
	70
	71
	72	static int
	73	checkentry_v0(const char *tablename,
2e4e6a17	74	const void *entry,
c4986734	75	const struct xt_target *target,
1da177e4	76	void *targinfo,
1da177e4 LT	77	unsigned int hook_mask)
1da177e4 LT	78	{
2e4e6a17	79	struct xt_mark_target_info *markinfo = targinfo;
bf3a46aa	80
bf3a46aa HW	81	if (markinfo->mark > 0xffffffff) {
	82	printk(KERN_WARNING "MARK: Only supports 32bit wide mark\n");
	83	return 0;
	84	}
1da177e4 LT	85	return 1;
	86	}
	87
	88	static int
	89	checkentry_v1(const char *tablename,
2e4e6a17	90	const void *entry,
c4986734	91	const struct xt_target *target,
1da177e4	92	void *targinfo,
1da177e4 LT	93	unsigned int hook_mask)
1da177e4 LT	94	{
2e4e6a17	95	struct xt_mark_target_info_v1 *markinfo = targinfo;
1da177e4	96
2e4e6a17 HW	97	if (markinfo->mode != XT_MARK_SET
	98	&& markinfo->mode != XT_MARK_AND
	99	&& markinfo->mode != XT_MARK_OR) {
1da177e4 LT	100	printk(KERN_WARNING "MARK: unknown mode %u\n",
	101	markinfo->mode);
	102	return 0;
	103	}
bf3a46aa HW	104	if (markinfo->mark > 0xffffffff) {
	105	printk(KERN_WARNING "MARK: Only supports 32bit wide mark\n");
	106	return 0;
	107	}
1da177e4 LT	108	return 1;
	109	}
	110
4470bbc7 PM	111	static struct xt_target xt_mark_target[] = {
	112	{
	113	.name = "MARK",
	114	.family = AF_INET,
	115	.revision = 0,
	116	.checkentry = checkentry_v0,
	117	.target = target_v0,
	118	.targetsize = sizeof(struct xt_mark_target_info),
	119	.table = "mangle",
	120	.me = THIS_MODULE,
	121	},
	122	{
	123	.name = "MARK",
	124	.family = AF_INET,
	125	.revision = 1,
	126	.checkentry = checkentry_v1,
	127	.target = target_v1,
	128	.targetsize = sizeof(struct xt_mark_target_info_v1),
	129	.table = "mangle",
	130	.me = THIS_MODULE,
	131	},
	132	{
	133	.name = "MARK",
	134	.family = AF_INET6,
	135	.revision = 0,
	136	.checkentry = checkentry_v0,
	137	.target = target_v0,
	138	.targetsize = sizeof(struct xt_mark_target_info),
	139	.table = "mangle",
	140	.me = THIS_MODULE,
	141	},
2e4e6a17 HW	142	};
2e4e6a17 HW	143
65b4b4e8	144	static int __init xt_mark_init(void)
1da177e4	145	{
4470bbc7	146	return xt_register_targets(xt_mark_target, ARRAY_SIZE(xt_mark_target));
1da177e4 LT	147	}
1da177e4 LT	148
65b4b4e8	149	static void __exit xt_mark_fini(void)
1da177e4	150	{
4470bbc7	151	xt_unregister_targets(xt_mark_target, ARRAY_SIZE(xt_mark_target));
1da177e4 LT	152	}
1da177e4 LT	153
65b4b4e8 AM	154	module_init(xt_mark_init);
65b4b4e8 AM	155	module_exit(xt_mark_fini);