]> git.proxmox.com Git - mirror_iproute2.git/blob - tc/f_u32.c
projects / mirror_iproute2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/shemminger...
[mirror_iproute2.git] / tc / f_u32.c
1 /*
2 * q_u32.c U32 filter.
3 *
4 * This program is free software; you can u32istribute 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: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 * Match mark added by Catalin(ux aka Dino) BOIE <catab at umbrella.ro> [5 nov 2004]
11 *
12 */
13
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <unistd.h>
17 #include <syslog.h>
18 #include <fcntl.h>
19 #include <sys/socket.h>
20 #include <netinet/in.h>
21 #include <arpa/inet.h>
22 #include <string.h>
23 #include <linux/if.h>
24 #include <linux/if_ether.h>
25
26 #include "utils.h"
27 #include "tc_util.h"
28
29 extern int show_pretty;
30
31 static void explain(void)
32 {
33 fprintf(stderr, "Usage: ... u32 [ match SELECTOR ... ] [ link HTID ]"
34 " [ classid CLASSID ]\n");
35 fprintf(stderr, " [ action ACTION_SPEC ]"
36 " [ offset OFFSET_SPEC ]\n");
37 fprintf(stderr, " [ ht HTID ] [ hashkey HASHKEY_SPEC ]\n");
38 fprintf(stderr, " [ sample SAMPLE ]\n");
39 fprintf(stderr, "or u32 divisor DIVISOR\n");
40 fprintf(stderr, "\n");
41 fprintf(stderr, "Where: SELECTOR := SAMPLE SAMPLE ...\n");
42 fprintf(stderr, " SAMPLE := { ip | ip6 | udp | tcp | icmp |"
43 " u{32|16|8} | mark } SAMPLE_ARGS [divisor DIVISOR]\n");
44 fprintf(stderr, " FILTERID := X:Y:Z\n");
45 fprintf(stderr, "\nNOTE: CLASSID is parsed at hexadecimal input.\n");
46 }
47
48 static int get_u32_handle(__u32 *handle, const char *str)
49 {
50 __u32 htid=0, hash=0, nodeid=0;
51 char *tmp = strchr(str, ':');
52
53 if (tmp == NULL) {
54 if (memcmp("0x", str, 2) == 0)
55 return get_u32(handle, str, 16);
56 return -1;
57 }
58 htid = strtoul(str, &tmp, 16);
59 if (tmp == str && *str != ':' && *str != 0)
60 return -1;
61 if (htid>=0x1000)
62 return -1;
63 if (*tmp) {
64 str = tmp + 1;
65 hash = strtoul(str, &tmp, 16);
66 if (tmp == str && *str != ':' && *str != 0)
67 return -1;
68 if (hash>=0x100)
69 return -1;
70 if (*tmp) {
71 str = tmp + 1;
72 nodeid = strtoul(str, &tmp, 16);
73 if (tmp == str && *str != 0)
74 return -1;
75 if (nodeid>=0x1000)
76 return -1;
77 }
78 }
79 *handle = (htid<<20)|(hash<<12)|nodeid;
80 return 0;
81 }
82
83 static char * sprint_u32_handle(__u32 handle, char *buf)
84 {
85 int bsize = SPRINT_BSIZE-1;
86 __u32 htid = TC_U32_HTID(handle);
87 __u32 hash = TC_U32_HASH(handle);
88 __u32 nodeid = TC_U32_NODE(handle);
89 char *b = buf;
90
91 if (handle == 0) {
92 snprintf(b, bsize, "none");
93 return b;
94 }
95 if (htid) {
96 int l = snprintf(b, bsize, "%x:", htid>>20);
97 bsize -= l;
98 b += l;
99 }
100 if (nodeid|hash) {
101 if (hash) {
102 int l = snprintf(b, bsize, "%x", hash);
103 bsize -= l;
104 b += l;
105 }
106 if (nodeid) {
107 int l = snprintf(b, bsize, ":%x", nodeid);
108 bsize -= l;
109 b += l;
110 }
111 }
112 if (show_raw)
113 snprintf(b, bsize, "[%08x] ", handle);
114 return buf;
115 }
116
117 static int pack_key(struct tc_u32_sel *sel, __u32 key, __u32 mask,
118 int off, int offmask)
119 {
120 int i;
121 int hwm = sel->nkeys;
122
123 key &= mask;
124
125 for (i=0; i<hwm; i++) {
126 if (sel->keys[i].off == off && sel->keys[i].offmask == offmask) {
127 __u32 intersect = mask & sel->keys[i].mask;
128
129 if ((key ^ sel->keys[i].val) & intersect)
130 return -1;
131 sel->keys[i].val |= key;
132 sel->keys[i].mask |= mask;
133 return 0;
134 }
135 }
136
137 if (hwm >= 128)
138 return -1;
139 if (off % 4)
140 return -1;
141 sel->keys[hwm].val = key;
142 sel->keys[hwm].mask = mask;
143 sel->keys[hwm].off = off;
144 sel->keys[hwm].offmask = offmask;
145 sel->nkeys++;
146 return 0;
147 }
148
149 static int pack_key32(struct tc_u32_sel *sel, __u32 key, __u32 mask,
150 int off, int offmask)
151 {
152 key = htonl(key);
153 mask = htonl(mask);
154 return pack_key(sel, key, mask, off, offmask);
155 }
156
157 static int pack_key16(struct tc_u32_sel *sel, __u32 key, __u32 mask,
158 int off, int offmask)
159 {
160 if (key > 0xFFFF || mask > 0xFFFF)
161 return -1;
162
163 if ((off & 3) == 0) {
164 key <<= 16;
165 mask <<= 16;
166 }
167 off &= ~3;
168 key = htonl(key);
169 mask = htonl(mask);
170
171 return pack_key(sel, key, mask, off, offmask);
172 }
173
174 static int pack_key8(struct tc_u32_sel *sel, __u32 key, __u32 mask, int off, int offmask)
175 {
176 if (key > 0xFF || mask > 0xFF)
177 return -1;
178
179 if ((off & 3) == 0) {
180 key <<= 24;
181 mask <<= 24;
182 } else if ((off & 3) == 1) {
183 key <<= 16;
184 mask <<= 16;
185 } else if ((off & 3) == 2) {
186 key <<= 8;
187 mask <<= 8;
188 }
189 off &= ~3;
190 key = htonl(key);
191 mask = htonl(mask);
192
193 return pack_key(sel, key, mask, off, offmask);
194 }
195
196
197 static int parse_at(int *argc_p, char ***argv_p, int *off, int *offmask)
198 {
199 int argc = *argc_p;
200 char **argv = *argv_p;
201 char *p = *argv;
202
203 if (argc <= 0)
204 return -1;
205
206 if (strlen(p) > strlen("nexthdr+") &&
207 memcmp(p, "nexthdr+", strlen("nexthdr+")) == 0) {
208 *offmask = -1;
209 p += strlen("nexthdr+");
210 } else if (matches(*argv, "nexthdr+") == 0) {
211 NEXT_ARG();
212 *offmask = -1;
213 p = *argv;
214 }
215
216 if (get_integer(off, p, 0))
217 return -1;
218 argc--; argv++;
219
220 *argc_p = argc;
221 *argv_p = argv;
222 return 0;
223 }
224
225
226 static int parse_u32(int *argc_p, char ***argv_p, struct tc_u32_sel *sel,
227 int off, int offmask)
228 {
229 int res = -1;
230 int argc = *argc_p;
231 char **argv = *argv_p;
232 __u32 key;
233 __u32 mask;
234
235 if (argc < 2)
236 return -1;
237
238 if (get_u32(&key, *argv, 0))
239 return -1;
240 argc--; argv++;
241
242 if (get_u32(&mask, *argv, 16))
243 return -1;
244 argc--; argv++;
245
246 if (argc > 0 && strcmp(argv[0], "at") == 0) {
247 NEXT_ARG();
248 if (parse_at(&argc, &argv, &off, &offmask))
249 return -1;
250 }
251
252 res = pack_key32(sel, key, mask, off, offmask);
253 *argc_p = argc;
254 *argv_p = argv;
255 return res;
256 }
257
258 static int parse_u16(int *argc_p, char ***argv_p, struct tc_u32_sel *sel,
259 int off, int offmask)
260 {
261 int res = -1;
262 int argc = *argc_p;
263 char **argv = *argv_p;
264 __u32 key;
265 __u32 mask;
266
267 if (argc < 2)
268 return -1;
269
270 if (get_u32(&key, *argv, 0))
271 return -1;
272 argc--; argv++;
273
274 if (get_u32(&mask, *argv, 16))
275 return -1;
276 argc--; argv++;
277
278 if (argc > 0 && strcmp(argv[0], "at") == 0) {
279 NEXT_ARG();
280 if (parse_at(&argc, &argv, &off, &offmask))
281 return -1;
282 }
283 res = pack_key16(sel, key, mask, off, offmask);
284 *argc_p = argc;
285 *argv_p = argv;
286 return res;
287 }
288
289 static int parse_u8(int *argc_p, char ***argv_p, struct tc_u32_sel *sel,
290 int off, int offmask)
291 {
292 int res = -1;
293 int argc = *argc_p;
294 char **argv = *argv_p;
295 __u32 key;
296 __u32 mask;
297
298 if (argc < 2)
299 return -1;
300
301 if (get_u32(&key, *argv, 0))
302 return -1;
303 argc--; argv++;
304
305 if (get_u32(&mask, *argv, 16))
306 return -1;
307 argc--; argv++;
308
309 if (key > 0xFF || mask > 0xFF)
310 return -1;
311
312 if (argc > 0 && strcmp(argv[0], "at") == 0) {
313 NEXT_ARG();
314 if (parse_at(&argc, &argv, &off, &offmask))
315 return -1;
316 }
317
318 res = pack_key8(sel, key, mask, off, offmask);
319 *argc_p = argc;
320 *argv_p = argv;
321 return res;
322 }
323
324 static int parse_ip_addr(int *argc_p, char ***argv_p, struct tc_u32_sel *sel,
325 int off)
326 {
327 int res = -1;
328 int argc = *argc_p;
329 char **argv = *argv_p;
330 inet_prefix addr;
331 __u32 mask;
332 int offmask = 0;
333
334 if (argc < 1)
335 return -1;
336
337 if (get_prefix_1(&addr, *argv, AF_INET))
338 return -1;
339 argc--; argv++;
340
341 if (argc > 0 && strcmp(argv[0], "at") == 0) {
342 NEXT_ARG();
343 if (parse_at(&argc, &argv, &off, &offmask))
344 return -1;
345 }
346
347 mask = 0;
348 if (addr.bitlen)
349 mask = htonl(0xFFFFFFFF << (32 - addr.bitlen));
350 if (pack_key(sel, addr.data[0], mask, off, offmask) < 0)
351 return -1;
352 res = 0;
353
354 *argc_p = argc;
355 *argv_p = argv;
356 return res;
357 }
358
359 static int parse_ip6_addr(int *argc_p, char ***argv_p,
360 struct tc_u32_sel *sel, int off)
361 {
362 int res = -1;
363 int argc = *argc_p;
364 char **argv = *argv_p;
365 int plen = 128;
366 int i;
367 inet_prefix addr;
368 int offmask = 0;
369
370 if (argc < 1)
371 return -1;
372
373 if (get_prefix_1(&addr, *argv, AF_INET6))
374 return -1;
375 argc--; argv++;
376
377 if (argc > 0 && strcmp(argv[0], "at") == 0) {
378 NEXT_ARG();
379 if (parse_at(&argc, &argv, &off, &offmask))
380 return -1;
381 }
382
383 plen = addr.bitlen;
384 for (i = 0; i < plen; i += 32) {
385 // if (((i + 31) & ~0x1F) <= plen) {
386 if (i + 31 <= plen) {
387 res = pack_key(sel, addr.data[i / 32],
388 0xFFFFFFFF, off + 4 * (i / 32), offmask);
389 if (res < 0)
390 return -1;
391 } else if (i < plen) {
392 __u32 mask = htonl(0xFFFFFFFF << (32 - (plen - i)));
393 res = pack_key(sel, addr.data[i / 32],
394 mask, off + 4 * (i / 32), offmask);
395 if (res < 0)
396 return -1;
397 }
398 }
399 res = 0;
400
401 *argc_p = argc;
402 *argv_p = argv;
403 return res;
404 }
405
406 static int parse_ip6_class(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
407 {
408 int res = -1;
409 int argc = *argc_p;
410 char **argv = *argv_p;
411 __u32 key;
412 __u32 mask;
413 int off = 0;
414 int offmask = 0;
415
416 if (argc < 2)
417 return -1;
418
419 if (get_u32(&key, *argv, 0))
420 return -1;
421 argc--; argv++;
422
423 if (get_u32(&mask, *argv, 16))
424 return -1;
425 argc--; argv++;
426
427 if (key > 0xFF || mask > 0xFF)
428 return -1;
429
430 key <<= 20;
431 mask <<= 20;
432 key = htonl(key);
433 mask = htonl(mask);
434
435 res = pack_key(sel, key, mask, off, offmask);
436 if (res < 0)
437 return -1;
438
439 *argc_p = argc;
440 *argv_p = argv;
441 return 0;
442 }
443
444 static int parse_ether_addr(int *argc_p, char ***argv_p,
445 struct tc_u32_sel *sel, int off)
446 {
447 int res = -1;
448 int argc = *argc_p;
449 char **argv = *argv_p;
450 __u8 addr[6];
451 int offmask = 0;
452 int i;
453
454 if (argc < 1)
455 return -1;
456
457 if (sscanf(*argv, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
458 addr + 0, addr + 1, addr + 2,
459 addr + 3, addr + 4, addr + 5) != 6) {
460 fprintf(stderr, "parse_ether_addr: improperly formed address '%s'\n",
461 *argv);
462 return -1;
463 }
464
465 argc--; argv++;
466 if (argc > 0 && strcmp(argv[0], "at") == 0) {
467 NEXT_ARG();
468 if (parse_at(&argc, &argv, &off, &offmask))
469 return -1;
470 }
471
472 for (i = 0; i < 6; i++) {
473 res = pack_key8(sel, addr[i], 0xFF, off + i, offmask);
474 if (res < 0)
475 return -1;
476 }
477
478 *argc_p = argc;
479 *argv_p = argv;
480 return res;
481 }
482
483 static int parse_ip(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
484 {
485 int res = -1;
486 int argc = *argc_p;
487 char **argv = *argv_p;
488
489 if (argc < 2)
490 return -1;
491
492 if (strcmp(*argv, "src") == 0) {
493 NEXT_ARG();
494 res = parse_ip_addr(&argc, &argv, sel, 12);
495 } else if (strcmp(*argv, "dst") == 0) {
496 NEXT_ARG();
497 res = parse_ip_addr(&argc, &argv, sel, 16);
498 } else if (strcmp(*argv, "tos") == 0 ||
499 matches(*argv, "dsfield") == 0 ||
500 matches(*argv, "precedence") == 0) {
501 NEXT_ARG();
502 res = parse_u8(&argc, &argv, sel, 1, 0);
503 } else if (strcmp(*argv, "ihl") == 0) {
504 NEXT_ARG();
505 res = parse_u8(&argc, &argv, sel, 0, 0);
506 } else if (strcmp(*argv, "protocol") == 0) {
507 NEXT_ARG();
508 res = parse_u8(&argc, &argv, sel, 9, 0);
509 } else if (strcmp(*argv, "nofrag") == 0) {
510 argc--; argv++;
511 res = pack_key16(sel, 0, 0x3FFF, 6, 0);
512 } else if (strcmp(*argv, "firstfrag") == 0) {
513 argc--; argv++;
514 res = pack_key16(sel, 0x2000, 0x3FFF, 6, 0);
515 } else if (strcmp(*argv, "df") == 0) {
516 argc--; argv++;
517 res = pack_key16(sel, 0x4000, 0x4000, 6, 0);
518 } else if (strcmp(*argv, "mf") == 0) {
519 argc--; argv++;
520 res = pack_key16(sel, 0x2000, 0x2000, 6, 0);
521 } else if (strcmp(*argv, "dport") == 0) {
522 NEXT_ARG();
523 res = parse_u16(&argc, &argv, sel, 22, 0);
524 } else if (strcmp(*argv, "sport") == 0) {
525 NEXT_ARG();
526 res = parse_u16(&argc, &argv, sel, 20, 0);
527 } else if (strcmp(*argv, "icmp_type") == 0) {
528 NEXT_ARG();
529 res = parse_u8(&argc, &argv, sel, 20, 0);
530 } else if (strcmp(*argv, "icmp_code") == 0) {
531 NEXT_ARG();
532 res = parse_u8(&argc, &argv, sel, 21, 0);
533 } else
534 return -1;
535
536 *argc_p = argc;
537 *argv_p = argv;
538 return res;
539 }
540
541 static int parse_ip6(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
542 {
543 int res = -1;
544 int argc = *argc_p;
545 char **argv = *argv_p;
546
547 if (argc < 2)
548 return -1;
549
550 if (strcmp(*argv, "src") == 0) {
551 NEXT_ARG();
552 res = parse_ip6_addr(&argc, &argv, sel, 8);
553 } else if (strcmp(*argv, "dst") == 0) {
554 NEXT_ARG();
555 res = parse_ip6_addr(&argc, &argv, sel, 24);
556 } else if (strcmp(*argv, "priority") == 0) {
557 NEXT_ARG();
558 res = parse_ip6_class(&argc, &argv, sel);
559 } else if (strcmp(*argv, "protocol") == 0) {
560 NEXT_ARG();
561 res = parse_u8(&argc, &argv, sel, 6, 0);
562 } else if (strcmp(*argv, "flowlabel") == 0) {
563 NEXT_ARG();
564 res = parse_u32(&argc, &argv, sel, 0, 0);
565 } else if (strcmp(*argv, "dport") == 0) {
566 NEXT_ARG();
567 res = parse_u16(&argc, &argv, sel, 42, 0);
568 } else if (strcmp(*argv, "sport") == 0) {
569 NEXT_ARG();
570 res = parse_u16(&argc, &argv, sel, 40, 0);
571 } else if (strcmp(*argv, "icmp_type") == 0) {
572 NEXT_ARG();
573 res = parse_u8(&argc, &argv, sel, 40, 0);
574 } else if (strcmp(*argv, "icmp_code") == 0) {
575 NEXT_ARG();
576 res = parse_u8(&argc, &argv, sel, 41, 1);
577 } else
578 return -1;
579
580 *argc_p = argc;
581 *argv_p = argv;
582 return res;
583 }
584
585 static int parse_ether(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
586 {
587 int res = -1;
588 int argc = *argc_p;
589 char **argv = *argv_p;
590
591 if (argc < 2)
592 return -1;
593
594 if (strcmp(*argv, "src") == 0) {
595 NEXT_ARG();
596 res = parse_ether_addr(&argc, &argv, sel, -8);
597 } else if (strcmp(*argv, "dst") == 0) {
598 NEXT_ARG();
599 res = parse_ether_addr(&argc, &argv, sel, -14);
600 } else {
601 fprintf(stderr, "Unknown match: ether %s\n", *argv);
602 return -1;
603 }
604
605 *argc_p = argc;
606 *argv_p = argv;
607 return res;
608 }
609
610 #define parse_tcp parse_udp
611 static int parse_udp(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
612 {
613 int res = -1;
614 int argc = *argc_p;
615 char **argv = *argv_p;
616
617 if (argc < 2)
618 return -1;
619
620 if (strcmp(*argv, "src") == 0) {
621 NEXT_ARG();
622 res = parse_u16(&argc, &argv, sel, 0, -1);
623 } else if (strcmp(*argv, "dst") == 0) {
624 NEXT_ARG();
625 res = parse_u16(&argc, &argv, sel, 2, -1);
626 } else
627 return -1;
628
629 *argc_p = argc;
630 *argv_p = argv;
631 return res;
632 }
633
634
635 static int parse_icmp(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
636 {
637 int res = -1;
638 int argc = *argc_p;
639 char **argv = *argv_p;
640
641 if (argc < 2)
642 return -1;
643
644 if (strcmp(*argv, "type") == 0) {
645 NEXT_ARG();
646 res = parse_u8(&argc, &argv, sel, 0, -1);
647 } else if (strcmp(*argv, "code") == 0) {
648 NEXT_ARG();
649 res = parse_u8(&argc, &argv, sel, 1, -1);
650 } else
651 return -1;
652
653 *argc_p = argc;
654 *argv_p = argv;
655 return res;
656 }
657
658 static int parse_mark(int *argc_p, char ***argv_p, struct nlmsghdr *n)
659 {
660 int res = -1;
661 int argc = *argc_p;
662 char **argv = *argv_p;
663 struct tc_u32_mark mark;
664
665 if (argc <= 1)
666 return -1;
667
668 if (get_u32(&mark.val, *argv, 0)) {
669 fprintf(stderr, "Illegal \"mark\" value\n");
670 return -1;
671 }
672 NEXT_ARG();
673
674 if (get_u32(&mark.mask, *argv, 0)) {
675 fprintf(stderr, "Illegal \"mark\" mask\n");
676 return -1;
677 }
678 NEXT_ARG();
679
680 if ((mark.val & mark.mask) != mark.val) {
681 fprintf(stderr, "Illegal \"mark\" (impossible combination)\n");
682 return -1;
683 }
684
685 addattr_l(n, MAX_MSG, TCA_U32_MARK, &mark, sizeof(mark));
686 res = 0;
687
688 *argc_p = argc;
689 *argv_p = argv;
690 return res;
691 }
692
693 static int parse_selector(int *argc_p, char ***argv_p,
694 struct tc_u32_sel *sel, struct nlmsghdr *n)
695 {
696 int argc = *argc_p;
697 char **argv = *argv_p;
698 int res = -1;
699
700 if (argc <= 0)
701 return -1;
702
703 if (matches(*argv, "u32") == 0) {
704 NEXT_ARG();
705 res = parse_u32(&argc, &argv, sel, 0, 0);
706 } else if (matches(*argv, "u16") == 0) {
707 NEXT_ARG();
708 res = parse_u16(&argc, &argv, sel, 0, 0);
709 } else if (matches(*argv, "u8") == 0) {
710 NEXT_ARG();
711 res = parse_u8(&argc, &argv, sel, 0, 0);
712 } else if (matches(*argv, "ip") == 0) {
713 NEXT_ARG();
714 res = parse_ip(&argc, &argv, sel);
715 } else if (matches(*argv, "ip6") == 0) {
716 NEXT_ARG();
717 res = parse_ip6(&argc, &argv, sel);
718 } else if (matches(*argv, "udp") == 0) {
719 NEXT_ARG();
720 res = parse_udp(&argc, &argv, sel);
721 } else if (matches(*argv, "tcp") == 0) {
722 NEXT_ARG();
723 res = parse_tcp(&argc, &argv, sel);
724 } else if (matches(*argv, "icmp") == 0) {
725 NEXT_ARG();
726 res = parse_icmp(&argc, &argv, sel);
727 } else if (matches(*argv, "mark") == 0) {
728 NEXT_ARG();
729 res = parse_mark(&argc, &argv, n);
730 } else if (matches(*argv, "ether") == 0) {
731 NEXT_ARG();
732 res = parse_ether(&argc, &argv, sel);
733 } else
734 return -1;
735
736 *argc_p = argc;
737 *argv_p = argv;
738 return res;
739 }
740
741 static int parse_offset(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
742 {
743 int argc = *argc_p;
744 char **argv = *argv_p;
745
746 while (argc > 0) {
747 if (matches(*argv, "plus") == 0) {
748 int off;
749 NEXT_ARG();
750 if (get_integer(&off, *argv, 0))
751 return -1;
752 sel->off = off;
753 sel->flags |= TC_U32_OFFSET;
754 } else if (matches(*argv, "at") == 0) {
755 int off;
756 NEXT_ARG();
757 if (get_integer(&off, *argv, 0))
758 return -1;
759 sel->offoff = off;
760 if (off%2) {
761 fprintf(stderr, "offset \"at\" must be even\n");
762 return -1;
763 }
764 sel->flags |= TC_U32_VAROFFSET;
765 } else if (matches(*argv, "mask") == 0) {
766 __u16 mask;
767 NEXT_ARG();
768 if (get_u16(&mask, *argv, 16))
769 return -1;
770 sel->offmask = htons(mask);
771 sel->flags |= TC_U32_VAROFFSET;
772 } else if (matches(*argv, "shift") == 0) {
773 int shift;
774 NEXT_ARG();
775 if (get_integer(&shift, *argv, 0))
776 return -1;
777 sel->offshift = shift;
778 sel->flags |= TC_U32_VAROFFSET;
779 } else if (matches(*argv, "eat") == 0) {
780 sel->flags |= TC_U32_EAT;
781 } else {
782 break;
783 }
784 argc--; argv++;
785 }
786
787 *argc_p = argc;
788 *argv_p = argv;
789 return 0;
790 }
791
792 static int parse_hashkey(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
793 {
794 int argc = *argc_p;
795 char **argv = *argv_p;
796
797 while (argc > 0) {
798 if (matches(*argv, "mask") == 0) {
799 __u32 mask;
800 NEXT_ARG();
801 if (get_u32(&mask, *argv, 16))
802 return -1;
803 sel->hmask = htonl(mask);
804 } else if (matches(*argv, "at") == 0) {
805 int num;
806 NEXT_ARG();
807 if (get_integer(&num, *argv, 0))
808 return -1;
809 if (num%4)
810 return -1;
811 sel->hoff = num;
812 } else {
813 break;
814 }
815 argc--; argv++;
816 }
817
818 *argc_p = argc;
819 *argv_p = argv;
820 return 0;
821 }
822
823 static void print_ipv4(FILE *f, const struct tc_u32_key *key)
824 {
825 char abuf[256];
826
827 switch (key->off) {
828 case 0:
829 switch (ntohl(key->mask)) {
830 case 0x0f000000:
831 fprintf(f, "\n match IP ihl %u", ntohl(key->val) >> 24);
832 return;
833 case 0x00ff0000:
834 fprintf(f, "\n match IP dsfield %#x", ntohl(key->val) >> 16);
835 return;
836 }
837 break;
838 case 8:
839 if (ntohl(key->mask) == 0x00ff0000) {
840 fprintf(f, "\n match IP protocol %d", ntohl(key->val) >> 16);
841 return;
842 }
843 break;
844 case 12:
845 case 16: {
846 int bits = mask2bits(key->mask);
847 if (bits >= 0) {
848 fprintf(f, "\n %s %s/%d",
849 key->off == 12 ? "match IP src" : "match IP dst",
850 inet_ntop(AF_INET, &key->val,
851 abuf, sizeof(abuf)),
852 bits);
853 return;
854 }
855 }
856 break;
857
858 case 20:
859 switch (ntohl(key->mask)) {
860 case 0x0000ffff:
861 fprintf(f, "\n match dport %u",
862 ntohl(key->val) & 0xffff);
863 return;
864 case 0xffff0000:
865 fprintf(f, "\n match sport %u",
866 ntohl(key->val) >> 16);
867 return;
868 case 0xffffffff:
869 fprintf(f, "\n match dport %u, match sport %u",
870 ntohl(key->val) & 0xffff,
871 ntohl(key->val) >> 16);
872
873 return;
874 }
875 /* XXX: Default print_raw */
876 }
877 }
878
879 static void print_ipv6(FILE *f, const struct tc_u32_key *key)
880 {
881 char abuf[256];
882
883 switch (key->off) {
884 case 0:
885 switch (ntohl(key->mask)) {
886 case 0x0f000000:
887 fprintf(f, "\n match IP ihl %u", ntohl(key->val) >> 24);
888 return;
889 case 0x00ff0000:
890 fprintf(f, "\n match IP dsfield %#x", ntohl(key->val) >> 16);
891 return;
892 }
893 break;
894 case 8:
895 if (ntohl(key->mask) == 0x00ff0000) {
896 fprintf(f, "\n match IP protocol %d", ntohl(key->val) >> 16);
897 return;
898 }
899 break;
900 case 12:
901 case 16: {
902 int bits = mask2bits(key->mask);
903 if (bits >= 0) {
904 fprintf(f, "\n %s %s/%d",
905 key->off == 12 ? "match IP src" : "match IP dst",
906 inet_ntop(AF_INET, &key->val,
907 abuf, sizeof(abuf)),
908 bits);
909 return;
910 }
911 }
912 break;
913
914 case 20:
915 switch (ntohl(key->mask)) {
916 case 0x0000ffff:
917 fprintf(f, "\n match sport %u",
918 ntohl(key->val) & 0xffff);
919 return;
920 case 0xffff0000:
921 fprintf(f, "\n match dport %u",
922 ntohl(key->val) >> 16);
923 return;
924 case 0xffffffff:
925 fprintf(f, "\n match sport %u, match dport %u",
926 ntohl(key->val) & 0xffff,
927 ntohl(key->val) >> 16);
928
929 return;
930 }
931 /* XXX: Default print_raw */
932 }
933 }
934
935 static void print_raw(FILE *f, const struct tc_u32_key *key)
936 {
937 fprintf(f, "\n match %08x/%08x at %s%d",
938 (unsigned int)ntohl(key->val),
939 (unsigned int)ntohl(key->mask),
940 key->offmask ? "nexthdr+" : "",
941 key->off);
942 }
943
944 static const struct {
945 __u16 proto;
946 __u16 pad;
947 void (*pprinter)(FILE *f, const struct tc_u32_key *key);
948 } u32_pprinters[] = {
949 {0, 0, print_raw},
950 {ETH_P_IP, 0, print_ipv4},
951 {ETH_P_IPV6, 0, print_ipv6},
952 };
953
954 static void show_keys(FILE *f, const struct tc_u32_key *key)
955 {
956 int i = 0;
957
958 if (!show_pretty)
959 goto show_k;
960
961 for (i = 0; i < sizeof(u32_pprinters) / sizeof(u32_pprinters[0]); i++) {
962 if (u32_pprinters[i].proto == ntohs(f_proto)) {
963 show_k:
964 u32_pprinters[i].pprinter(f, key);
965 return;
966 }
967 }
968
969 i = 0;
970 goto show_k;
971 }
972
973 static int u32_parse_opt(struct filter_util *qu, char *handle,
974 int argc, char **argv, struct nlmsghdr *n)
975 {
976 struct {
977 struct tc_u32_sel sel;
978 struct tc_u32_key keys[128];
979 } sel;
980 struct tcmsg *t = NLMSG_DATA(n);
981 struct rtattr *tail;
982 int sel_ok = 0, terminal_ok = 0;
983 int sample_ok = 0;
984 __u32 htid = 0;
985 __u32 order = 0;
986
987 memset(&sel, 0, sizeof(sel));
988
989 if (handle && get_u32_handle(&t->tcm_handle, handle)) {
990 fprintf(stderr, "Illegal filter ID\n");
991 return -1;
992 }
993
994 if (argc == 0)
995 return 0;
996
997 tail = NLMSG_TAIL(n);
998 addattr_l(n, MAX_MSG, TCA_OPTIONS, NULL, 0);
999
1000 while (argc > 0) {
1001 if (matches(*argv, "match") == 0) {
1002 NEXT_ARG();
1003 if (parse_selector(&argc, &argv, &sel.sel, n)) {
1004 fprintf(stderr, "Illegal \"match\"\n");
1005 return -1;
1006 }
1007 sel_ok++;
1008 continue;
1009 } else if (matches(*argv, "offset") == 0) {
1010 NEXT_ARG();
1011 if (parse_offset(&argc, &argv, &sel.sel)) {
1012 fprintf(stderr, "Illegal \"offset\"\n");
1013 return -1;
1014 }
1015 continue;
1016 } else if (matches(*argv, "hashkey") == 0) {
1017 NEXT_ARG();
1018 if (parse_hashkey(&argc, &argv, &sel.sel)) {
1019 fprintf(stderr, "Illegal \"hashkey\"\n");
1020 return -1;
1021 }
1022 continue;
1023 } else if (matches(*argv, "classid") == 0 ||
1024 strcmp(*argv, "flowid") == 0) {
1025 unsigned handle;
1026 NEXT_ARG();
1027 if (get_tc_classid(&handle, *argv)) {
1028 fprintf(stderr, "Illegal \"classid\"\n");
1029 return -1;
1030 }
1031 addattr_l(n, MAX_MSG, TCA_U32_CLASSID, &handle, 4);
1032 sel.sel.flags |= TC_U32_TERMINAL;
1033 } else if (matches(*argv, "divisor") == 0) {
1034 unsigned divisor;
1035 NEXT_ARG();
1036 if (get_unsigned(&divisor, *argv, 0) ||
1037 divisor == 0 ||
1038 divisor > 0x100 || ((divisor - 1) & divisor)) {
1039 fprintf(stderr, "Illegal \"divisor\"\n");
1040 return -1;
1041 }
1042 addattr_l(n, MAX_MSG, TCA_U32_DIVISOR, &divisor, 4);
1043 } else if (matches(*argv, "order") == 0) {
1044 NEXT_ARG();
1045 if (get_u32(&order, *argv, 0)) {
1046 fprintf(stderr, "Illegal \"order\"\n");
1047 return -1;
1048 }
1049 } else if (strcmp(*argv, "link") == 0) {
1050 unsigned handle;
1051 NEXT_ARG();
1052 if (get_u32_handle(&handle, *argv)) {
1053 fprintf(stderr, "Illegal \"link\"\n");
1054 return -1;
1055 }
1056 if (handle && TC_U32_NODE(handle)) {
1057 fprintf(stderr, "\"link\" must be a hash table.\n");
1058 return -1;
1059 }
1060 addattr_l(n, MAX_MSG, TCA_U32_LINK, &handle, 4);
1061 } else if (strcmp(*argv, "ht") == 0) {
1062 unsigned handle;
1063 NEXT_ARG();
1064 if (get_u32_handle(&handle, *argv)) {
1065 fprintf(stderr, "Illegal \"ht\"\n");
1066 return -1;
1067 }
1068 if (handle && TC_U32_NODE(handle)) {
1069 fprintf(stderr, "\"ht\" must be a hash table.\n");
1070 return -1;
1071 }
1072 if (sample_ok)
1073 htid = (htid & 0xFF000) | (handle & 0xFFF00000);
1074 else
1075 htid = (handle & 0xFFFFF000);
1076 } else if (strcmp(*argv, "sample") == 0) {
1077 __u32 hash;
1078 unsigned divisor = 0x100;
1079
1080 struct {
1081 struct tc_u32_sel sel;
1082 struct tc_u32_key keys[4];
1083 } sel2;
1084 memset(&sel2, 0, sizeof(sel2));
1085 NEXT_ARG();
1086 if (parse_selector(&argc, &argv, &sel2.sel, n)) {
1087 fprintf(stderr, "Illegal \"sample\"\n");
1088 return -1;
1089 }
1090 if (sel2.sel.nkeys != 1) {
1091 fprintf(stderr, "\"sample\" must contain"
1092 " exactly ONE key.\n");
1093 return -1;
1094 }
1095 if (*argv != 0 && strcmp(*argv, "divisor") == 0) {
1096 NEXT_ARG();
1097 if (get_unsigned(&divisor, *argv, 0) || divisor == 0 ||
1098 divisor > 0x100 || ((divisor - 1) & divisor)) {
1099 fprintf(stderr, "Illegal sample \"divisor\"\n");
1100 return -1;
1101 }
1102 NEXT_ARG();
1103 }
1104 hash = sel2.sel.keys[0].val & sel2.sel.keys[0].mask;
1105 hash ^= hash >> 16;
1106 hash ^= hash >> 8;
1107 htid = ((hash % divisor) << 12) | (htid & 0xFFF00000);
1108 sample_ok = 1;
1109 continue;
1110 } else if (strcmp(*argv, "indev") == 0) {
1111 char ind[IFNAMSIZ + 1];
1112 memset(ind, 0, sizeof (ind));
1113 argc--;
1114 argv++;
1115 if (argc < 1) {
1116 fprintf(stderr, "Illegal indev\n");
1117 return -1;
1118 }
1119 strncpy(ind, *argv, sizeof (ind) - 1);
1120 addattr_l(n, MAX_MSG, TCA_U32_INDEV, ind, strlen(ind) + 1);
1121
1122 } else if (matches(*argv, "action") == 0) {
1123 NEXT_ARG();
1124 if (parse_action(&argc, &argv, TCA_U32_ACT, n)) {
1125 fprintf(stderr, "Illegal \"action\"\n");
1126 return -1;
1127 }
1128 terminal_ok++;
1129 continue;
1130
1131 } else if (matches(*argv, "police") == 0) {
1132 NEXT_ARG();
1133 if (parse_police(&argc, &argv, TCA_U32_POLICE, n)) {
1134 fprintf(stderr, "Illegal \"police\"\n");
1135 return -1;
1136 }
1137 terminal_ok++;
1138 continue;
1139 } else if (strcmp(*argv, "help") == 0) {
1140 explain();
1141 return -1;
1142 } else {
1143 fprintf(stderr, "What is \"%s\"?\n", *argv);
1144 explain();
1145 return -1;
1146 }
1147 argc--; argv++;
1148 }
1149
1150 /* We dont necessarily need class/flowids */
1151 if (terminal_ok)
1152 sel.sel.flags |= TC_U32_TERMINAL;
1153
1154 if (order) {
1155 if (TC_U32_NODE(t->tcm_handle) && order != TC_U32_NODE(t->tcm_handle)) {
1156 fprintf(stderr, "\"order\" contradicts \"handle\"\n");
1157 return -1;
1158 }
1159 t->tcm_handle |= order;
1160 }
1161
1162 if (htid)
1163 addattr_l(n, MAX_MSG, TCA_U32_HASH, &htid, 4);
1164 if (sel_ok)
1165 addattr_l(n, MAX_MSG, TCA_U32_SEL, &sel,
1166 sizeof(sel.sel) + sel.sel.nkeys * sizeof(struct tc_u32_key));
1167 tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail;
1168 return 0;
1169 }
1170
1171 static int u32_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
1172 __u32 handle)
1173 {
1174 struct rtattr *tb[TCA_U32_MAX + 1];
1175 struct tc_u32_sel *sel = NULL;
1176 struct tc_u32_pcnt *pf = NULL;
1177
1178 if (opt == NULL)
1179 return 0;
1180
1181 parse_rtattr_nested(tb, TCA_U32_MAX, opt);
1182
1183 if (handle) {
1184 SPRINT_BUF(b1);
1185 fprintf(f, "fh %s ", sprint_u32_handle(handle, b1));
1186 }
1187 if (TC_U32_NODE(handle)) {
1188 fprintf(f, "order %d ", TC_U32_NODE(handle));
1189 }
1190
1191 if (tb[TCA_U32_SEL]) {
1192 if (RTA_PAYLOAD(tb[TCA_U32_SEL]) < sizeof(*sel))
1193 return -1;
1194
1195 sel = RTA_DATA(tb[TCA_U32_SEL]);
1196 }
1197
1198 if (tb[TCA_U32_DIVISOR]) {
1199 fprintf(f, "ht divisor %d ", rta_getattr_u32(tb[TCA_U32_DIVISOR]));
1200 } else if (tb[TCA_U32_HASH]) {
1201 __u32 htid = rta_getattr_u32(tb[TCA_U32_HASH]);
1202 fprintf(f, "key ht %x bkt %x ", TC_U32_USERHTID(htid),
1203 TC_U32_HASH(htid));
1204 } else {
1205 fprintf(f, "??? ");
1206 }
1207 if (tb[TCA_U32_CLASSID]) {
1208 SPRINT_BUF(b1);
1209 fprintf(f, "%sflowid %s ",
1210 !sel || !(sel->flags & TC_U32_TERMINAL) ? "*" : "",
1211 sprint_tc_classid(rta_getattr_u32(tb[TCA_U32_CLASSID]), b1));
1212 } else if (sel && sel->flags & TC_U32_TERMINAL) {
1213 fprintf(f, "terminal flowid ??? ");
1214 }
1215 if (tb[TCA_U32_LINK]) {
1216 SPRINT_BUF(b1);
1217 fprintf(f, "link %s ",
1218 sprint_u32_handle(rta_getattr_u32(tb[TCA_U32_LINK]), b1));
1219 }
1220
1221 if (tb[TCA_U32_PCNT]) {
1222 if (RTA_PAYLOAD(tb[TCA_U32_PCNT]) < sizeof(*pf)) {
1223 fprintf(f, "Broken perf counters \n");
1224 return -1;
1225 }
1226 pf = RTA_DATA(tb[TCA_U32_PCNT]);
1227 }
1228
1229 if (sel && show_stats && NULL != pf)
1230 fprintf(f, " (rule hit %llu success %llu)",
1231 (unsigned long long) pf->rcnt,
1232 (unsigned long long) pf->rhit);
1233
1234 if (tb[TCA_U32_MARK]) {
1235 struct tc_u32_mark *mark = RTA_DATA(tb[TCA_U32_MARK]);
1236 if (RTA_PAYLOAD(tb[TCA_U32_MARK]) < sizeof(*mark)) {
1237 fprintf(f, "\n Invalid mark (kernel&iproute2 mismatch)\n");
1238 } else {
1239 fprintf(f, "\n mark 0x%04x 0x%04x (success %d)",
1240 mark->val, mark->mask, mark->success);
1241 }
1242 }
1243
1244 if (sel) {
1245 if (sel->nkeys) {
1246 int i;
1247 for (i=0; i<sel->nkeys; i++) {
1248 show_keys(f, sel->keys + i);
1249 if (show_stats && NULL != pf)
1250 fprintf(f, " (success %llu ) ",
1251 (unsigned long long) pf->kcnts[i]);
1252 }
1253 }
1254
1255 if (sel->flags & (TC_U32_VAROFFSET | TC_U32_OFFSET)) {
1256 fprintf(f, "\n offset ");
1257 if (sel->flags & TC_U32_VAROFFSET)
1258 fprintf(f, "%04x>>%d at %d ",
1259 ntohs(sel->offmask),
1260 sel->offshift, sel->offoff);
1261 if (sel->off)
1262 fprintf(f, "plus %d ", sel->off);
1263 }
1264 if (sel->flags & TC_U32_EAT)
1265 fprintf(f, " eat ");
1266
1267 if (sel->hmask) {
1268 fprintf(f, "\n hash mask %08x at %d ",
1269 (unsigned int)htonl(sel->hmask), sel->hoff);
1270 }
1271 }
1272
1273 if (tb[TCA_U32_POLICE]) {
1274 fprintf(f, "\n");
1275 tc_print_police(f, tb[TCA_U32_POLICE]);
1276 }
1277 if (tb[TCA_U32_INDEV]) {
1278 struct rtattr *idev = tb[TCA_U32_INDEV];
1279 fprintf(f, "\n input dev %s\n", rta_getattr_str(idev));
1280 }
1281 if (tb[TCA_U32_ACT]) {
1282 tc_print_action(f, tb[TCA_U32_ACT]);
1283 }
1284
1285 return 0;
1286 }
1287
1288 struct filter_util u32_filter_util = {
1289 .id = "u32",
1290 .parse_fopt = u32_parse_opt,
1291 .print_fopt = u32_print_opt,
1292 };
Upstream mirror of iproute2