1/*
2 * net/sched/pedit.c	Generic packet editor
3 *
4 *		This program is free software; you can redistribute it and/or
5 *		modify it under the terms of the GNU General Public License
6 *		as published by the Free Software Foundation; either version
7 *		2 of the License, or (at your option) any later version.
8 *
9 * Authors:	Jamal Hadi Salim (2002-4)
10 */
11
12#include <linux/types.h>
13#include <linux/kernel.h>
14#include <linux/string.h>
15#include <linux/errno.h>
16#include <linux/skbuff.h>
17#include <linux/rtnetlink.h>
18#include <linux/module.h>
19#include <linux/init.h>
20#include <linux/slab.h>
21#include <net/netlink.h>
22#include <net/pkt_sched.h>
23#include <linux/tc_act/tc_pedit.h>
24#include <net/tc_act/tc_pedit.h>
25
26#define PEDIT_TAB_MASK	15
27
28static const struct nla_policy pedit_policy[TCA_PEDIT_MAX + 1] = {
29	[TCA_PEDIT_PARMS]	= { .len = sizeof(struct tc_pedit) },
30};
31
32static int tcf_pedit_init(struct net *net, struct nlattr *nla,
33			  struct nlattr *est, struct tc_action *a,
34			  int ovr, int bind)
35{
36	struct nlattr *tb[TCA_PEDIT_MAX + 1];
37	struct tc_pedit *parm;
38	int ret = 0, err;
39	struct tcf_pedit *p;
40	struct tc_pedit_key *keys = NULL;
41	int ksize;
42
43	if (nla == NULL)
44		return -EINVAL;
45
46	err = nla_parse_nested(tb, TCA_PEDIT_MAX, nla, pedit_policy);
47	if (err < 0)
48		return err;
49
50	if (tb[TCA_PEDIT_PARMS] == NULL)
51		return -EINVAL;
52	parm = nla_data(tb[TCA_PEDIT_PARMS]);
53	ksize = parm->nkeys * sizeof(struct tc_pedit_key);
54	if (nla_len(tb[TCA_PEDIT_PARMS]) < sizeof(*parm) + ksize)
55		return -EINVAL;
56
57	if (!tcf_hash_check(parm->index, a, bind)) {
58		if (!parm->nkeys)
59			return -EINVAL;
60		ret = tcf_hash_create(parm->index, est, a, sizeof(*p), bind);
61		if (ret)
62			return ret;
63		p = to_pedit(a);
64		keys = kmalloc(ksize, GFP_KERNEL);
65		if (keys == NULL) {
66			tcf_hash_cleanup(a, est);
67			return -ENOMEM;
68		}
69		ret = ACT_P_CREATED;
70	} else {
71		p = to_pedit(a);
72		tcf_hash_release(a, bind);
73		if (bind)
74			return 0;
75		if (!ovr)
76			return -EEXIST;
77
78		if (p->tcfp_nkeys && p->tcfp_nkeys != parm->nkeys) {
79			keys = kmalloc(ksize, GFP_KERNEL);
80			if (keys == NULL)
81				return -ENOMEM;
82		}
83	}
84
85	spin_lock_bh(&p->tcf_lock);
86	p->tcfp_flags = parm->flags;
87	p->tcf_action = parm->action;
88	if (keys) {
89		kfree(p->tcfp_keys);
90		p->tcfp_keys = keys;
91		p->tcfp_nkeys = parm->nkeys;
92	}
93	memcpy(p->tcfp_keys, parm->keys, ksize);
94	spin_unlock_bh(&p->tcf_lock);
95	if (ret == ACT_P_CREATED)
96		tcf_hash_insert(a);
97	return ret;
98}
99
100static void tcf_pedit_cleanup(struct tc_action *a, int bind)
101{
102	struct tcf_pedit *p = a->priv;
103	struct tc_pedit_key *keys = p->tcfp_keys;
104	kfree(keys);
105}
106
107static int tcf_pedit(struct sk_buff *skb, const struct tc_action *a,
108		     struct tcf_result *res)
109{
110	struct tcf_pedit *p = a->priv;
111	int i, munged = 0;
112	unsigned int off;
113
114	if (skb_unclone(skb, GFP_ATOMIC))
115		return p->tcf_action;
116
117	off = skb_network_offset(skb);
118
119	spin_lock(&p->tcf_lock);
120
121	p->tcf_tm.lastuse = jiffies;
122
123	if (p->tcfp_nkeys > 0) {
124		struct tc_pedit_key *tkey = p->tcfp_keys;
125
126		for (i = p->tcfp_nkeys; i > 0; i--, tkey++) {
127			u32 *ptr, _data;
128			int offset = tkey->off;
129
130			if (tkey->offmask) {
131				char *d, _d;
132
133				d = skb_header_pointer(skb, off + tkey->at, 1,
134						       &_d);
135				if (!d)
136					goto bad;
137				offset += (*d & tkey->offmask) >> tkey->shift;
138			}
139
140			if (offset % 4) {
141				pr_info("tc filter pedit"
142					" offset must be on 32 bit boundaries\n");
143				goto bad;
144			}
145			if (offset > 0 && offset > skb->len) {
146				pr_info("tc filter pedit"
147					" offset %d can't exceed pkt length %d\n",
148				       offset, skb->len);
149				goto bad;
150			}
151
152			ptr = skb_header_pointer(skb, off + offset, 4, &_data);
153			if (!ptr)
154				goto bad;
155			/* just do it, baby */
156			*ptr = ((*ptr & tkey->mask) ^ tkey->val);
157			if (ptr == &_data)
158				skb_store_bits(skb, off + offset, ptr, 4);
159			munged++;
160		}
161
162		if (munged)
163			skb->tc_verd = SET_TC_MUNGED(skb->tc_verd);
164		goto done;
165	} else
166		WARN(1, "pedit BUG: index %d\n", p->tcf_index);
167
168bad:
169	p->tcf_qstats.overlimits++;
170done:
171	bstats_update(&p->tcf_bstats, skb);
172	spin_unlock(&p->tcf_lock);
173	return p->tcf_action;
174}
175
176static int tcf_pedit_dump(struct sk_buff *skb, struct tc_action *a,
177			  int bind, int ref)
178{
179	unsigned char *b = skb_tail_pointer(skb);
180	struct tcf_pedit *p = a->priv;
181	struct tc_pedit *opt;
182	struct tcf_t t;
183	int s;
184
185	s = sizeof(*opt) + p->tcfp_nkeys * sizeof(struct tc_pedit_key);
186
187	/* netlink spinlocks held above us - must use ATOMIC */
188	opt = kzalloc(s, GFP_ATOMIC);
189	if (unlikely(!opt))
190		return -ENOBUFS;
191
192	memcpy(opt->keys, p->tcfp_keys,
193	       p->tcfp_nkeys * sizeof(struct tc_pedit_key));
194	opt->index = p->tcf_index;
195	opt->nkeys = p->tcfp_nkeys;
196	opt->flags = p->tcfp_flags;
197	opt->action = p->tcf_action;
198	opt->refcnt = p->tcf_refcnt - ref;
199	opt->bindcnt = p->tcf_bindcnt - bind;
200
201	if (nla_put(skb, TCA_PEDIT_PARMS, s, opt))
202		goto nla_put_failure;
203	t.install = jiffies_to_clock_t(jiffies - p->tcf_tm.install);
204	t.lastuse = jiffies_to_clock_t(jiffies - p->tcf_tm.lastuse);
205	t.expires = jiffies_to_clock_t(p->tcf_tm.expires);
206	if (nla_put(skb, TCA_PEDIT_TM, sizeof(t), &t))
207		goto nla_put_failure;
208	kfree(opt);
209	return skb->len;
210
211nla_put_failure:
212	nlmsg_trim(skb, b);
213	kfree(opt);
214	return -1;
215}
216
217static struct tc_action_ops act_pedit_ops = {
218	.kind		=	"pedit",
219	.type		=	TCA_ACT_PEDIT,
220	.owner		=	THIS_MODULE,
221	.act		=	tcf_pedit,
222	.dump		=	tcf_pedit_dump,
223	.cleanup	=	tcf_pedit_cleanup,
224	.init		=	tcf_pedit_init,
225};
226
227MODULE_AUTHOR("Jamal Hadi Salim(2002-4)");
228MODULE_DESCRIPTION("Generic Packet Editor actions");
229MODULE_LICENSE("GPL");
230
231static int __init pedit_init_module(void)
232{
233	return tcf_register_action(&act_pedit_ops, PEDIT_TAB_MASK);
234}
235
236static void __exit pedit_cleanup_module(void)
237{
238	tcf_unregister_action(&act_pedit_ops);
239}
240
241module_init(pedit_init_module);
242module_exit(pedit_cleanup_module);
243
244