tools/testing/selftests/bpf/test_flow_dissector.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Inject packets with all sorts of encapsulation into the kernel.
   4  *
   5  * IPv4/IPv6    outer layer 3
   6  * GRE/GUE/BARE outer layer 4, where bare is IPIP/SIT/IPv4-in-IPv6/..
   7  * IPv4/IPv6    inner layer 3
   8  */
   9
  10 #define _GNU_SOURCE
  11
  12 #include <stddef.h>
  13 #include <arpa/inet.h>
  14 #include <asm/byteorder.h>
  15 #include <error.h>
  16 #include <errno.h>
  17 #include <linux/if_packet.h>
  18 #include <linux/if_ether.h>
  19 #include <linux/ipv6.h>
  20 #include <netinet/ip.h>
  21 #include <netinet/in.h>
  22 #include <netinet/udp.h>
  23 #include <poll.h>
  24 #include <stdbool.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <sys/ioctl.h>
  29 #include <sys/socket.h>
  30 #include <sys/stat.h>
  31 #include <sys/time.h>
  32 #include <sys/types.h>
  33 #include <unistd.h>
  34
  35 #define CFG_PORT_INNER  8000
  36
  37 /* Add some protocol definitions that do not exist in userspace */
  38
  39 struct grehdr {
  40         uint16_t unused;
  41         uint16_t protocol;
  42 } __attribute__((packed));
  43
  44 struct guehdr {
  45         union {
  46                 struct {
  47 #if defined(__LITTLE_ENDIAN_BITFIELD)
  48                         __u8    hlen:5,
  49                                 control:1,
  50                                 version:2;
  51 #elif defined (__BIG_ENDIAN_BITFIELD)
  52                         __u8    version:2,
  53                                 control:1,
  54                                 hlen:5;
  55 #else
  56 #error  "Please fix <asm/byteorder.h>"
  57 #endif
  58                         __u8    proto_ctype;
  59                         __be16  flags;
  60                 };
  61                 __be32  word;
  62         };
  63 };
  64
  65 static uint8_t  cfg_dsfield_inner;
  66 static uint8_t  cfg_dsfield_outer;
  67 static uint8_t  cfg_encap_proto;
  68 static bool     cfg_expect_failure = false;
  69 static int      cfg_l3_extra = AF_UNSPEC;       /* optional SIT prefix */
  70 static int      cfg_l3_inner = AF_UNSPEC;
  71 static int      cfg_l3_outer = AF_UNSPEC;
  72 static int      cfg_num_pkt = 10;
  73 static int      cfg_num_secs = 0;
  74 static char     cfg_payload_char = 'a';
  75 static int      cfg_payload_len = 100;
  76 static int      cfg_port_gue = 6080;
  77 static bool     cfg_only_rx;
  78 static bool     cfg_only_tx;
  79 static int      cfg_src_port = 9;
  80
  81 static char     buf[ETH_DATA_LEN];
  82
  83 #define INIT_ADDR4(name, addr4, port)                           \
  84         static struct sockaddr_in name = {                      \
  85                 .sin_family = AF_INET,                          \
  86                 .sin_port = __constant_htons(port),             \
  87                 .sin_addr.s_addr = __constant_htonl(addr4),     \
  88         };
  89
  90 #define INIT_ADDR6(name, addr6, port)                           \
  91         static struct sockaddr_in6 name = {                     \
  92                 .sin6_family = AF_INET6,                        \
  93                 .sin6_port = __constant_htons(port),            \
  94                 .sin6_addr = addr6,                             \
  95         };
  96
  97 INIT_ADDR4(in_daddr4, INADDR_LOOPBACK, CFG_PORT_INNER)
  98 INIT_ADDR4(in_saddr4, INADDR_LOOPBACK + 2, 0)
  99 INIT_ADDR4(out_daddr4, INADDR_LOOPBACK, 0)
 100 INIT_ADDR4(out_saddr4, INADDR_LOOPBACK + 1, 0)
 101 INIT_ADDR4(extra_daddr4, INADDR_LOOPBACK, 0)
 102 INIT_ADDR4(extra_saddr4, INADDR_LOOPBACK + 1, 0)
 103
 104 INIT_ADDR6(in_daddr6, IN6ADDR_LOOPBACK_INIT, CFG_PORT_INNER)
 105 INIT_ADDR6(in_saddr6, IN6ADDR_LOOPBACK_INIT, 0)
 106 INIT_ADDR6(out_daddr6, IN6ADDR_LOOPBACK_INIT, 0)
 107 INIT_ADDR6(out_saddr6, IN6ADDR_LOOPBACK_INIT, 0)
 108 INIT_ADDR6(extra_daddr6, IN6ADDR_LOOPBACK_INIT, 0)
 109 INIT_ADDR6(extra_saddr6, IN6ADDR_LOOPBACK_INIT, 0)
 110
 111 static unsigned long util_gettime(void)
 112 {
 113         struct timeval tv;
 114
 115         gettimeofday(&tv, NULL);
 116         return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
 117 }
 118
 119 static void util_printaddr(const char *msg, struct sockaddr *addr)
 120 {
 121         unsigned long off = 0;
 122         char nbuf[INET6_ADDRSTRLEN];
 123
 124         switch (addr->sa_family) {
 125         case PF_INET:
 126                 off = __builtin_offsetof(struct sockaddr_in, sin_addr);
 127                 break;
 128         case PF_INET6:
 129                 off = __builtin_offsetof(struct sockaddr_in6, sin6_addr);
 130                 break;
 131         default:
 132                 error(1, 0, "printaddr: unsupported family %u\n",
 133                       addr->sa_family);
 134         }
 135
 136         if (!inet_ntop(addr->sa_family, ((void *) addr) + off, nbuf,
 137                        sizeof(nbuf)))
 138                 error(1, errno, "inet_ntop");
 139
 140         fprintf(stderr, "%s: %s\n", msg, nbuf);
 141 }
 142
 143 static unsigned long add_csum_hword(const uint16_t *start, int num_u16)
 144 {
 145         unsigned long sum = 0;
 146         int i;
 147
 148         for (i = 0; i < num_u16; i++)
 149                 sum += start[i];
 150
 151         return sum;
 152 }
 153
 154 static uint16_t build_ip_csum(const uint16_t *start, int num_u16,
 155                               unsigned long sum)
 156 {
 157         sum += add_csum_hword(start, num_u16);
 158
 159         while (sum >> 16)
 160                 sum = (sum & 0xffff) + (sum >> 16);
 161
 162         return ~sum;
 163 }
 164
 165 static void build_ipv4_header(void *header, uint8_t proto,
 166                               uint32_t src, uint32_t dst,
 167                               int payload_len, uint8_t tos)
 168 {
 169         struct iphdr *iph = header;
 170
 171         iph->ihl = 5;
 172         iph->version = 4;
 173         iph->tos = tos;
 174         iph->ttl = 8;
 175         iph->tot_len = htons(sizeof(*iph) + payload_len);
 176         iph->id = htons(1337);
 177         iph->protocol = proto;
 178         iph->saddr = src;
 179         iph->daddr = dst;
 180         iph->check = build_ip_csum((void *) iph, iph->ihl << 1, 0);
 181 }
 182
 183 static void ipv6_set_dsfield(struct ipv6hdr *ip6h, uint8_t dsfield)
 184 {
 185         uint16_t val, *ptr = (uint16_t *)ip6h;
 186
 187         val = ntohs(*ptr);
 188         val &= 0xF00F;
 189         val |= ((uint16_t) dsfield) << 4;
 190         *ptr = htons(val);
 191 }
 192
 193 static void build_ipv6_header(void *header, uint8_t proto,
 194                               struct sockaddr_in6 *src,
 195                               struct sockaddr_in6 *dst,
 196                               int payload_len, uint8_t dsfield)
 197 {
 198         struct ipv6hdr *ip6h = header;
 199
 200         ip6h->version = 6;
 201         ip6h->payload_len = htons(payload_len);
 202         ip6h->nexthdr = proto;
 203         ip6h->hop_limit = 8;
 204         ipv6_set_dsfield(ip6h, dsfield);
 205
 206         memcpy(&ip6h->saddr, &src->sin6_addr, sizeof(ip6h->saddr));
 207         memcpy(&ip6h->daddr, &dst->sin6_addr, sizeof(ip6h->daddr));
 208 }
 209
 210 static uint16_t build_udp_v4_csum(const struct iphdr *iph,
 211                                   const struct udphdr *udph,
 212                                   int num_words)
 213 {
 214         unsigned long pseudo_sum;
 215         int num_u16 = sizeof(iph->saddr);       /* halfwords: twice byte len */
 216
 217         pseudo_sum = add_csum_hword((void *) &iph->saddr, num_u16);
 218         pseudo_sum += htons(IPPROTO_UDP);
 219         pseudo_sum += udph->len;
 220         return build_ip_csum((void *) udph, num_words, pseudo_sum);
 221 }
 222
 223 static uint16_t build_udp_v6_csum(const struct ipv6hdr *ip6h,
 224                                   const struct udphdr *udph,
 225                                   int num_words)
 226 {
 227         unsigned long pseudo_sum;
 228         int num_u16 = sizeof(ip6h->saddr);      /* halfwords: twice byte len */
 229
 230         pseudo_sum = add_csum_hword((void *) &ip6h->saddr, num_u16);
 231         pseudo_sum += htons(ip6h->nexthdr);
 232         pseudo_sum += ip6h->payload_len;
 233         return build_ip_csum((void *) udph, num_words, pseudo_sum);
 234 }
 235
 236 static void build_udp_header(void *header, int payload_len,
 237                              uint16_t dport, int family)
 238 {
 239         struct udphdr *udph = header;
 240         int len = sizeof(*udph) + payload_len;
 241
 242         udph->source = htons(cfg_src_port);
 243         udph->dest = htons(dport);
 244         udph->len = htons(len);
 245         udph->check = 0;
 246         if (family == AF_INET)
 247                 udph->check = build_udp_v4_csum(header - sizeof(struct iphdr),
 248                                                 udph, len >> 1);
 249         else
 250                 udph->check = build_udp_v6_csum(header - sizeof(struct ipv6hdr),
 251                                                 udph, len >> 1);
 252 }
 253
 254 static void build_gue_header(void *header, uint8_t proto)
 255 {
 256         struct guehdr *gueh = header;
 257
 258         gueh->proto_ctype = proto;
 259 }
 260
 261 static void build_gre_header(void *header, uint16_t proto)
 262 {
 263         struct grehdr *greh = header;
 264
 265         greh->protocol = htons(proto);
 266 }
 267
 268 static int l3_length(int family)
 269 {
 270         if (family == AF_INET)
 271                 return sizeof(struct iphdr);
 272         else
 273                 return sizeof(struct ipv6hdr);
 274 }
 275
 276 static int build_packet(void)
 277 {
 278         int ol3_len = 0, ol4_len = 0, il3_len = 0, il4_len = 0;
 279         int el3_len = 0;
 280
 281         if (cfg_l3_extra)
 282                 el3_len = l3_length(cfg_l3_extra);
 283
 284         /* calculate header offsets */
 285         if (cfg_encap_proto) {
 286                 ol3_len = l3_length(cfg_l3_outer);
 287
 288                 if (cfg_encap_proto == IPPROTO_GRE)
 289                         ol4_len = sizeof(struct grehdr);
 290                 else if (cfg_encap_proto == IPPROTO_UDP)
 291                         ol4_len = sizeof(struct udphdr) + sizeof(struct guehdr);
 292         }
 293
 294         il3_len = l3_length(cfg_l3_inner);
 295         il4_len = sizeof(struct udphdr);
 296
 297         if (el3_len + ol3_len + ol4_len + il3_len + il4_len + cfg_payload_len >=
 298             sizeof(buf))
 299                 error(1, 0, "packet too large\n");
 300
 301         /*
 302          * Fill packet from inside out, to calculate correct checksums.
 303          * But create ip before udp headers, as udp uses ip for pseudo-sum.
 304          */
 305         memset(buf + el3_len + ol3_len + ol4_len + il3_len + il4_len,
 306                cfg_payload_char, cfg_payload_len);
 307
 308         /* add zero byte for udp csum padding */
 309         buf[el3_len + ol3_len + ol4_len + il3_len + il4_len + cfg_payload_len] = 0;
 310
 311         switch (cfg_l3_inner) {
 312         case PF_INET:
 313                 build_ipv4_header(buf + el3_len + ol3_len + ol4_len,
 314                                   IPPROTO_UDP,
 315                                   in_saddr4.sin_addr.s_addr,
 316                                   in_daddr4.sin_addr.s_addr,
 317                                   il4_len + cfg_payload_len,
 318                                   cfg_dsfield_inner);
 319                 break;
 320         case PF_INET6:
 321                 build_ipv6_header(buf + el3_len + ol3_len + ol4_len,
 322                                   IPPROTO_UDP,
 323                                   &in_saddr6, &in_daddr6,
 324                                   il4_len + cfg_payload_len,
 325                                   cfg_dsfield_inner);
 326                 break;
 327         }
 328
 329         build_udp_header(buf + el3_len + ol3_len + ol4_len + il3_len,
 330                          cfg_payload_len, CFG_PORT_INNER, cfg_l3_inner);
 331
 332         if (!cfg_encap_proto)
 333                 return il3_len + il4_len + cfg_payload_len;
 334
 335         switch (cfg_l3_outer) {
 336         case PF_INET:
 337                 build_ipv4_header(buf + el3_len, cfg_encap_proto,
 338                                   out_saddr4.sin_addr.s_addr,
 339                                   out_daddr4.sin_addr.s_addr,
 340                                   ol4_len + il3_len + il4_len + cfg_payload_len,
 341                                   cfg_dsfield_outer);
 342                 break;
 343         case PF_INET6:
 344                 build_ipv6_header(buf + el3_len, cfg_encap_proto,
 345                                   &out_saddr6, &out_daddr6,
 346                                   ol4_len + il3_len + il4_len + cfg_payload_len,
 347                                   cfg_dsfield_outer);
 348                 break;
 349         }
 350
 351         switch (cfg_encap_proto) {
 352         case IPPROTO_UDP:
 353                 build_gue_header(buf + el3_len + ol3_len + ol4_len -
 354                                  sizeof(struct guehdr),
 355                                  cfg_l3_inner == PF_INET ? IPPROTO_IPIP
 356                                                          : IPPROTO_IPV6);
 357                 build_udp_header(buf + el3_len + ol3_len,
 358                                  sizeof(struct guehdr) + il3_len + il4_len +
 359                                  cfg_payload_len,
 360                                  cfg_port_gue, cfg_l3_outer);
 361                 break;
 362         case IPPROTO_GRE:
 363                 build_gre_header(buf + el3_len + ol3_len,
 364                                  cfg_l3_inner == PF_INET ? ETH_P_IP
 365                                                          : ETH_P_IPV6);
 366                 break;
 367         }
 368
 369         switch (cfg_l3_extra) {
 370         case PF_INET:
 371                 build_ipv4_header(buf,
 372                                   cfg_l3_outer == PF_INET ? IPPROTO_IPIP
 373                                                           : IPPROTO_IPV6,
 374                                   extra_saddr4.sin_addr.s_addr,
 375                                   extra_daddr4.sin_addr.s_addr,
 376                                   ol3_len + ol4_len + il3_len + il4_len +
 377                                   cfg_payload_len, 0);
 378                 break;
 379         case PF_INET6:
 380                 build_ipv6_header(buf,
 381                                   cfg_l3_outer == PF_INET ? IPPROTO_IPIP
 382                                                           : IPPROTO_IPV6,
 383                                   &extra_saddr6, &extra_daddr6,
 384                                   ol3_len + ol4_len + il3_len + il4_len +
 385                                   cfg_payload_len, 0);
 386                 break;
 387         }
 388
 389         return el3_len + ol3_len + ol4_len + il3_len + il4_len +
 390                cfg_payload_len;
 391 }
 392
 393 /* sender transmits encapsulated over RAW or unencap'd over UDP */
 394 static int setup_tx(void)
 395 {
 396         int family, fd, ret;
 397
 398         if (cfg_l3_extra)
 399                 family = cfg_l3_extra;
 400         else if (cfg_l3_outer)
 401                 family = cfg_l3_outer;
 402         else
 403                 family = cfg_l3_inner;
 404
 405         fd = socket(family, SOCK_RAW, IPPROTO_RAW);
 406         if (fd == -1)
 407                 error(1, errno, "socket tx");
 408
 409         if (cfg_l3_extra) {
 410                 if (cfg_l3_extra == PF_INET)
 411                         ret = connect(fd, (void *) &extra_daddr4,
 412                                       sizeof(extra_daddr4));
 413                 else
 414                         ret = connect(fd, (void *) &extra_daddr6,
 415                                       sizeof(extra_daddr6));
 416                 if (ret)
 417                         error(1, errno, "connect tx");
 418         } else if (cfg_l3_outer) {
 419                 /* connect to destination if not encapsulated */
 420                 if (cfg_l3_outer == PF_INET)
 421                         ret = connect(fd, (void *) &out_daddr4,
 422                                       sizeof(out_daddr4));
 423                 else
 424                         ret = connect(fd, (void *) &out_daddr6,
 425                                       sizeof(out_daddr6));
 426                 if (ret)
 427                         error(1, errno, "connect tx");
 428         } else {
 429                 /* otherwise using loopback */
 430                 if (cfg_l3_inner == PF_INET)
 431                         ret = connect(fd, (void *) &in_daddr4,
 432                                       sizeof(in_daddr4));
 433                 else
 434                         ret = connect(fd, (void *) &in_daddr6,
 435                                       sizeof(in_daddr6));
 436                 if (ret)
 437                         error(1, errno, "connect tx");
 438         }
 439
 440         return fd;
 441 }
 442
 443 /* receiver reads unencapsulated UDP */
 444 static int setup_rx(void)
 445 {
 446         int fd, ret;
 447
 448         fd = socket(cfg_l3_inner, SOCK_DGRAM, 0);
 449         if (fd == -1)
 450                 error(1, errno, "socket rx");
 451
 452         if (cfg_l3_inner == PF_INET)
 453                 ret = bind(fd, (void *) &in_daddr4, sizeof(in_daddr4));
 454         else
 455                 ret = bind(fd, (void *) &in_daddr6, sizeof(in_daddr6));
 456         if (ret)
 457                 error(1, errno, "bind rx");
 458
 459         return fd;
 460 }
 461
 462 static int do_tx(int fd, const char *pkt, int len)
 463 {
 464         int ret;
 465
 466         ret = write(fd, pkt, len);
 467         if (ret == -1)
 468                 error(1, errno, "send");
 469         if (ret != len)
 470                 error(1, errno, "send: len (%d < %d)\n", ret, len);
 471
 472         return 1;
 473 }
 474
 475 static int do_poll(int fd, short events, int timeout)
 476 {
 477         struct pollfd pfd;
 478         int ret;
 479
 480         pfd.fd = fd;
 481         pfd.events = events;
 482
 483         ret = poll(&pfd, 1, timeout);
 484         if (ret == -1)
 485                 error(1, errno, "poll");
 486         if (ret && !(pfd.revents & POLLIN))
 487                 error(1, errno, "poll: unexpected event 0x%x\n", pfd.revents);
 488
 489         return ret;
 490 }
 491
 492 static int do_rx(int fd)
 493 {
 494         char rbuf;
 495         int ret, num = 0;
 496
 497         while (1) {
 498                 ret = recv(fd, &rbuf, 1, MSG_DONTWAIT);
 499                 if (ret == -1 && errno == EAGAIN)
 500                         break;
 501                 if (ret == -1)
 502                         error(1, errno, "recv");
 503                 if (rbuf != cfg_payload_char)
 504                         error(1, 0, "recv: payload mismatch");
 505                 num++;
 506         };
 507
 508         return num;
 509 }
 510
 511 static int do_main(void)
 512 {
 513         unsigned long tstop, treport, tcur;
 514         int fdt = -1, fdr = -1, len, tx = 0, rx = 0;
 515
 516         if (!cfg_only_tx)
 517                 fdr = setup_rx();
 518         if (!cfg_only_rx)
 519                 fdt = setup_tx();
 520
 521         len = build_packet();
 522
 523         tcur = util_gettime();
 524         treport = tcur + 1000;
 525         tstop = tcur + (cfg_num_secs * 1000);
 526
 527         while (1) {
 528                 if (!cfg_only_rx)
 529                         tx += do_tx(fdt, buf, len);
 530
 531                 if (!cfg_only_tx)
 532                         rx += do_rx(fdr);
 533
 534                 if (cfg_num_secs) {
 535                         tcur = util_gettime();
 536                         if (tcur >= tstop)
 537                                 break;
 538                         if (tcur >= treport) {
 539                                 fprintf(stderr, "pkts: tx=%u rx=%u\n", tx, rx);
 540                                 tx = 0;
 541                                 rx = 0;
 542                                 treport = tcur + 1000;
 543                         }
 544                 } else {
 545                         if (tx == cfg_num_pkt)
 546                                 break;
 547                 }
 548         }
 549
 550         /* read straggler packets, if any */
 551         if (rx < tx) {
 552                 tstop = util_gettime() + 100;
 553                 while (rx < tx) {
 554                         tcur = util_gettime();
 555                         if (tcur >= tstop)
 556                                 break;
 557
 558                         do_poll(fdr, POLLIN, tstop - tcur);
 559                         rx += do_rx(fdr);
 560                 }
 561         }
 562
 563         fprintf(stderr, "pkts: tx=%u rx=%u\n", tx, rx);
 564
 565         if (fdr != -1 && close(fdr))
 566                 error(1, errno, "close rx");
 567         if (fdt != -1 && close(fdt))
 568                 error(1, errno, "close tx");
 569
 570         /*
 571          * success (== 0) only if received all packets
 572          * unless failure is expected, in which case none must arrive.
 573          */
 574         if (cfg_expect_failure)
 575                 return rx != 0;
 576         else
 577                 return rx != tx;
 578 }
 579
 580
 581 static void __attribute__((noreturn)) usage(const char *filepath)
 582 {
 583         fprintf(stderr, "Usage: %s [-e gre|gue|bare|none] [-i 4|6] [-l len] "
 584                         "[-O 4|6] [-o 4|6] [-n num] [-t secs] [-R] [-T] "
 585                         "[-s <osrc> [-d <odst>] [-S <isrc>] [-D <idst>] "
 586                         "[-x <otos>] [-X <itos>] [-f <isport>] [-F]\n",
 587                 filepath);
 588         exit(1);
 589 }
 590
 591 static void parse_addr(int family, void *addr, const char *optarg)
 592 {
 593         int ret;
 594
 595         ret = inet_pton(family, optarg, addr);
 596         if (ret == -1)
 597                 error(1, errno, "inet_pton");
 598         if (ret == 0)
 599                 error(1, 0, "inet_pton: bad string");
 600 }
 601
 602 static void parse_addr4(struct sockaddr_in *addr, const char *optarg)
 603 {
 604         parse_addr(AF_INET, &addr->sin_addr, optarg);
 605 }
 606
 607 static void parse_addr6(struct sockaddr_in6 *addr, const char *optarg)
 608 {
 609         parse_addr(AF_INET6, &addr->sin6_addr, optarg);
 610 }
 611
 612 static int parse_protocol_family(const char *filepath, const char *optarg)
 613 {
 614         if (!strcmp(optarg, "4"))
 615                 return PF_INET;
 616         if (!strcmp(optarg, "6"))
 617                 return PF_INET6;
 618
 619         usage(filepath);
 620 }
 621
 622 static void parse_opts(int argc, char **argv)
 623 {
 624         int c;
 625
 626         while ((c = getopt(argc, argv, "d:D:e:f:Fhi:l:n:o:O:Rs:S:t:Tx:X:")) != -1) {
 627                 switch (c) {
 628                 case 'd':
 629                         if (cfg_l3_outer == AF_UNSPEC)
 630                                 error(1, 0, "-d must be preceded by -o");
 631                         if (cfg_l3_outer == AF_INET)
 632                                 parse_addr4(&out_daddr4, optarg);
 633                         else
 634                                 parse_addr6(&out_daddr6, optarg);
 635                         break;
 636                 case 'D':
 637                         if (cfg_l3_inner == AF_UNSPEC)
 638                                 error(1, 0, "-D must be preceded by -i");
 639                         if (cfg_l3_inner == AF_INET)
 640                                 parse_addr4(&in_daddr4, optarg);
 641                         else
 642                                 parse_addr6(&in_daddr6, optarg);
 643                         break;
 644                 case 'e':
 645                         if (!strcmp(optarg, "gre"))
 646                                 cfg_encap_proto = IPPROTO_GRE;
 647                         else if (!strcmp(optarg, "gue"))
 648                                 cfg_encap_proto = IPPROTO_UDP;
 649                         else if (!strcmp(optarg, "bare"))
 650                                 cfg_encap_proto = IPPROTO_IPIP;
 651                         else if (!strcmp(optarg, "none"))
 652                                 cfg_encap_proto = IPPROTO_IP;   /* == 0 */
 653                         else
 654                                 usage(argv[0]);
 655                         break;
 656                 case 'f':
 657                         cfg_src_port = strtol(optarg, NULL, 0);
 658                         break;
 659                 case 'F':
 660                         cfg_expect_failure = true;
 661                         break;
 662                 case 'h':
 663                         usage(argv[0]);
 664                         break;
 665                 case 'i':
 666                         if (!strcmp(optarg, "4"))
 667                                 cfg_l3_inner = PF_INET;
 668                         else if (!strcmp(optarg, "6"))
 669                                 cfg_l3_inner = PF_INET6;
 670                         else
 671                                 usage(argv[0]);
 672                         break;
 673                 case 'l':
 674                         cfg_payload_len = strtol(optarg, NULL, 0);
 675                         break;
 676                 case 'n':
 677                         cfg_num_pkt = strtol(optarg, NULL, 0);
 678                         break;
 679                 case 'o':
 680                         cfg_l3_outer = parse_protocol_family(argv[0], optarg);
 681                         break;
 682                 case 'O':
 683                         cfg_l3_extra = parse_protocol_family(argv[0], optarg);
 684                         break;
 685                 case 'R':
 686                         cfg_only_rx = true;
 687                         break;
 688                 case 's':
 689                         if (cfg_l3_outer == AF_INET)
 690                                 parse_addr4(&out_saddr4, optarg);
 691                         else
 692                                 parse_addr6(&out_saddr6, optarg);
 693                         break;
 694                 case 'S':
 695                         if (cfg_l3_inner == AF_INET)
 696                                 parse_addr4(&in_saddr4, optarg);
 697                         else
 698                                 parse_addr6(&in_saddr6, optarg);
 699                         break;
 700                 case 't':
 701                         cfg_num_secs = strtol(optarg, NULL, 0);
 702                         break;
 703                 case 'T':
 704                         cfg_only_tx = true;
 705                         break;
 706                 case 'x':
 707                         cfg_dsfield_outer = strtol(optarg, NULL, 0);
 708                         break;
 709                 case 'X':
 710                         cfg_dsfield_inner = strtol(optarg, NULL, 0);
 711                         break;
 712                 }
 713         }
 714
 715         if (cfg_only_rx && cfg_only_tx)
 716                 error(1, 0, "options: cannot combine rx-only and tx-only");
 717
 718         if (cfg_encap_proto && cfg_l3_outer == AF_UNSPEC)
 719                 error(1, 0, "options: must specify outer with encap");
 720         else if ((!cfg_encap_proto) && cfg_l3_outer != AF_UNSPEC)
 721                 error(1, 0, "options: cannot combine no-encap and outer");
 722         else if ((!cfg_encap_proto) && cfg_l3_extra != AF_UNSPEC)
 723                 error(1, 0, "options: cannot combine no-encap and extra");
 724
 725         if (cfg_l3_inner == AF_UNSPEC)
 726                 cfg_l3_inner = AF_INET6;
 727         if (cfg_l3_inner == AF_INET6 && cfg_encap_proto == IPPROTO_IPIP)
 728                 cfg_encap_proto = IPPROTO_IPV6;
 729
 730         /* RFC 6040 4.2:
 731          *   on decap, if outer encountered congestion (CE == 0x3),
 732          *   but inner cannot encode ECN (NoECT == 0x0), then drop packet.
 733          */
 734         if (((cfg_dsfield_outer & 0x3) == 0x3) &&
 735             ((cfg_dsfield_inner & 0x3) == 0x0))
 736                 cfg_expect_failure = true;
 737 }
 738
 739 static void print_opts(void)
 740 {
 741         if (cfg_l3_inner == PF_INET6) {
 742                 util_printaddr("inner.dest6", (void *) &in_daddr6);
 743                 util_printaddr("inner.source6", (void *) &in_saddr6);
 744         } else {
 745                 util_printaddr("inner.dest4", (void *) &in_daddr4);
 746                 util_printaddr("inner.source4", (void *) &in_saddr4);
 747         }
 748
 749         if (!cfg_l3_outer)
 750                 return;
 751
 752         fprintf(stderr, "encap proto:   %u\n", cfg_encap_proto);
 753
 754         if (cfg_l3_outer == PF_INET6) {
 755                 util_printaddr("outer.dest6", (void *) &out_daddr6);
 756                 util_printaddr("outer.source6", (void *) &out_saddr6);
 757         } else {
 758                 util_printaddr("outer.dest4", (void *) &out_daddr4);
 759                 util_printaddr("outer.source4", (void *) &out_saddr4);
 760         }
 761
 762         if (!cfg_l3_extra)
 763                 return;
 764
 765         if (cfg_l3_outer == PF_INET6) {
 766                 util_printaddr("extra.dest6", (void *) &extra_daddr6);
 767                 util_printaddr("extra.source6", (void *) &extra_saddr6);
 768         } else {
 769                 util_printaddr("extra.dest4", (void *) &extra_daddr4);
 770                 util_printaddr("extra.source4", (void *) &extra_saddr4);
 771         }
 772
 773 }
 774
 775 int main(int argc, char **argv)
 776 {
 777         parse_opts(argc, argv);
 778         print_opts();
 779         return do_main();
 780 }