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 } 781