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, "               [ police POLICE_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 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 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 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                 NEXT_ARG();
 501                 res = parse_u8(&argc, &argv, sel, 1, 0);
 502         } else if (strcmp(*argv, "ihl") == 0) {
 503                 NEXT_ARG();
 504                 res = parse_u8(&argc, &argv, sel, 0, 0);
 505         } else if (strcmp(*argv, "protocol") == 0) {
 506                 NEXT_ARG();
 507                 res = parse_u8(&argc, &argv, sel, 9, 0);
 508         } else if (matches(*argv, "precedence") == 0) {
 509                 NEXT_ARG();
 510                 res = parse_u8(&argc, &argv, sel, 1, 0);
 511         } else if (strcmp(*argv, "nofrag") == 0) {
 512                 argc--; argv++;
 513                 res = pack_key16(sel, 0, 0x3FFF, 6, 0);
 514         } else if (strcmp(*argv, "firstfrag") == 0) {
 515                 argc--; argv++;
 516                 res = pack_key16(sel, 0, 0x1FFF, 6, 0);
 517         } else if (strcmp(*argv, "df") == 0) {
 518                 argc--; argv++;
 519                 res = pack_key16(sel, 0x4000, 0x4000, 6, 0);
 520         } else if (strcmp(*argv, "mf") == 0) {
 521                 argc--; argv++;
 522                 res = pack_key16(sel, 0x2000, 0x2000, 6, 0);
 523         } else if (strcmp(*argv, "dport") == 0) {
 524                 NEXT_ARG();
 525                 res = parse_u16(&argc, &argv, sel, 22, 0);
 526         } else if (strcmp(*argv, "sport") == 0) {
 527                 NEXT_ARG();
 528                 res = parse_u16(&argc, &argv, sel, 20, 0);
 529         } else if (strcmp(*argv, "icmp_type") == 0) {
 530                 NEXT_ARG();
 531                 res = parse_u8(&argc, &argv, sel, 20, 0);
 532         } else if (strcmp(*argv, "icmp_code") == 0) {
 533                 NEXT_ARG();
 534                 res = parse_u8(&argc, &argv, sel, 20, 1);
 535         } else
 536                 return -1;
 537
 538         *argc_p = argc;
 539         *argv_p = argv;
 540         return res;
 541 }
 542
 543 static int parse_ip6(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
 544 {
 545         int res = -1;
 546         int argc = *argc_p;
 547         char **argv = *argv_p;
 548
 549         if (argc < 2)
 550                 return -1;
 551
 552         if (strcmp(*argv, "src") == 0) {
 553                 NEXT_ARG();
 554                 res = parse_ip6_addr(&argc, &argv, sel, 8);
 555         } else if (strcmp(*argv, "dst") == 0) {
 556                 NEXT_ARG();
 557                 res = parse_ip6_addr(&argc, &argv, sel, 24);
 558         } else if (strcmp(*argv, "priority") == 0) {
 559                 NEXT_ARG();
 560                 res = parse_ip6_class(&argc, &argv, sel);
 561         } else if (strcmp(*argv, "protocol") == 0) {
 562                 NEXT_ARG();
 563                 res = parse_u8(&argc, &argv, sel, 6, 0);
 564         } else if (strcmp(*argv, "flowlabel") == 0) {
 565                 NEXT_ARG();
 566                 res = parse_u32(&argc, &argv, sel, 0, 0);
 567         } else if (strcmp(*argv, "dport") == 0) {
 568                 NEXT_ARG();
 569                 res = parse_u16(&argc, &argv, sel, 42, 0);
 570         } else if (strcmp(*argv, "sport") == 0) {
 571                 NEXT_ARG();
 572                 res = parse_u16(&argc, &argv, sel, 40, 0);
 573         } else if (strcmp(*argv, "icmp_type") == 0) {
 574                 NEXT_ARG();
 575                 res = parse_u8(&argc, &argv, sel, 40, 0);
 576         } else if (strcmp(*argv, "icmp_code") == 0) {
 577                 NEXT_ARG();
 578                 res = parse_u8(&argc, &argv, sel, 41, 1);
 579         } else
 580                 return -1;
 581
 582         *argc_p = argc;
 583         *argv_p = argv;
 584         return res;
 585 }
 586
 587 static int parse_ether(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
 588 {
 589         int res = -1;
 590         int argc = *argc_p;
 591         char **argv = *argv_p;
 592
 593         if (argc < 2)
 594                 return -1;
 595
 596         if (strcmp(*argv, "src") == 0) {
 597                 NEXT_ARG();
 598                 res = parse_ether_addr(&argc, &argv, sel, -8);
 599         } else if (strcmp(*argv, "dst") == 0) {
 600                 NEXT_ARG();
 601                 res = parse_ether_addr(&argc, &argv, sel, -14);
 602         } else {
 603                 fprintf(stderr, "Unknown match: ether %s\n", *argv);
 604                 return -1;
 605         }
 606
 607         *argc_p = argc;
 608         *argv_p = argv;
 609         return res;
 610 }
 611
 612 #define parse_tcp parse_udp
 613 static int parse_udp(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
 614 {
 615         int res = -1;
 616         int argc = *argc_p;
 617         char **argv = *argv_p;
 618
 619         if (argc < 2)
 620                 return -1;
 621
 622         if (strcmp(*argv, "src") == 0) {
 623                 NEXT_ARG();
 624                 res = parse_u16(&argc, &argv, sel, 0, -1);
 625         } else if (strcmp(*argv, "dst") == 0) {
 626                 NEXT_ARG();
 627                 res = parse_u16(&argc, &argv, sel, 2, -1);
 628         } else
 629                 return -1;
 630
 631         *argc_p = argc;
 632         *argv_p = argv;
 633         return res;
 634 }
 635
 636
 637 static int parse_icmp(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
 638 {
 639         int res = -1;
 640         int argc = *argc_p;
 641         char **argv = *argv_p;
 642
 643         if (argc < 2)
 644                 return -1;
 645
 646         if (strcmp(*argv, "type") == 0) {
 647                 NEXT_ARG();
 648                 res = parse_u8(&argc, &argv, sel, 0, -1);
 649         } else if (strcmp(*argv, "code") == 0) {
 650                 NEXT_ARG();
 651                 res = parse_u8(&argc, &argv, sel, 1, -1);
 652         } else
 653                 return -1;
 654
 655         *argc_p = argc;
 656         *argv_p = argv;
 657         return res;
 658 }
 659
 660 static int parse_mark(int *argc_p, char ***argv_p, struct nlmsghdr *n)
 661 {
 662         int res = -1;
 663         int argc = *argc_p;
 664         char **argv = *argv_p;
 665         struct tc_u32_mark mark;
 666
 667         if (argc <= 1)
 668                 return -1;
 669
 670         if (get_u32(&mark.val, *argv, 0)) {
 671                 fprintf(stderr, "Illegal \"mark\" value\n");
 672                 return -1;
 673         }
 674         NEXT_ARG();
 675
 676         if (get_u32(&mark.mask, *argv, 0)) {
 677                 fprintf(stderr, "Illegal \"mark\" mask\n");
 678                 return -1;
 679         }
 680         NEXT_ARG();
 681
 682         if ((mark.val & mark.mask) != mark.val) {
 683                 fprintf(stderr, "Illegal \"mark\" (impossible combination)\n");
 684                 return -1;
 685         }
 686
 687         addattr_l(n, MAX_MSG, TCA_U32_MARK, &mark, sizeof(mark));
 688         res = 0;
 689
 690         *argc_p = argc;
 691         *argv_p = argv;
 692         return res;
 693 }
 694
 695 static int parse_selector(int *argc_p, char ***argv_p,
 696                           struct tc_u32_sel *sel, struct nlmsghdr *n)
 697 {
 698         int argc = *argc_p;
 699         char **argv = *argv_p;
 700         int res = -1;
 701
 702         if (argc <= 0)
 703                 return -1;
 704
 705         if (matches(*argv, "u32") == 0) {
 706                 NEXT_ARG();
 707                 res = parse_u32(&argc, &argv, sel, 0, 0);
 708         } else if (matches(*argv, "u16") == 0) {
 709                 NEXT_ARG();
 710                 res = parse_u16(&argc, &argv, sel, 0, 0);
 711         } else if (matches(*argv, "u8") == 0) {
 712                 NEXT_ARG();
 713                 res = parse_u8(&argc, &argv, sel, 0, 0);
 714         } else if (matches(*argv, "ip") == 0) {
 715                 NEXT_ARG();
 716                 res = parse_ip(&argc, &argv, sel);
 717         } else  if (matches(*argv, "ip6") == 0) {
 718                 NEXT_ARG();
 719                 res = parse_ip6(&argc, &argv, sel);
 720         } else if (matches(*argv, "udp") == 0) {
 721                 NEXT_ARG();
 722                 res = parse_udp(&argc, &argv, sel);
 723         } else if (matches(*argv, "tcp") == 0) {
 724                 NEXT_ARG();
 725                 res = parse_tcp(&argc, &argv, sel);
 726         } else if (matches(*argv, "icmp") == 0) {
 727                 NEXT_ARG();
 728                 res = parse_icmp(&argc, &argv, sel);
 729         } else if (matches(*argv, "mark") == 0) {
 730                 NEXT_ARG();
 731                 res = parse_mark(&argc, &argv, n);
 732         } else if (matches(*argv, "ether") == 0) {
 733                 NEXT_ARG();
 734                 res = parse_ether(&argc, &argv, sel);
 735         } else
 736                 return -1;
 737
 738         *argc_p = argc;
 739         *argv_p = argv;
 740         return res;
 741 }
 742
 743 static int parse_offset(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
 744 {
 745         int argc = *argc_p;
 746         char **argv = *argv_p;
 747
 748         while (argc > 0) {
 749                 if (matches(*argv, "plus") == 0) {
 750                         int off;
 751                         NEXT_ARG();
 752                         if (get_integer(&off, *argv, 0))
 753                                 return -1;
 754                         sel->off = off;
 755                         sel->flags |= TC_U32_OFFSET;
 756                 } else if (matches(*argv, "at") == 0) {
 757                         int off;
 758                         NEXT_ARG();
 759                         if (get_integer(&off, *argv, 0))
 760                                 return -1;
 761                         sel->offoff = off;
 762                         if (off%2) {
 763                                 fprintf(stderr, "offset \"at\" must be even\n");
 764                                 return -1;
 765                         }
 766                         sel->flags |= TC_U32_VAROFFSET;
 767                 } else if (matches(*argv, "mask") == 0) {
 768                         __u16 mask;
 769                         NEXT_ARG();
 770                         if (get_u16(&mask, *argv, 16))
 771                                 return -1;
 772                         sel->offmask = htons(mask);
 773                         sel->flags |= TC_U32_VAROFFSET;
 774                 } else if (matches(*argv, "shift") == 0) {
 775                         int shift;
 776                         NEXT_ARG();
 777                         if (get_integer(&shift, *argv, 0))
 778                                 return -1;
 779                         sel->offshift = shift;
 780                         sel->flags |= TC_U32_VAROFFSET;
 781                 } else if (matches(*argv, "eat") == 0) {
 782                         sel->flags |= TC_U32_EAT;
 783                 } else {
 784                         break;
 785                 }
 786                 argc--; argv++;
 787         }
 788
 789         *argc_p = argc;
 790         *argv_p = argv;
 791         return 0;
 792 }
 793
 794 static int parse_hashkey(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
 795 {
 796         int argc = *argc_p;
 797         char **argv = *argv_p;
 798
 799         while (argc > 0) {
 800                 if (matches(*argv, "mask") == 0) {
 801                         __u32 mask;
 802                         NEXT_ARG();
 803                         if (get_u32(&mask, *argv, 16))
 804                                 return -1;
 805                         sel->hmask = htonl(mask);
 806                 } else if (matches(*argv, "at") == 0) {
 807                         int num;
 808                         NEXT_ARG();
 809                         if (get_integer(&num, *argv, 0))
 810                                 return -1;
 811                         if (num%4)
 812                                 return -1;
 813                         sel->hoff = num;
 814                 } else {
 815                         break;
 816                 }
 817                 argc--; argv++;
 818         }
 819
 820         *argc_p = argc;
 821         *argv_p = argv;
 822         return 0;
 823 }
 824
 825 static void print_ipv4(FILE *f, const struct tc_u32_key *key)
 826 {
 827         char abuf[256];
 828
 829         switch (key->off) {
 830         case 0:
 831                 switch (ntohl(key->mask)) {
 832                 case 0x0f000000:
 833                         fprintf(f, "\n  match IP ihl %u", ntohl(key->val) >> 24);
 834                         return;
 835                 case 0x00ff0000:
 836                         fprintf(f, "\n  match IP dsfield %#x", ntohl(key->val) >> 16);
 837                         return;
 838                 }
 839                 break;
 840         case 8:
 841                 if (ntohl(key->mask) == 0x00ff0000) {
 842                         fprintf(f, "\n  match IP protocol %d", ntohl(key->val) >> 16);
 843                         return;
 844                 }
 845                 break;
 846         case 12:
 847         case 16: {
 848                         int bits = mask2bits(key->mask);
 849                         if (bits >= 0) {
 850                                 fprintf(f, "\n  %s %s/%d",
 851                                         key->off == 12 ? "match IP src" : "match IP dst",
 852                                         inet_ntop(AF_INET, &key->val,
 853                                                   abuf, sizeof(abuf)),
 854                                         bits);
 855                                 return;
 856                         }
 857                 }
 858                 break;
 859
 860         case 20:
 861                 switch (ntohl(key->mask)) {
 862                 case 0x0000ffff:
 863                         fprintf(f, "\n  match dport %u",
 864                                 ntohl(key->val) & 0xffff);
 865                         return;
 866                 case 0xffff0000:
 867                         fprintf(f, "\n  match sport %u",
 868                                 ntohl(key->val) >> 16);
 869                         return;
 870                 case 0xffffffff:
 871                         fprintf(f, "\n  match dport %u, match sport %u",
 872                                 ntohl(key->val) & 0xffff,
 873                                 ntohl(key->val) >> 16);
 874
 875                         return;
 876                 }
 877                 /* XXX: Default print_raw */
 878         }
 879 }
 880
 881 static void print_ipv6(FILE *f, const struct tc_u32_key *key)
 882 {
 883         char abuf[256];
 884
 885         switch (key->off) {
 886         case 0:
 887                 switch (ntohl(key->mask)) {
 888                 case 0x0f000000:
 889                         fprintf(f, "\n  match IP ihl %u", ntohl(key->val) >> 24);
 890                         return;
 891                 case 0x00ff0000:
 892                         fprintf(f, "\n  match IP dsfield %#x", ntohl(key->val) >> 16);
 893                         return;
 894                 }
 895                 break;
 896         case 8:
 897                 if (ntohl(key->mask) == 0x00ff0000) {
 898                         fprintf(f, "\n  match IP protocol %d", ntohl(key->val) >> 16);
 899                         return;
 900                 }
 901                 break;
 902         case 12:
 903         case 16: {
 904                         int bits = mask2bits(key->mask);
 905                         if (bits >= 0) {
 906                                 fprintf(f, "\n  %s %s/%d",
 907                                         key->off == 12 ? "match IP src" : "match IP dst",
 908                                         inet_ntop(AF_INET, &key->val,
 909                                                   abuf, sizeof(abuf)),
 910                                         bits);
 911                                 return;
 912                         }
 913                 }
 914                 break;
 915
 916         case 20:
 917                 switch (ntohl(key->mask)) {
 918                 case 0x0000ffff:
 919                         fprintf(f, "\n  match sport %u",
 920                                 ntohl(key->val) & 0xffff);
 921                         return;
 922                 case 0xffff0000:
 923                         fprintf(f, "\n  match dport %u",
 924                                 ntohl(key->val) >> 16);
 925                         return;
 926                 case 0xffffffff:
 927                         fprintf(f, "\n  match sport %u, match dport %u",
 928                                 ntohl(key->val) & 0xffff,
 929                                 ntohl(key->val) >> 16);
 930
 931                         return;
 932                 }
 933                 /* XXX: Default print_raw */
 934         }
 935 }
 936
 937 static void print_raw(FILE *f, const struct tc_u32_key *key)
 938 {
 939         fprintf(f, "\n  match %08x/%08x at %s%d",
 940                 (unsigned int)ntohl(key->val),
 941                 (unsigned int)ntohl(key->mask),
 942                 key->offmask ? "nexthdr+" : "",
 943                 key->off);
 944 }
 945
 946 static const struct {
 947         __u16 proto;
 948         __u16 pad;
 949         void (*pprinter)(FILE *f, const struct tc_u32_key *key);
 950 } u32_pprinters[] = {
 951         {0,        0, print_raw},
 952         {ETH_P_IP, 0, print_ipv4},
 953         {ETH_P_IPV6, 0, print_ipv6},
 954 };
 955
 956 static void show_keys(FILE *f, const struct tc_u32_key *key)
 957 {
 958         int i = 0;
 959
 960         if (!show_pretty)
 961                 goto show_k;
 962
 963         for (i = 0; i < sizeof(u32_pprinters) / sizeof(u32_pprinters[0]); i++) {
 964                 if (u32_pprinters[i].proto == ntohs(f_proto)) {
 965 show_k:
 966                         u32_pprinters[i].pprinter(f, key);
 967                         return;
 968                 }
 969         }
 970
 971         i = 0;
 972         goto show_k;
 973 }
 974
 975 static int u32_parse_opt(struct filter_util *qu, char *handle,
 976                          int argc, char **argv, struct nlmsghdr *n)
 977 {
 978         struct {
 979                 struct tc_u32_sel sel;
 980                 struct tc_u32_key keys[128];
 981         } sel;
 982         struct tcmsg *t = NLMSG_DATA(n);
 983         struct rtattr *tail;
 984         int sel_ok = 0, terminal_ok = 0;
 985         int sample_ok = 0;
 986         __u32 htid = 0;
 987         __u32 order = 0;
 988
 989         memset(&sel, 0, sizeof(sel));
 990
 991         if (handle && get_u32_handle(&t->tcm_handle, handle)) {
 992                 fprintf(stderr, "Illegal filter ID\n");
 993                 return -1;
 994         }
 995
 996         if (argc == 0)
 997                 return 0;
 998
 999         tail = NLMSG_TAIL(n);
1000         addattr_l(n, MAX_MSG, TCA_OPTIONS, NULL, 0);
1001
1002         while (argc > 0) {
1003                 if (matches(*argv, "match") == 0) {
1004                         NEXT_ARG();
1005                         if (parse_selector(&argc, &argv, &sel.sel, n)) {
1006                                 fprintf(stderr, "Illegal \"match\"\n");
1007                                 return -1;
1008                         }
1009                         sel_ok++;
1010                         continue;
1011                 } else if (matches(*argv, "offset") == 0) {
1012                         NEXT_ARG();
1013                         if (parse_offset(&argc, &argv, &sel.sel)) {
1014                                 fprintf(stderr, "Illegal \"offset\"\n");
1015                                 return -1;
1016                         }
1017                         continue;
1018                 } else if (matches(*argv, "hashkey") == 0) {
1019                         NEXT_ARG();
1020                         if (parse_hashkey(&argc, &argv, &sel.sel)) {
1021                                 fprintf(stderr, "Illegal \"hashkey\"\n");
1022                                 return -1;
1023                         }
1024                         continue;
1025                 } else if (matches(*argv, "classid") == 0 ||
1026                            strcmp(*argv, "flowid") == 0) {
1027                         unsigned handle;
1028                         NEXT_ARG();
1029                         if (get_tc_classid(&handle, *argv)) {
1030                                 fprintf(stderr, "Illegal \"classid\"\n");
1031                                 return -1;
1032                         }
1033                         addattr_l(n, MAX_MSG, TCA_U32_CLASSID, &handle, 4);
1034                         sel.sel.flags |= TC_U32_TERMINAL;
1035                 } else if (matches(*argv, "divisor") == 0) {
1036                         unsigned divisor;
1037                         NEXT_ARG();
1038                         if (get_unsigned(&divisor, *argv, 0) ||
1039                             divisor == 0 ||
1040                             divisor > 0x100 || ((divisor - 1) & divisor)) {
1041                                 fprintf(stderr, "Illegal \"divisor\"\n");
1042                                 return -1;
1043                         }
1044                         addattr_l(n, MAX_MSG, TCA_U32_DIVISOR, &divisor, 4);
1045                 } else if (matches(*argv, "order") == 0) {
1046                         NEXT_ARG();
1047                         if (get_u32(&order, *argv, 0)) {
1048                                 fprintf(stderr, "Illegal \"order\"\n");
1049                                 return -1;
1050                         }
1051                 } else if (strcmp(*argv, "link") == 0) {
1052                         unsigned handle;
1053                         NEXT_ARG();
1054                         if (get_u32_handle(&handle, *argv)) {
1055                                 fprintf(stderr, "Illegal \"link\"\n");
1056                                 return -1;
1057                         }
1058                         if (handle && TC_U32_NODE(handle)) {
1059                                 fprintf(stderr, "\"link\" must be a hash table.\n");
1060                                 return -1;
1061                         }
1062                         addattr_l(n, MAX_MSG, TCA_U32_LINK, &handle, 4);
1063                 } else if (strcmp(*argv, "ht") == 0) {
1064                         unsigned handle;
1065                         NEXT_ARG();
1066                         if (get_u32_handle(&handle, *argv)) {
1067                                 fprintf(stderr, "Illegal \"ht\"\n");
1068                                 return -1;
1069                         }
1070                         if (handle && TC_U32_NODE(handle)) {
1071                                 fprintf(stderr, "\"ht\" must be a hash table.\n");
1072                                 return -1;
1073                         }
1074                         if (sample_ok)
1075                                 htid = (htid&0xFF000)|(handle&0xFFF00000);
1076                         else
1077                                 htid = (handle&0xFFFFF000);
1078                 } else if (strcmp(*argv, "sample") == 0) {
1079                         __u32 hash;
1080                         unsigned divisor = 0x100;
1081
1082                         struct {
1083                                 struct tc_u32_sel sel;
1084                                 struct tc_u32_key keys[4];
1085                         } sel2;
1086                         memset(&sel2, 0, sizeof(sel2));
1087                         NEXT_ARG();
1088                         if (parse_selector(&argc, &argv, &sel2.sel, n)) {
1089                                 fprintf(stderr, "Illegal \"sample\"\n");
1090                                 return -1;
1091                         }
1092                         if (sel2.sel.nkeys != 1) {
1093                                 fprintf(stderr, "\"sample\" must contain"
1094                                         " exactly ONE key.\n");
1095                                 return -1;
1096                         }
1097                         if (*argv != 0 && strcmp(*argv, "divisor") == 0) {
1098                                 NEXT_ARG();
1099                                 if (get_unsigned(&divisor, *argv, 0) || divisor == 0 ||
1100                                     divisor > 0x100 || ((divisor - 1) & divisor)) {
1101                                         fprintf(stderr, "Illegal sample \"divisor\"\n");
1102                                         return -1;
1103                                 }
1104                                 NEXT_ARG();
1105                         }
1106                         hash = sel2.sel.keys[0].val&sel2.sel.keys[0].mask;
1107                         hash ^= hash>>16;
1108                         hash ^= hash>>8;
1109                         htid = ((hash%divisor)<<12)|(htid&0xFFF00000);
1110                         sample_ok = 1;
1111                         continue;
1112                 } else if (strcmp(*argv, "indev") == 0) {
1113                         char ind[IFNAMSIZ + 1];
1114                         memset(ind, 0, sizeof (ind));
1115                         argc--;
1116                         argv++;
1117                         if (argc < 1) {
1118                                 fprintf(stderr, "Illegal indev\n");
1119                                 return -1;
1120                         }
1121                         strncpy(ind, *argv, sizeof (ind) - 1);
1122                         addattr_l(n, MAX_MSG, TCA_U32_INDEV, ind, strlen(ind) + 1);
1123
1124                 } else if (matches(*argv, "action") == 0) {
1125                         NEXT_ARG();
1126                         if (parse_action(&argc, &argv, TCA_U32_ACT, n)) {
1127                                 fprintf(stderr, "Illegal \"action\"\n");
1128                                 return -1;
1129                         }
1130                         terminal_ok++;
1131                         continue;
1132
1133                 } else if (matches(*argv, "police") == 0) {
1134                         NEXT_ARG();
1135                         if (parse_police(&argc, &argv, TCA_U32_POLICE, n)) {
1136                                 fprintf(stderr, "Illegal \"police\"\n");
1137                                 return -1;
1138                         }
1139                         terminal_ok++;
1140                         continue;
1141                 } else if (strcmp(*argv, "help") == 0) {
1142                         explain();
1143                         return -1;
1144                 } else {
1145                         fprintf(stderr, "What is \"%s\"?\n", *argv);
1146                         explain();
1147                         return -1;
1148                 }
1149                 argc--; argv++;
1150         }
1151
1152         /* We dont necessarily need class/flowids */
1153         if (terminal_ok)
1154                 sel.sel.flags |= TC_U32_TERMINAL;
1155
1156         if (order) {
1157                 if (TC_U32_NODE(t->tcm_handle) && order != TC_U32_NODE(t->tcm_handle)) {
1158                         fprintf(stderr, "\"order\" contradicts \"handle\"\n");
1159                         return -1;
1160                 }
1161                 t->tcm_handle |= order;
1162         }
1163
1164         if (htid)
1165                 addattr_l(n, MAX_MSG, TCA_U32_HASH, &htid, 4);
1166         if (sel_ok)
1167                 addattr_l(n, MAX_MSG, TCA_U32_SEL, &sel,
1168                           sizeof(sel.sel)+sel.sel.nkeys*sizeof(struct tc_u32_key));
1169         tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail;
1170         return 0;
1171 }
1172
1173 static int u32_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
1174                          __u32 handle)
1175 {
1176         struct rtattr *tb[TCA_U32_MAX+1];
1177         struct tc_u32_sel *sel = NULL;
1178         struct tc_u32_pcnt *pf = NULL;
1179
1180         if (opt == NULL)
1181                 return 0;
1182
1183         parse_rtattr_nested(tb, TCA_U32_MAX, opt);
1184
1185         if (handle) {
1186                 SPRINT_BUF(b1);
1187                 fprintf(f, "fh %s ", sprint_u32_handle(handle, b1));
1188         }
1189         if (TC_U32_NODE(handle)) {
1190                 fprintf(f, "order %d ", TC_U32_NODE(handle));
1191         }
1192
1193         if (tb[TCA_U32_SEL]) {
1194                 if (RTA_PAYLOAD(tb[TCA_U32_SEL])  < sizeof(*sel))
1195                         return -1;
1196
1197                 sel = RTA_DATA(tb[TCA_U32_SEL]);
1198         }
1199
1200         if (tb[TCA_U32_DIVISOR]) {
1201                 fprintf(f, "ht divisor %d ", *(__u32*)RTA_DATA(tb[TCA_U32_DIVISOR]));
1202         } else if (tb[TCA_U32_HASH]) {
1203                 __u32 htid = *(__u32*)RTA_DATA(tb[TCA_U32_HASH]);
1204                 fprintf(f, "key ht %x bkt %x ", TC_U32_USERHTID(htid),
1205                         TC_U32_HASH(htid));
1206         } else {
1207                 fprintf(f, "??? ");
1208         }
1209         if (tb[TCA_U32_CLASSID]) {
1210                 SPRINT_BUF(b1);
1211                 fprintf(f, "%sflowid %s ",
1212                         !sel || !(sel->flags&TC_U32_TERMINAL) ? "*" : "",
1213                         sprint_tc_classid(*(__u32*)RTA_DATA(tb[TCA_U32_CLASSID]), b1));
1214         } else if (sel && sel->flags&TC_U32_TERMINAL) {
1215                 fprintf(f, "terminal flowid ??? ");
1216         }
1217         if (tb[TCA_U32_LINK]) {
1218                 SPRINT_BUF(b1);
1219                 fprintf(f, "link %s ",
1220                         sprint_u32_handle(*(__u32*)RTA_DATA(tb[TCA_U32_LINK]), b1));
1221         }
1222
1223         if (tb[TCA_U32_PCNT]) {
1224                 if (RTA_PAYLOAD(tb[TCA_U32_PCNT])  < sizeof(*pf)) {
1225                         fprintf(f, "Broken perf counters \n");
1226                         return -1;
1227                 }
1228                 pf = RTA_DATA(tb[TCA_U32_PCNT]);
1229         }
1230
1231         if (sel && show_stats && NULL != pf)
1232                 fprintf(f, " (rule hit %llu success %llu)",
1233                         (unsigned long long) pf->rcnt,
1234                         (unsigned long long) pf->rhit);
1235
1236         if (tb[TCA_U32_MARK]) {
1237                 struct tc_u32_mark *mark = RTA_DATA(tb[TCA_U32_MARK]);
1238                 if (RTA_PAYLOAD(tb[TCA_U32_MARK]) < sizeof(*mark)) {
1239                         fprintf(f, "\n  Invalid mark (kernel&iproute2 mismatch)\n");
1240                 } else {
1241                         fprintf(f, "\n  mark 0x%04x 0x%04x (success %d)",
1242                                 mark->val, mark->mask, mark->success);
1243                 }
1244         }
1245
1246         if (sel) {
1247                 if (sel->nkeys) {
1248                         int i;
1249                         for (i=0; i<sel->nkeys; i++) {
1250                                 show_keys(f, sel->keys + i);
1251                                 if (show_stats && NULL != pf)
1252                                         fprintf(f, " (success %llu ) ",
1253                                                 (unsigned long long) pf->kcnts[i]);
1254                         }
1255                 }
1256
1257                 if (sel->flags&(TC_U32_VAROFFSET|TC_U32_OFFSET)) {
1258                         fprintf(f, "\n    offset ");
1259                         if (sel->flags&TC_U32_VAROFFSET)
1260                                 fprintf(f, "%04x>>%d at %d ",
1261                                         ntohs(sel->offmask),
1262                                         sel->offshift,  sel->offoff);
1263                         if (sel->off)
1264                                 fprintf(f, "plus %d ", sel->off);
1265                 }
1266                 if (sel->flags&TC_U32_EAT)
1267                         fprintf(f, " eat ");
1268
1269                 if (sel->hmask) {
1270                         fprintf(f, "\n    hash mask %08x at %d ",
1271                                 (unsigned int)htonl(sel->hmask), sel->hoff);
1272                 }
1273         }
1274
1275         if (tb[TCA_U32_POLICE]) {
1276                 fprintf(f, "\n");
1277                 tc_print_police(f, tb[TCA_U32_POLICE]);
1278         }
1279         if (tb[TCA_U32_INDEV]) {
1280                 struct rtattr *idev = tb[TCA_U32_INDEV];
1281                 fprintf(f, "\n  input dev %s\n", (char *) RTA_DATA(idev));
1282         }
1283         if (tb[TCA_U32_ACT]) {
1284                 tc_print_action(f, tb[TCA_U32_ACT]);
1285         }
1286
1287         return 0;
1288 }
1289
1290 struct filter_util u32_filter_util = {
1291         .id = "u32",
1292         .parse_fopt = u32_parse_opt,
1293         .print_fopt = u32_print_opt,
1294 };