[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 void *targinfo,
	  void *userinfo)
{
	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 void *targinfo,
	  void *userinfo)
{
	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,
	      void *targinfo,
	      unsigned int targinfosize,
	      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,
	      void *targinfo,
	      unsigned int targinfosize,
	      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 ipt_mark_reg_v0 = {
	.name		= "MARK",
	.target		= target_v0,
	.targetsize	= sizeof(struct xt_mark_target_info),
	.table		= "mangle",
	.checkentry	= checkentry_v0,
	.me		= THIS_MODULE,
	.revision	= 0,
};

static struct xt_target ipt_mark_reg_v1 = {
	.name		= "MARK",
	.target		= target_v1,
	.targetsize	= sizeof(struct xt_mark_target_info_v1),
	.table		= "mangle",
	.checkentry	= checkentry_v1,
	.me		= THIS_MODULE,
	.revision	= 1,
};

static struct xt_target ip6t_mark_reg_v0 = {
	.name		= "MARK",
	.target		= target_v0,
	.targetsize	= sizeof(struct xt_mark_target_info),
	.table		= "mangle",
	.checkentry	= checkentry_v0,
	.me		= THIS_MODULE,
	.revision	= 0,
};

static int __init init(void)
{
	int err;

	err = xt_register_target(AF_INET, &ipt_mark_reg_v0);
	if (err)
		return err;

	err = xt_register_target(AF_INET, &ipt_mark_reg_v1);
	if (err)
		xt_unregister_target(AF_INET, &ipt_mark_reg_v0);

	err = xt_register_target(AF_INET6, &ip6t_mark_reg_v0);
	if (err) {
		xt_unregister_target(AF_INET, &ipt_mark_reg_v0);
		xt_unregister_target(AF_INET, &ipt_mark_reg_v1);
	}

	return err;
}

static void __exit fini(void)
{
	xt_unregister_target(AF_INET, &ipt_mark_reg_v0);
	xt_unregister_target(AF_INET, &ipt_mark_reg_v1);
	xt_unregister_target(AF_INET6, &ip6t_mark_reg_v0);
}

module_init(init);
module_exit(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,
	29	const void *targinfo,
	30	void *userinfo)
	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,
	45	const void *targinfo,
	46	void *userinfo)
	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,
1da177e4 LT	75	void *targinfo,
	76	unsigned int targinfosize,
	77	unsigned int hook_mask)
	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,
1da177e4 LT	91	void *targinfo,
	92	unsigned int targinfosize,
	93	unsigned int hook_mask)
	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
2e4e6a17	111	static struct xt_target ipt_mark_reg_v0 = {
1da177e4 LT	112	.name = "MARK",
1da177e4 LT	113	.target = target_v0,
5d04bff0 PM	114	.targetsize = sizeof(struct xt_mark_target_info),
5d04bff0 PM	115	.table = "mangle",
1da177e4 LT	116	.checkentry = checkentry_v0,
	117	.me = THIS_MODULE,
	118	.revision = 0,
	119	};
	120
2e4e6a17	121	static struct xt_target ipt_mark_reg_v1 = {
1da177e4 LT	122	.name = "MARK",
1da177e4 LT	123	.target = target_v1,
5d04bff0 PM	124	.targetsize = sizeof(struct xt_mark_target_info_v1),
5d04bff0 PM	125	.table = "mangle",
1da177e4 LT	126	.checkentry = checkentry_v1,
	127	.me = THIS_MODULE,
	128	.revision = 1,
	129	};
	130
2e4e6a17 HW	131	static struct xt_target ip6t_mark_reg_v0 = {
	132	.name = "MARK",
	133	.target = target_v0,
5d04bff0 PM	134	.targetsize = sizeof(struct xt_mark_target_info),
5d04bff0 PM	135	.table = "mangle",
2e4e6a17 HW	136	.checkentry = checkentry_v0,
	137	.me = THIS_MODULE,
	138	.revision = 0,
	139	};
	140
1da177e4 LT	141	static int __init init(void)
	142	{
	143	int err;
	144
2e4e6a17 HW	145	err = xt_register_target(AF_INET, &ipt_mark_reg_v0);
	146	if (err)
	147	return err;
	148
	149	err = xt_register_target(AF_INET, &ipt_mark_reg_v1);
	150	if (err)
	151	xt_unregister_target(AF_INET, &ipt_mark_reg_v0);
	152
	153	err = xt_register_target(AF_INET6, &ip6t_mark_reg_v0);
	154	if (err) {
	155	xt_unregister_target(AF_INET, &ipt_mark_reg_v0);
	156	xt_unregister_target(AF_INET, &ipt_mark_reg_v1);
1da177e4	157	}
2e4e6a17	158
1da177e4 LT	159	return err;
	160	}
	161
	162	static void __exit fini(void)
	163	{
2e4e6a17 HW	164	xt_unregister_target(AF_INET, &ipt_mark_reg_v0);
	165	xt_unregister_target(AF_INET, &ipt_mark_reg_v1);
	166	xt_unregister_target(AF_INET6, &ip6t_mark_reg_v0);
1da177e4 LT	167	}
	168
	169	module_init(init);
	170	module_exit(fini);