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