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

/*
 * TTL modification target for IP tables
 * (C) 2000,2005 by Harald Welte <[email protected]>
 *
 * Hop Limit modification target for ip6tables
 * Maciej Soltysiak <[email protected]>
 *
 * 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 <linux/ipv6.h>
#include <net/checksum.h>

#include <linux/netfilter/x_tables.h>
#include <linux/netfilter_ipv4/ipt_TTL.h>
#include <linux/netfilter_ipv6/ip6t_HL.h>

MODULE_AUTHOR("Harald Welte <[email protected]>");
MODULE_AUTHOR("Maciej Soltysiak <[email protected]>");
MODULE_DESCRIPTION("Xtables: Hoplimit/TTL Limit field modification target");
MODULE_LICENSE("GPL");

static unsigned int
ttl_tg(struct sk_buff *skb, const struct xt_target_param *par)
{
	struct iphdr *iph;
	const struct ipt_TTL_info *info = par->targinfo;
	int new_ttl;

	if (!skb_make_writable(skb, skb->len))
		return NF_DROP;

	iph = ip_hdr(skb);

	switch (info->mode) {
		case IPT_TTL_SET:
			new_ttl = info->ttl;
			break;
		case IPT_TTL_INC:
			new_ttl = iph->ttl + info->ttl;
			if (new_ttl > 255)
				new_ttl = 255;
			break;
		case IPT_TTL_DEC:
			new_ttl = iph->ttl - info->ttl;
			if (new_ttl < 0)
				new_ttl = 0;
			break;
		default:
			new_ttl = iph->ttl;
			break;
	}

	if (new_ttl != iph->ttl) {
		csum_replace2(&iph->check, htons(iph->ttl << 8),
					   htons(new_ttl << 8));
		iph->ttl = new_ttl;
	}

	return XT_CONTINUE;
}

static unsigned int
hl_tg6(struct sk_buff *skb, const struct xt_target_param *par)
{
	struct ipv6hdr *ip6h;
	const struct ip6t_HL_info *info = par->targinfo;
	int new_hl;

	if (!skb_make_writable(skb, skb->len))
		return NF_DROP;

	ip6h = ipv6_hdr(skb);

	switch (info->mode) {
		case IP6T_HL_SET:
			new_hl = info->hop_limit;
			break;
		case IP6T_HL_INC:
			new_hl = ip6h->hop_limit + info->hop_limit;
			if (new_hl > 255)
				new_hl = 255;
			break;
		case IP6T_HL_DEC:
			new_hl = ip6h->hop_limit - info->hop_limit;
			if (new_hl < 0)
				new_hl = 0;
			break;
		default:
			new_hl = ip6h->hop_limit;
			break;
	}

	ip6h->hop_limit = new_hl;

	return XT_CONTINUE;
}

static bool ttl_tg_check(const struct xt_tgchk_param *par)
{
	const struct ipt_TTL_info *info = par->targinfo;

	if (info->mode > IPT_TTL_MAXMODE) {
		printk(KERN_WARNING "ipt_TTL: invalid or unknown Mode %u\n",
			info->mode);
		return false;
	}
	if (info->mode != IPT_TTL_SET && info->ttl == 0)
		return false;
	return true;
}

static bool hl_tg6_check(const struct xt_tgchk_param *par)
{
	const struct ip6t_HL_info *info = par->targinfo;

	if (info->mode > IP6T_HL_MAXMODE) {
		printk(KERN_WARNING "ip6t_HL: invalid or unknown Mode %u\n",
			info->mode);
		return false;
	}
	if (info->mode != IP6T_HL_SET && info->hop_limit == 0) {
		printk(KERN_WARNING "ip6t_HL: increment/decrement doesn't "
			"make sense with value 0\n");
		return false;
	}
	return true;
}

static struct xt_target hl_tg_reg[] __read_mostly = {
	{
		.name       = "TTL",
		.revision   = 0,
		.family     = NFPROTO_IPV4,
		.target     = ttl_tg,
		.targetsize = sizeof(struct ipt_TTL_info),
		.table      = "mangle",
		.checkentry = ttl_tg_check,
		.me         = THIS_MODULE,
	},
	{
		.name       = "HL",
		.revision   = 0,
		.family     = NFPROTO_IPV6,
		.target     = hl_tg6,
		.targetsize = sizeof(struct ip6t_HL_info),
		.table      = "mangle",
		.checkentry = hl_tg6_check,
		.me         = THIS_MODULE,
	},
};

static int __init hl_tg_init(void)
{
	return xt_register_targets(hl_tg_reg, ARRAY_SIZE(hl_tg_reg));
}

static void __exit hl_tg_exit(void)
{
	xt_unregister_targets(hl_tg_reg, ARRAY_SIZE(hl_tg_reg));
}

module_init(hl_tg_init);
module_exit(hl_tg_exit);
MODULE_ALIAS("ipt_TTL");
MODULE_ALIAS("ip6t_HL");
Commit	Line	Data
563d36eb JE	1	/*
	2	* TTL modification target for IP tables
	3	* (C) 2000,2005 by Harald Welte <[email protected]>
	4	*
	5	* Hop Limit modification target for ip6tables
	6	* Maciej Soltysiak <[email protected]>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12
	13	#include <linux/module.h>
	14	#include <linux/skbuff.h>
	15	#include <linux/ip.h>
	16	#include <linux/ipv6.h>
	17	#include <net/checksum.h>
	18
	19	#include <linux/netfilter/x_tables.h>
	20	#include <linux/netfilter_ipv4/ipt_TTL.h>
	21	#include <linux/netfilter_ipv6/ip6t_HL.h>
	22
	23	MODULE_AUTHOR("Harald Welte <[email protected]>");
	24	MODULE_AUTHOR("Maciej Soltysiak <[email protected]>");
	25	MODULE_DESCRIPTION("Xtables: Hoplimit/TTL Limit field modification target");
	26	MODULE_LICENSE("GPL");
	27
	28	static unsigned int
	29	ttl_tg(struct sk_buff skb, const struct xt_target_param par)
	30	{
	31	struct iphdr *iph;
	32	const struct ipt_TTL_info *info = par->targinfo;
	33	int new_ttl;
	34
	35	if (!skb_make_writable(skb, skb->len))
	36	return NF_DROP;
	37
	38	iph = ip_hdr(skb);
	39
	40	switch (info->mode) {
	41	case IPT_TTL_SET:
	42	new_ttl = info->ttl;
	43	break;
	44	case IPT_TTL_INC:
	45	new_ttl = iph->ttl + info->ttl;
	46	if (new_ttl > 255)
	47	new_ttl = 255;
	48	break;
	49	case IPT_TTL_DEC:
	50	new_ttl = iph->ttl - info->ttl;
	51	if (new_ttl < 0)
	52	new_ttl = 0;
	53	break;
	54	default:
	55	new_ttl = iph->ttl;
	56	break;
	57	}
	58
	59	if (new_ttl != iph->ttl) {
	60	csum_replace2(&iph->check, htons(iph->ttl << 8),
	61	htons(new_ttl << 8));
	62	iph->ttl = new_ttl;
	63	}
	64
65	return XT_CONTINUE;
66	}
67
68	static unsigned int
69	hl_tg6(struct sk_buff skb, const struct xt_target_param par)
70	{
71	struct ipv6hdr *ip6h;
72	const struct ip6t_HL_info *info = par->targinfo;
73	int new_hl;
74
75	if (!skb_make_writable(skb, skb->len))
76	return NF_DROP;
77
78	ip6h = ipv6_hdr(skb);
79
80	switch (info->mode) {
81	case IP6T_HL_SET:
82	new_hl = info->hop_limit;
83	break;
84	case IP6T_HL_INC:
85	new_hl = ip6h->hop_limit + info->hop_limit;
86	if (new_hl > 255)
87	new_hl = 255;
88	break;
89	case IP6T_HL_DEC:
90	new_hl = ip6h->hop_limit - info->hop_limit;
91	if (new_hl < 0)
92	new_hl = 0;
93	break;
94	default:
95	new_hl = ip6h->hop_limit;
96	break;
97	}
98
99	ip6h->hop_limit = new_hl;
100
101	return XT_CONTINUE;
102	}
103
104	static bool ttl_tg_check(const struct xt_tgchk_param *par)
105	{
106	const struct ipt_TTL_info *info = par->targinfo;
107
108	if (info->mode > IPT_TTL_MAXMODE) {
109	printk(KERN_WARNING "ipt_TTL: invalid or unknown Mode %u\n",
110	info->mode);
111	return false;
112	}
113	if (info->mode != IPT_TTL_SET && info->ttl == 0)
114	return false;
115	return true;
116	}
117
118	static bool hl_tg6_check(const struct xt_tgchk_param *par)
119	{
120	const struct ip6t_HL_info *info = par->targinfo;
121
122	if (info->mode > IP6T_HL_MAXMODE) {
123	printk(KERN_WARNING "ip6t_HL: invalid or unknown Mode %u\n",
124	info->mode);
125	return false;
126	}
127	if (info->mode != IP6T_HL_SET && info->hop_limit == 0) {
128	printk(KERN_WARNING "ip6t_HL: increment/decrement doesn't "
129	"make sense with value 0\n");
130	return false;
131	}
132	return true;
133	}
134
135	static struct xt_target hl_tg_reg[] __read_mostly = {
136	{
137	.name = "TTL",
138	.revision = 0,
139	.family = NFPROTO_IPV4,
140	.target = ttl_tg,
141	.targetsize = sizeof(struct ipt_TTL_info),
142	.table = "mangle",
143	.checkentry = ttl_tg_check,
144	.me = THIS_MODULE,
145	},
146	{
147	.name = "HL",
148	.revision = 0,
149	.family = NFPROTO_IPV6,
150	.target = hl_tg6,
151	.targetsize = sizeof(struct ip6t_HL_info),
152	.table = "mangle",
153	.checkentry = hl_tg6_check,
154	.me = THIS_MODULE,
155	},
156	};
157
158	static int __init hl_tg_init(void)
159	{
160	return xt_register_targets(hl_tg_reg, ARRAY_SIZE(hl_tg_reg));
161	}
162
163	static void __exit hl_tg_exit(void)
164	{
165	xt_unregister_targets(hl_tg_reg, ARRAY_SIZE(hl_tg_reg));
166	}
167
168	module_init(hl_tg_init);
169	module_exit(hl_tg_exit);
170	MODULE_ALIAS("ipt_TTL");
171	MODULE_ALIAS("ip6t_HL");