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 12:
 801         case 16: {
 802                         int bits = mask2bits(key->mask);
 803                         if (bits >= 0) {
 804                                 fprintf(f, "\n  %s %s/%d\n",
 805                                         key->off == 12 ? "src" : "dst",
 806                                         inet_ntop(AF_INET, &key->val,
 807                                                   abuf, sizeof(abuf)),
 808                                         bits);
 809                                 return;
 810                         }
 811                 }
 812                 break;
 813
 814         case 20:
 815         case 22:
 816                 if (key->mask == ntohl(0xffff)) {
 817                         fprintf(f, "\n  %s %u\n",
 818                                 key->off == 20 ? "sport" : "dport",
 819                                 (unsigned short) ntohl(key->val));
 820                         return;
 821                 }
 822         }
 823
 824 raw:
 825         fprintf(f, "\n  match %08x/%08x at %s%d",
 826                 (unsigned int)ntohl(key->val),
 827                 (unsigned int)ntohl(key->mask),
 828                 key->offmask ? "nexthdr+" : "",
 829                 key->off);
 830 }
 831
 832 static int u32_parse_opt(struct filter_util *qu, char *handle,
 833                          int argc, char **argv, struct nlmsghdr *n)
 834 {
 835         struct {
 836                 struct tc_u32_sel sel;
 837                 struct tc_u32_key keys[128];
 838         } sel;
 839         struct tcmsg *t = NLMSG_DATA(n);
 840         struct rtattr *tail;
 841         int sel_ok = 0, terminal_ok = 0;
 842         int sample_ok = 0;
 843         __u32 htid = 0;
 844         __u32 order = 0;
 845
 846         memset(&sel, 0, sizeof(sel));
 847
 848         if (handle && get_u32_handle(&t->tcm_handle, handle)) {
 849                 fprintf(stderr, "Illegal filter ID\n");
 850                 return -1;
 851         }
 852
 853         if (argc == 0)
 854                 return 0;
 855
 856         tail = NLMSG_TAIL(n);
 857         addattr_l(n, MAX_MSG, TCA_OPTIONS, NULL, 0);
 858
 859         while (argc > 0) {
 860                 if (matches(*argv, "match") == 0) {
 861                         NEXT_ARG();
 862                         if (parse_selector(&argc, &argv, &sel.sel, n)) {
 863                                 fprintf(stderr, "Illegal \"match\"\n");
 864                                 return -1;
 865                         }
 866                         sel_ok++;
 867                         continue;
 868                 } else if (matches(*argv, "offset") == 0) {
 869                         NEXT_ARG();
 870                         if (parse_offset(&argc, &argv, &sel.sel)) {
 871                                 fprintf(stderr, "Illegal \"offset\"\n");
 872                                 return -1;
 873                         }
 874                         continue;
 875                 } else if (matches(*argv, "hashkey") == 0) {
 876                         NEXT_ARG();
 877                         if (parse_hashkey(&argc, &argv, &sel.sel)) {
 878                                 fprintf(stderr, "Illegal \"hashkey\"\n");
 879                                 return -1;
 880                         }
 881                         continue;
 882                 } else if (matches(*argv, "classid") == 0 ||
 883                            strcmp(*argv, "flowid") == 0) {
 884                         unsigned handle;
 885                         NEXT_ARG();
 886                         if (get_tc_classid(&handle, *argv)) {
 887                                 fprintf(stderr, "Illegal \"classid\"\n");
 888                                 return -1;
 889                         }
 890                         addattr_l(n, MAX_MSG, TCA_U32_CLASSID, &handle, 4);
 891                         sel.sel.flags |= TC_U32_TERMINAL;
 892                 } else if (matches(*argv, "divisor") == 0) {
 893                         unsigned divisor;
 894                         NEXT_ARG();
 895                         if (get_unsigned(&divisor, *argv, 0) ||
 896                             divisor == 0 ||
 897                             divisor > 0x100 || ((divisor - 1) & divisor)) {
 898                                 fprintf(stderr, "Illegal \"divisor\"\n");
 899                                 return -1;
 900                         }
 901                         addattr_l(n, MAX_MSG, TCA_U32_DIVISOR, &divisor, 4);
 902                 } else if (matches(*argv, "order") == 0) {
 903                         NEXT_ARG();
 904                         if (get_u32(&order, *argv, 0)) {
 905                                 fprintf(stderr, "Illegal \"order\"\n");
 906                                 return -1;
 907                         }
 908                 } else if (strcmp(*argv, "link") == 0) {
 909                         unsigned handle;
 910                         NEXT_ARG();
 911                         if (get_u32_handle(&handle, *argv)) {
 912                                 fprintf(stderr, "Illegal \"link\"\n");
 913                                 return -1;
 914                         }
 915                         if (handle && TC_U32_NODE(handle)) {
 916                                 fprintf(stderr, "\"link\" must be a hash table.\n");
 917                                 return -1;
 918                         }
 919                         addattr_l(n, MAX_MSG, TCA_U32_LINK, &handle, 4);
 920                 } else if (strcmp(*argv, "ht") == 0) {
 921                         unsigned handle;
 922                         NEXT_ARG();
 923                         if (get_u32_handle(&handle, *argv)) {
 924                                 fprintf(stderr, "Illegal \"ht\"\n");
 925                                 return -1;
 926                         }
 927                         if (handle && TC_U32_NODE(handle)) {
 928                                 fprintf(stderr, "\"ht\" must be a hash table.\n");
 929                                 return -1;
 930                         }
 931                         if (sample_ok)
 932                                 htid = (htid&0xFF000)|(handle&0xFFF00000);
 933                         else
 934                                 htid = (handle&0xFFFFF000);
 935                 } else if (strcmp(*argv, "sample") == 0) {
 936                         __u32 hash;
 937                         unsigned divisor = 0x100;
 938
 939                         struct {
 940                                 struct tc_u32_sel sel;
 941                                 struct tc_u32_key keys[4];
 942                         } sel2;
 943                         memset(&sel2, 0, sizeof(sel2));
 944                         NEXT_ARG();
 945                         if (parse_selector(&argc, &argv, &sel2.sel, n)) {
 946                                 fprintf(stderr, "Illegal \"sample\"\n");
 947                                 return -1;
 948                         }
 949                         if (sel2.sel.nkeys != 1) {
 950                                 fprintf(stderr, "\"sample\" must contain"
 951                                         " exactly ONE key.\n");
 952                                 return -1;
 953                         }
 954                         if (*argv != 0 && strcmp(*argv, "divisor") == 0) {
 955                                 NEXT_ARG();
 956                                 if (get_unsigned(&divisor, *argv, 0) || divisor == 0 ||
 957                                     divisor > 0x100 || ((divisor - 1) & divisor)) {
 958                                         fprintf(stderr, "Illegal sample \"divisor\"\n");
 959                                         return -1;
 960                                 }
 961                                 NEXT_ARG();
 962                         }
 963                         hash = sel2.sel.keys[0].val&sel2.sel.keys[0].mask;
 964                         hash ^= hash>>16;
 965                         hash ^= hash>>8;
 966                         htid = ((hash%divisor)<<12)|(htid&0xFFF00000);
 967                         sample_ok = 1;
 968                         continue;
 969                 } else if (strcmp(*argv, "indev") == 0) {
 970                         char ind[IFNAMSIZ + 1];
 971                         memset(ind, 0, sizeof (ind));
 972                         argc--;
 973                         argv++;
 974                         if (argc < 1) {
 975                                 fprintf(stderr, "Illegal indev\n");
 976                                 return -1;
 977                         }
 978                         strncpy(ind, *argv, sizeof (ind) - 1);
 979                         addattr_l(n, MAX_MSG, TCA_U32_INDEV, ind, strlen(ind) + 1);
 980
 981                 } else if (matches(*argv, "action") == 0) {
 982                         NEXT_ARG();
 983                         if (parse_action(&argc, &argv, TCA_U32_ACT, n)) {
 984                                 fprintf(stderr, "Illegal \"action\"\n");
 985                                 return -1;
 986                         }
 987                         terminal_ok++;
 988                         continue;
 989
 990                 } else if (matches(*argv, "police") == 0) {
 991                         NEXT_ARG();
 992                         if (parse_police(&argc, &argv, TCA_U32_POLICE, n)) {
 993                                 fprintf(stderr, "Illegal \"police\"\n");
 994                                 return -1;
 995                         }
 996                         terminal_ok++;
 997                         continue;
 998                 } else if (strcmp(*argv, "help") == 0) {
 999                         explain();
1000                         return -1;
1001                 } else {
1002                         fprintf(stderr, "What is \"%s\"?\n", *argv);
1003                         explain();
1004                         return -1;
1005                 }
1006                 argc--; argv++;
1007         }
1008
1009         /* We dont necessarily need class/flowids */
1010         if (terminal_ok)
1011                 sel.sel.flags |= TC_U32_TERMINAL;
1012
1013         if (order) {
1014                 if (TC_U32_NODE(t->tcm_handle) && order != TC_U32_NODE(t->tcm_handle)) {
1015                         fprintf(stderr, "\"order\" contradicts \"handle\"\n");
1016                         return -1;
1017                 }
1018                 t->tcm_handle |= order;
1019         }
1020
1021         if (htid)
1022                 addattr_l(n, MAX_MSG, TCA_U32_HASH, &htid, 4);
1023         if (sel_ok)
1024                 addattr_l(n, MAX_MSG, TCA_U32_SEL, &sel,
1025                           sizeof(sel.sel)+sel.sel.nkeys*sizeof(struct tc_u32_key));
1026         tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail;
1027         return 0;
1028 }
1029
1030 static int u32_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
1031                          __u32 handle)
1032 {
1033         struct rtattr *tb[TCA_U32_MAX+1];
1034         struct tc_u32_sel *sel = NULL;
1035         struct tc_u32_pcnt *pf = NULL;
1036
1037         if (opt == NULL)
1038                 return 0;
1039
1040         parse_rtattr_nested(tb, TCA_U32_MAX, opt);
1041
1042         if (handle) {
1043                 SPRINT_BUF(b1);
1044                 fprintf(f, "fh %s ", sprint_u32_handle(handle, b1));
1045         }
1046         if (TC_U32_NODE(handle)) {
1047                 fprintf(f, "order %d ", TC_U32_NODE(handle));
1048         }
1049
1050         if (tb[TCA_U32_SEL]) {
1051                 if (RTA_PAYLOAD(tb[TCA_U32_SEL])  < sizeof(*sel))
1052                         return -1;
1053
1054                 sel = RTA_DATA(tb[TCA_U32_SEL]);
1055         }
1056
1057         if (tb[TCA_U32_DIVISOR]) {
1058                 fprintf(f, "ht divisor %d ", *(__u32*)RTA_DATA(tb[TCA_U32_DIVISOR]));
1059         } else if (tb[TCA_U32_HASH]) {
1060                 __u32 htid = *(__u32*)RTA_DATA(tb[TCA_U32_HASH]);
1061                 fprintf(f, "key ht %x bkt %x ", TC_U32_USERHTID(htid),
1062                         TC_U32_HASH(htid));
1063         } else {
1064                 fprintf(f, "??? ");
1065         }
1066         if (tb[TCA_U32_CLASSID]) {
1067                 SPRINT_BUF(b1);
1068                 fprintf(f, "%sflowid %s ",
1069                         !sel || !(sel->flags&TC_U32_TERMINAL) ? "*" : "",
1070                         sprint_tc_classid(*(__u32*)RTA_DATA(tb[TCA_U32_CLASSID]), b1));
1071         } else if (sel && sel->flags&TC_U32_TERMINAL) {
1072                 fprintf(f, "terminal flowid ??? ");
1073         }
1074         if (tb[TCA_U32_LINK]) {
1075                 SPRINT_BUF(b1);
1076                 fprintf(f, "link %s ",
1077                         sprint_u32_handle(*(__u32*)RTA_DATA(tb[TCA_U32_LINK]), b1));
1078         }
1079
1080         if (tb[TCA_U32_PCNT]) {
1081                 if (RTA_PAYLOAD(tb[TCA_U32_PCNT])  < sizeof(*pf)) {
1082                         fprintf(f, "Broken perf counters \n");
1083                         return -1;
1084                 }
1085                 pf = RTA_DATA(tb[TCA_U32_PCNT]);
1086         }
1087
1088         if (sel && show_stats && NULL != pf)
1089                 fprintf(f, " (rule hit %llu success %llu)",
1090                         (unsigned long long) pf->rcnt,
1091                         (unsigned long long) pf->rhit);
1092
1093         if (tb[TCA_U32_MARK]) {
1094                 struct tc_u32_mark *mark = RTA_DATA(tb[TCA_U32_MARK]);
1095                 if (RTA_PAYLOAD(tb[TCA_U32_MARK]) < sizeof(*mark)) {
1096                         fprintf(f, "\n  Invalid mark (kernel&iproute2 mismatch)\n");
1097                 } else {
1098                         fprintf(f, "\n  mark 0x%04x 0x%04x (success %d)",
1099                                 mark->val, mark->mask, mark->success);
1100                 }
1101         }
1102
1103         if (sel) {
1104                 if (sel->nkeys) {
1105                         int i;
1106                         for (i=0; i<sel->nkeys; i++) {
1107                                 show_key(f, sel->keys + i);
1108                                 if (show_stats && NULL != pf)
1109                                         fprintf(f, " (success %llu ) ",
1110                                                 (unsigned long long) pf->kcnts[i]);
1111                         }
1112                 }
1113
1114                 if (sel->flags&(TC_U32_VAROFFSET|TC_U32_OFFSET)) {
1115                         fprintf(f, "\n    offset ");
1116                         if (sel->flags&TC_U32_VAROFFSET)
1117                                 fprintf(f, "%04x>>%d at %d ",
1118                                         ntohs(sel->offmask),
1119                                         sel->offshift,  sel->offoff);
1120                         if (sel->off)
1121                                 fprintf(f, "plus %d ", sel->off);
1122                 }
1123                 if (sel->flags&TC_U32_EAT)
1124                         fprintf(f, " eat ");
1125
1126                 if (sel->hmask) {
1127                         fprintf(f, "\n    hash mask %08x at %d ",
1128                                 (unsigned int)htonl(sel->hmask), sel->hoff);
1129                 }
1130         }
1131
1132         if (tb[TCA_U32_POLICE]) {
1133                 fprintf(f, "\n");
1134                 tc_print_police(f, tb[TCA_U32_POLICE]);
1135         }
1136         if (tb[TCA_U32_INDEV]) {
1137                 struct rtattr *idev = tb[TCA_U32_INDEV];
1138                 fprintf(f, "\n  input dev %s\n", (char *) RTA_DATA(idev));
1139         }
1140         if (tb[TCA_U32_ACT]) {
1141                 tc_print_action(f, tb[TCA_U32_ACT]);
1142         }
1143
1144         return 0;
1145 }
1146
1147 struct filter_util u32_filter_util = {
1148         .id = "u32",
1149         .parse_fopt = u32_parse_opt,
1150         .print_fopt = u32_print_opt,
1151 };