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

/* x_tables module for setting the IPv4/IPv6 DSCP field, Version 1.8
 *
 * (C) 2002 by Harald Welte <laforge@netfilter.org>
 * based on ipt_FTOS.c (C) 2000 by Matthew G. Marsh <mgm@paktronix.com>
 *
 * 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.
 *
 * See RFC2474 for a description of the DSCP field within the IP Header.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <net/dsfield.h>

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

MODULE_AUTHOR("Harald Welte <laforge@netfilter.org>");
MODULE_DESCRIPTION("Xtables: DSCP/TOS field modification");
MODULE_LICENSE("GPL");
MODULE_ALIAS("ipt_DSCP");
MODULE_ALIAS("ip6t_DSCP");
MODULE_ALIAS("ipt_TOS");
MODULE_ALIAS("ip6t_TOS");

static unsigned int
dscp_tg(struct sk_buff *skb, const struct xt_action_param *par)
{
	const struct xt_DSCP_info *dinfo = par->targinfo;
	u_int8_t dscp = ipv4_get_dsfield(ip_hdr(skb)) >> XT_DSCP_SHIFT;

	if (dscp != dinfo->dscp) {
		if (!skb_make_writable(skb, sizeof(struct iphdr)))
			return NF_DROP;

		ipv4_change_dsfield(ip_hdr(skb), (__u8)(~XT_DSCP_MASK),
				    dinfo->dscp << XT_DSCP_SHIFT);

	}
	return XT_CONTINUE;
}

static unsigned int
dscp_tg6(struct sk_buff *skb, const struct xt_action_param *par)
{
	const struct xt_DSCP_info *dinfo = par->targinfo;
	u_int8_t dscp = ipv6_get_dsfield(ipv6_hdr(skb)) >> XT_DSCP_SHIFT;

	if (dscp != dinfo->dscp) {
		if (!skb_make_writable(skb, sizeof(struct ipv6hdr)))
			return NF_DROP;

		ipv6_change_dsfield(ipv6_hdr(skb), (__u8)(~XT_DSCP_MASK),
				    dinfo->dscp << XT_DSCP_SHIFT);
	}
	return XT_CONTINUE;
}

static int dscp_tg_check(const struct xt_tgchk_param *par)
{
	const struct xt_DSCP_info *info = par->targinfo;

	if (info->dscp > XT_DSCP_MAX) {
		pr_info("dscp %x out of range\n", info->dscp);
		return -EDOM;
	}
	return 0;
}

static unsigned int
tos_tg(struct sk_buff *skb, const struct xt_action_param *par)
{
	const struct xt_tos_target_info *info = par->targinfo;
	struct iphdr *iph = ip_hdr(skb);
	u_int8_t orig, nv;

	orig = ipv4_get_dsfield(iph);
	nv   = (orig & ~info->tos_mask) ^ info->tos_value;

	if (orig != nv) {
		if (!skb_make_writable(skb, sizeof(struct iphdr)))
			return NF_DROP;
		iph = ip_hdr(skb);
		ipv4_change_dsfield(iph, 0, nv);
	}

	return XT_CONTINUE;
}

static unsigned int
tos_tg6(struct sk_buff *skb, const struct xt_action_param *par)
{
	const struct xt_tos_target_info *info = par->targinfo;
	struct ipv6hdr *iph = ipv6_hdr(skb);
	u_int8_t orig, nv;

	orig = ipv6_get_dsfield(iph);
	nv   = (orig & ~info->tos_mask) ^ info->tos_value;

	if (orig != nv) {
		if (!skb_make_writable(skb, sizeof(struct iphdr)))
			return NF_DROP;
		iph = ipv6_hdr(skb);
		ipv6_change_dsfield(iph, 0, nv);
	}

	return XT_CONTINUE;
}

static struct xt_target dscp_tg_reg[] __read_mostly = {
	{
		.name		= "DSCP",
		.family		= NFPROTO_IPV4,
		.checkentry	= dscp_tg_check,
		.target		= dscp_tg,
		.targetsize	= sizeof(struct xt_DSCP_info),
		.table		= "mangle",
		.me		= THIS_MODULE,
	},
	{
		.name		= "DSCP",
		.family		= NFPROTO_IPV6,
		.checkentry	= dscp_tg_check,
		.target		= dscp_tg6,
		.targetsize	= sizeof(struct xt_DSCP_info),
		.table		= "mangle",
		.me		= THIS_MODULE,
	},
	{
		.name		= "TOS",
		.revision	= 1,
		.family		= NFPROTO_IPV4,
		.table		= "mangle",
		.target		= tos_tg,
		.targetsize	= sizeof(struct xt_tos_target_info),
		.me		= THIS_MODULE,
	},
	{
		.name		= "TOS",
		.revision	= 1,
		.family		= NFPROTO_IPV6,
		.table		= "mangle",
		.target		= tos_tg6,
		.targetsize	= sizeof(struct xt_tos_target_info),
		.me		= THIS_MODULE,
	},
};

static int __init dscp_tg_init(void)
{
	return xt_register_targets(dscp_tg_reg, ARRAY_SIZE(dscp_tg_reg));
}

static void __exit dscp_tg_exit(void)
{
	xt_unregister_targets(dscp_tg_reg, ARRAY_SIZE(dscp_tg_reg));
}

module_init(dscp_tg_init);
module_exit(dscp_tg_exit);
Commit	Line	Data
a468701d YK	1	/* x_tables module for setting the IPv4/IPv6 DSCP field, Version 1.8
	2	*
	3	* (C) 2002 by Harald Welte <laforge@netfilter.org>
	4	* based on ipt_FTOS.c (C) 2000 by Matthew G. Marsh <mgm@paktronix.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*
	10	* See RFC2474 for a description of the DSCP field within the IP Header.
a468701d	11	*/
8bee4bad	12	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
a468701d YK	13	#include <linux/module.h>
	14	#include <linux/skbuff.h>
	15	#include <linux/ip.h>
	16	#include <linux/ipv6.h>
	17	#include <net/dsfield.h>
	18
	19	#include <linux/netfilter/x_tables.h>
	20	#include <linux/netfilter/xt_DSCP.h>
	21
	22	MODULE_AUTHOR("Harald Welte <laforge@netfilter.org>");
2ae15b64	23	MODULE_DESCRIPTION("Xtables: DSCP/TOS field modification");
a468701d YK	24	MODULE_LICENSE("GPL");
	25	MODULE_ALIAS("ipt_DSCP");
	26	MODULE_ALIAS("ip6t_DSCP");
c9fd4968	27	MODULE_ALIAS("ipt_TOS");
5c350e5a	28	MODULE_ALIAS("ip6t_TOS");
a468701d	29
d3c5ee6d	30	static unsigned int
4b560b44	31	dscp_tg(struct sk_buff skb, const struct xt_action_param par)
a468701d	32	{
7eb35586	33	const struct xt_DSCP_info *dinfo = par->targinfo;
3db05fea	34	u_int8_t dscp = ipv4_get_dsfield(ip_hdr(skb)) >> XT_DSCP_SHIFT;
a468701d YK	35
a468701d YK	36	if (dscp != dinfo->dscp) {
3db05fea	37	if (!skb_make_writable(skb, sizeof(struct iphdr)))
a468701d YK	38	return NF_DROP;
a468701d YK	39
3db05fea	40	ipv4_change_dsfield(ip_hdr(skb), (__u8)(~XT_DSCP_MASK),
a468701d YK	41	dinfo->dscp << XT_DSCP_SHIFT);
	42
	43	}
	44	return XT_CONTINUE;
	45	}
	46
d3c5ee6d	47	static unsigned int
4b560b44	48	dscp_tg6(struct sk_buff skb, const struct xt_action_param par)
a468701d	49	{
7eb35586	50	const struct xt_DSCP_info *dinfo = par->targinfo;
3db05fea	51	u_int8_t dscp = ipv6_get_dsfield(ipv6_hdr(skb)) >> XT_DSCP_SHIFT;
a468701d YK	52
a468701d YK	53	if (dscp != dinfo->dscp) {
3db05fea	54	if (!skb_make_writable(skb, sizeof(struct ipv6hdr)))
a468701d YK	55	return NF_DROP;
a468701d YK	56
3db05fea	57	ipv6_change_dsfield(ipv6_hdr(skb), (__u8)(~XT_DSCP_MASK),
a468701d YK	58	dinfo->dscp << XT_DSCP_SHIFT);
	59	}
	60	return XT_CONTINUE;
	61	}
	62
135367b8	63	static int dscp_tg_check(const struct xt_tgchk_param *par)
a468701d	64	{
af5d6dc2	65	const struct xt_DSCP_info *info = par->targinfo;
a468701d	66
af5d6dc2	67	if (info->dscp > XT_DSCP_MAX) {
8bee4bad	68	pr_info("dscp %x out of range\n", info->dscp);
4a5a5c73	69	return -EDOM;
a468701d	70	}
d6b00a53	71	return 0;
a468701d YK	72	}
a468701d YK	73
5c350e5a	74	static unsigned int
4b560b44	75	tos_tg(struct sk_buff skb, const struct xt_action_param par)
5c350e5a	76	{
7eb35586	77	const struct xt_tos_target_info *info = par->targinfo;
5c350e5a JE	78	struct iphdr *iph = ip_hdr(skb);
	79	u_int8_t orig, nv;
	80
	81	orig = ipv4_get_dsfield(iph);
9bb268ed	82	nv = (orig & ~info->tos_mask) ^ info->tos_value;
5c350e5a JE	83
	84	if (orig != nv) {
	85	if (!skb_make_writable(skb, sizeof(struct iphdr)))
	86	return NF_DROP;
	87	iph = ip_hdr(skb);
cdfe8b97	88	ipv4_change_dsfield(iph, 0, nv);
5c350e5a JE	89	}
	90
	91	return XT_CONTINUE;
	92	}
	93
	94	static unsigned int
4b560b44	95	tos_tg6(struct sk_buff skb, const struct xt_action_param par)
5c350e5a	96	{
7eb35586	97	const struct xt_tos_target_info *info = par->targinfo;
5c350e5a JE	98	struct ipv6hdr *iph = ipv6_hdr(skb);
	99	u_int8_t orig, nv;
	100
	101	orig = ipv6_get_dsfield(iph);
1ed2f73d	102	nv = (orig & ~info->tos_mask) ^ info->tos_value;
5c350e5a JE	103
	104	if (orig != nv) {
	105	if (!skb_make_writable(skb, sizeof(struct iphdr)))
	106	return NF_DROP;
	107	iph = ipv6_hdr(skb);
cdfe8b97	108	ipv6_change_dsfield(iph, 0, nv);
5c350e5a JE	109	}
	110
	111	return XT_CONTINUE;
	112	}
	113
d3c5ee6d	114	static struct xt_target dscp_tg_reg[] __read_mostly = {
4470bbc7 PM	115	{
4470bbc7 PM	116	.name = "DSCP",
ee999d8b	117	.family = NFPROTO_IPV4,
d3c5ee6d JE	118	.checkentry = dscp_tg_check,
d3c5ee6d JE	119	.target = dscp_tg,
4470bbc7 PM	120	.targetsize = sizeof(struct xt_DSCP_info),
	121	.table = "mangle",
	122	.me = THIS_MODULE,
	123	},
	124	{
	125	.name = "DSCP",
ee999d8b	126	.family = NFPROTO_IPV6,
d3c5ee6d JE	127	.checkentry = dscp_tg_check,
d3c5ee6d JE	128	.target = dscp_tg6,
4470bbc7 PM	129	.targetsize = sizeof(struct xt_DSCP_info),
	130	.table = "mangle",
	131	.me = THIS_MODULE,
	132	},
5c350e5a JE	133	{
	134	.name = "TOS",
	135	.revision = 1,
ee999d8b	136	.family = NFPROTO_IPV4,
5c350e5a JE	137	.table = "mangle",
	138	.target = tos_tg,
	139	.targetsize = sizeof(struct xt_tos_target_info),
	140	.me = THIS_MODULE,
	141	},
	142	{
	143	.name = "TOS",
	144	.revision = 1,
ee999d8b	145	.family = NFPROTO_IPV6,
5c350e5a JE	146	.table = "mangle",
	147	.target = tos_tg6,
	148	.targetsize = sizeof(struct xt_tos_target_info),
	149	.me = THIS_MODULE,
	150	},
a468701d YK	151	};
a468701d YK	152
d3c5ee6d	153	static int __init dscp_tg_init(void)
a468701d	154	{
d3c5ee6d	155	return xt_register_targets(dscp_tg_reg, ARRAY_SIZE(dscp_tg_reg));
a468701d YK	156	}
a468701d YK	157
d3c5ee6d	158	static void __exit dscp_tg_exit(void)
a468701d	159	{
d3c5ee6d	160	xt_unregister_targets(dscp_tg_reg, ARRAY_SIZE(dscp_tg_reg));
a468701d YK	161	}
a468701d YK	162
d3c5ee6d JE	163	module_init(dscp_tg_init);
d3c5ee6d JE	164	module_exit(dscp_tg_exit);