1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/module.h>
22#include <linux/slab.h>
23#include <linux/types.h>
24#include <linux/kernel.h>
25#include <linux/string.h>
26#include <linux/errno.h>
27#include <linux/skbuff.h>
28#include <net/netlink.h>
29#include <net/act_api.h>
30#include <net/pkt_cls.h>
31
32#define HTSIZE (PAGE_SIZE/sizeof(struct fw_filter *))
33
34struct fw_head
35{
36 struct fw_filter *ht[HTSIZE];
37 u32 mask;
38};
39
40struct fw_filter
41{
42 struct fw_filter *next;
43 u32 id;
44 struct tcf_result res;
45#ifdef CONFIG_NET_CLS_IND
46 char indev[IFNAMSIZ];
47#endif
48 struct tcf_exts exts;
49};
50
51static const struct tcf_ext_map fw_ext_map = {
52 .action = TCA_FW_ACT,
53 .police = TCA_FW_POLICE
54};
55
56static __inline__ int fw_hash(u32 handle)
57{
58 if (HTSIZE == 4096)
59 return ((handle >> 24) & 0xFFF) ^
60 ((handle >> 12) & 0xFFF) ^
61 (handle & 0xFFF);
62 else if (HTSIZE == 2048)
63 return ((handle >> 22) & 0x7FF) ^
64 ((handle >> 11) & 0x7FF) ^
65 (handle & 0x7FF);
66 else if (HTSIZE == 1024)
67 return ((handle >> 20) & 0x3FF) ^
68 ((handle >> 10) & 0x3FF) ^
69 (handle & 0x3FF);
70 else if (HTSIZE == 512)
71 return (handle >> 27) ^
72 ((handle >> 18) & 0x1FF) ^
73 ((handle >> 9) & 0x1FF) ^
74 (handle & 0x1FF);
75 else if (HTSIZE == 256) {
76 u8 *t = (u8 *) &handle;
77 return t[0] ^ t[1] ^ t[2] ^ t[3];
78 } else
79 return handle & (HTSIZE - 1);
80}
81
82static int fw_classify(struct sk_buff *skb, struct tcf_proto *tp,
83 struct tcf_result *res)
84{
85 struct fw_head *head = (struct fw_head*)tp->root;
86 struct fw_filter *f;
87 int r;
88 u32 id = skb->mark;
89
90 if (head != NULL) {
91 id &= head->mask;
92 for (f=head->ht[fw_hash(id)]; f; f=f->next) {
93 if (f->id == id) {
94 *res = f->res;
95#ifdef CONFIG_NET_CLS_IND
96 if (!tcf_match_indev(skb, f->indev))
97 continue;
98#endif
99 r = tcf_exts_exec(skb, &f->exts, res);
100 if (r < 0)
101 continue;
102
103 return r;
104 }
105 }
106 } else {
107
108 if (id && (TC_H_MAJ(id) == 0 || !(TC_H_MAJ(id^tp->q->handle)))) {
109 res->classid = id;
110 res->class = 0;
111 return 0;
112 }
113 }
114
115 return -1;
116}
117
118static unsigned long fw_get(struct tcf_proto *tp, u32 handle)
119{
120 struct fw_head *head = (struct fw_head*)tp->root;
121 struct fw_filter *f;
122
123 if (head == NULL)
124 return 0;
125
126 for (f=head->ht[fw_hash(handle)]; f; f=f->next) {
127 if (f->id == handle)
128 return (unsigned long)f;
129 }
130 return 0;
131}
132
133static void fw_put(struct tcf_proto *tp, unsigned long f)
134{
135}
136
137static int fw_init(struct tcf_proto *tp)
138{
139 return 0;
140}
141
142static inline void
143fw_delete_filter(struct tcf_proto *tp, struct fw_filter *f)
144{
145 tcf_unbind_filter(tp, &f->res);
146 tcf_exts_destroy(tp, &f->exts);
147 kfree(f);
148}
149
150static void fw_destroy(struct tcf_proto *tp)
151{
152 struct fw_head *head = tp->root;
153 struct fw_filter *f;
154 int h;
155
156 if (head == NULL)
157 return;
158
159 for (h=0; h<HTSIZE; h++) {
160 while ((f=head->ht[h]) != NULL) {
161 head->ht[h] = f->next;
162 fw_delete_filter(tp, f);
163 }
164 }
165 kfree(head);
166}
167
168static int fw_delete(struct tcf_proto *tp, unsigned long arg)
169{
170 struct fw_head *head = (struct fw_head*)tp->root;
171 struct fw_filter *f = (struct fw_filter*)arg;
172 struct fw_filter **fp;
173
174 if (head == NULL || f == NULL)
175 goto out;
176
177 for (fp=&head->ht[fw_hash(f->id)]; *fp; fp = &(*fp)->next) {
178 if (*fp == f) {
179 tcf_tree_lock(tp);
180 *fp = f->next;
181 tcf_tree_unlock(tp);
182 fw_delete_filter(tp, f);
183 return 0;
184 }
185 }
186out:
187 return -EINVAL;
188}
189
190static const struct nla_policy fw_policy[TCA_FW_MAX + 1] = {
191 [TCA_FW_CLASSID] = { .type = NLA_U32 },
192 [TCA_FW_INDEV] = { .type = NLA_STRING, .len = IFNAMSIZ },
193 [TCA_FW_MASK] = { .type = NLA_U32 },
194};
195
196static int
197fw_change_attrs(struct tcf_proto *tp, struct fw_filter *f,
198 struct nlattr **tb, struct nlattr **tca, unsigned long base)
199{
200 struct fw_head *head = (struct fw_head *)tp->root;
201 struct tcf_exts e;
202 u32 mask;
203 int err;
204
205 err = tcf_exts_validate(tp, tb, tca[TCA_RATE], &e, &fw_ext_map);
206 if (err < 0)
207 return err;
208
209 err = -EINVAL;
210 if (tb[TCA_FW_CLASSID]) {
211 f->res.classid = nla_get_u32(tb[TCA_FW_CLASSID]);
212 tcf_bind_filter(tp, &f->res, base);
213 }
214
215#ifdef CONFIG_NET_CLS_IND
216 if (tb[TCA_FW_INDEV]) {
217 err = tcf_change_indev(tp, f->indev, tb[TCA_FW_INDEV]);
218 if (err < 0)
219 goto errout;
220 }
221#endif
222
223 if (tb[TCA_FW_MASK]) {
224 mask = nla_get_u32(tb[TCA_FW_MASK]);
225 if (mask != head->mask)
226 goto errout;
227 } else if (head->mask != 0xFFFFFFFF)
228 goto errout;
229
230 tcf_exts_change(tp, &f->exts, &e);
231
232 return 0;
233errout:
234 tcf_exts_destroy(tp, &e);
235 return err;
236}
237
238static int fw_change(struct tcf_proto *tp, unsigned long base,
239 u32 handle,
240 struct nlattr **tca,
241 unsigned long *arg)
242{
243 struct fw_head *head = (struct fw_head*)tp->root;
244 struct fw_filter *f = (struct fw_filter *) *arg;
245 struct nlattr *opt = tca[TCA_OPTIONS];
246 struct nlattr *tb[TCA_FW_MAX + 1];
247 int err;
248
249 if (!opt)
250 return handle ? -EINVAL : 0;
251
252 err = nla_parse_nested(tb, TCA_FW_MAX, opt, fw_policy);
253 if (err < 0)
254 return err;
255
256 if (f != NULL) {
257 if (f->id != handle && handle)
258 return -EINVAL;
259 return fw_change_attrs(tp, f, tb, tca, base);
260 }
261
262 if (!handle)
263 return -EINVAL;
264
265 if (head == NULL) {
266 u32 mask = 0xFFFFFFFF;
267 if (tb[TCA_FW_MASK])
268 mask = nla_get_u32(tb[TCA_FW_MASK]);
269
270 head = kzalloc(sizeof(struct fw_head), GFP_KERNEL);
271 if (head == NULL)
272 return -ENOBUFS;
273 head->mask = mask;
274
275 tcf_tree_lock(tp);
276 tp->root = head;
277 tcf_tree_unlock(tp);
278 }
279
280 f = kzalloc(sizeof(struct fw_filter), GFP_KERNEL);
281 if (f == NULL)
282 return -ENOBUFS;
283
284 f->id = handle;
285
286 err = fw_change_attrs(tp, f, tb, tca, base);
287 if (err < 0)
288 goto errout;
289
290 f->next = head->ht[fw_hash(handle)];
291 tcf_tree_lock(tp);
292 head->ht[fw_hash(handle)] = f;
293 tcf_tree_unlock(tp);
294
295 *arg = (unsigned long)f;
296 return 0;
297
298errout:
299 kfree(f);
300 return err;
301}
302
303static void fw_walk(struct tcf_proto *tp, struct tcf_walker *arg)
304{
305 struct fw_head *head = (struct fw_head*)tp->root;
306 int h;
307
308 if (head == NULL)
309 arg->stop = 1;
310
311 if (arg->stop)
312 return;
313
314 for (h = 0; h < HTSIZE; h++) {
315 struct fw_filter *f;
316
317 for (f = head->ht[h]; f; f = f->next) {
318 if (arg->count < arg->skip) {
319 arg->count++;
320 continue;
321 }
322 if (arg->fn(tp, (unsigned long)f, arg) < 0) {
323 arg->stop = 1;
324 return;
325 }
326 arg->count++;
327 }
328 }
329}
330
331static int fw_dump(struct tcf_proto *tp, unsigned long fh,
332 struct sk_buff *skb, struct tcmsg *t)
333{
334 struct fw_head *head = (struct fw_head *)tp->root;
335 struct fw_filter *f = (struct fw_filter*)fh;
336 unsigned char *b = skb_tail_pointer(skb);
337 struct nlattr *nest;
338
339 if (f == NULL)
340 return skb->len;
341
342 t->tcm_handle = f->id;
343
344 if (!f->res.classid && !tcf_exts_is_available(&f->exts))
345 return skb->len;
346
347 nest = nla_nest_start(skb, TCA_OPTIONS);
348 if (nest == NULL)
349 goto nla_put_failure;
350
351 if (f->res.classid)
352 NLA_PUT_U32(skb, TCA_FW_CLASSID, f->res.classid);
353#ifdef CONFIG_NET_CLS_IND
354 if (strlen(f->indev))
355 NLA_PUT_STRING(skb, TCA_FW_INDEV, f->indev);
356#endif
357 if (head->mask != 0xFFFFFFFF)
358 NLA_PUT_U32(skb, TCA_FW_MASK, head->mask);
359
360 if (tcf_exts_dump(skb, &f->exts, &fw_ext_map) < 0)
361 goto nla_put_failure;
362
363 nla_nest_end(skb, nest);
364
365 if (tcf_exts_dump_stats(skb, &f->exts, &fw_ext_map) < 0)
366 goto nla_put_failure;
367
368 return skb->len;
369
370nla_put_failure:
371 nlmsg_trim(skb, b);
372 return -1;
373}
374
375static struct tcf_proto_ops cls_fw_ops __read_mostly = {
376 .kind = "fw",
377 .classify = fw_classify,
378 .init = fw_init,
379 .destroy = fw_destroy,
380 .get = fw_get,
381 .put = fw_put,
382 .change = fw_change,
383 .delete = fw_delete,
384 .walk = fw_walk,
385 .dump = fw_dump,
386 .owner = THIS_MODULE,
387};
388
389static int __init init_fw(void)
390{
391 return register_tcf_proto_ops(&cls_fw_ops);
392}
393
394static void __exit exit_fw(void)
395{
396 unregister_tcf_proto_ops(&cls_fw_ops);
397}
398
399module_init(init_fw)
400module_exit(exit_fw)
401MODULE_LICENSE("GPL");
402
