1 // SPDX-License-Identifier: GPL-2.0 2 3 /* Test hardware checksum offload: Rx + Tx, IPv4 + IPv6, TCP + UDP. 4 * 5 * The test runs on two machines to exercise the NIC. For this reason it 6 * is not integrated in kselftests. 7 * 8 * CMD=$((./csum -[46] -[tu] -S $SADDR -D $DADDR -[RT] -r 1 $EXTRA_ARGS)) 9 * 10 * Rx: 11 * 12 * The sender sends packets with a known checksum field using PF_INET(6) 13 * SOCK_RAW sockets. 14 * 15 * good packet: $CMD [-t] 16 * bad packet: $CMD [-t] -E 17 * 18 * The receiver reads UDP packets with a UDP socket. This is not an 19 * option for TCP packets ('-t'). Optionally insert an iptables filter 20 * to avoid these entering the real protocol stack. 21 * 22 * The receiver also reads all packets with a PF_PACKET socket, to 23 * observe whether both good and bad packets arrive on the host. And to 24 * read the optional TP_STATUS_CSUM_VALID bit. This requires setting 25 * option PACKET_AUXDATA, and works only for CHECKSUM_UNNECESSARY. 26 * 27 * Tx: 28 * 29 * The sender needs to build CHECKSUM_PARTIAL packets to exercise tx 30 * checksum offload. 31 * 32 * The sender can sends packets with a UDP socket. 33 * 34 * Optionally crafts a packet that sums up to zero to verify that the 35 * device writes negative zero 0xFFFF in this case to distinguish from 36 * 0x0000 (checksum disabled), as required by RFC 768. Hit this case 37 * by choosing a specific source port. 38 * 39 * good packet: $CMD -U 40 * zero csum: $CMD -U -Z 41 * 42 * The sender can also build packets with PF_PACKET with PACKET_VNET_HDR, 43 * to cover more protocols. PF_PACKET requires passing src and dst mac 44 * addresses. 45 * 46 * good packet: $CMD -s $smac -d $dmac -p [-t] 47 * 48 * Argument '-z' sends UDP packets with a 0x000 checksum disabled field, 49 * to verify that the NIC passes these packets unmodified. 50 * 51 * Argument '-e' adds a transport mode encapsulation header between 52 * network and transport header. This will fail for devices that parse 53 * headers. Should work on devices that implement protocol agnostic tx 54 * checksum offload (NETIF_F_HW_CSUM). 55 * 56 * Argument '-r $SEED' optionally randomizes header, payload and length 57 * to increase coverage between packets sent. SEED 1 further chooses a 58 * different seed for each run (and logs this for reproducibility). It 59 * is advised to enable this for extra coverage in continuous testing. 60 */ 61 62 #define _GNU_SOURCE 63 64 #include <arpa/inet.h> 65 #include <asm/byteorder.h> 66 #include <errno.h> 67 #include <error.h> 68 #include <linux/filter.h> 69 #include <linux/if_packet.h> 70 #include <linux/ipv6.h> 71 #include <linux/virtio_net.h> 72 #include <net/ethernet.h> 73 #include <net/if.h> 74 #include <netinet/if_ether.h> 75 #include <netinet/in.h> 76 #include <netinet/ip.h> 77 #include <netinet/ip6.h> 78 #include <netinet/tcp.h> 79 #include <netinet/udp.h> 80 #include <poll.h> 81 #include <sched.h> 82 #include <stdbool.h> 83 #include <stddef.h> 84 #include <stdint.h> 85 #include <stdio.h> 86 #include <stdlib.h> 87 #include <string.h> 88 #include <sys/socket.h> 89 #include <sys/stat.h> 90 #include <sys/time.h> 91 #include <sys/types.h> 92 #include <unistd.h> 93 94 static bool cfg_bad_csum; 95 static int cfg_family = PF_INET6; 96 static int cfg_num_pkt = 4; 97 static bool cfg_do_rx = true; 98 static bool cfg_do_tx = true; 99 static bool cfg_encap; 100 static char *cfg_ifname = "eth0"; 101 static char *cfg_mac_dst; 102 static char *cfg_mac_src; 103 static int cfg_proto = IPPROTO_UDP; 104 static int cfg_payload_char = 'a'; 105 static int cfg_payload_len = 100; 106 static uint16_t cfg_port_dst = 34000; 107 static uint16_t cfg_port_src = 33000; 108 static uint16_t cfg_port_src_encap = 33001; 109 static unsigned int cfg_random_seed; 110 static int cfg_rcvbuf = 1 << 22; /* be able to queue large cfg_num_pkt */ 111 static bool cfg_send_pfpacket; 112 static bool cfg_send_udp; 113 static int cfg_timeout_ms = 2000; 114 static bool cfg_zero_disable; /* skip checksum: set to zero (udp only) */ 115 static bool cfg_zero_sum; /* create packet that adds up to zero */ 116 117 static struct sockaddr_in cfg_daddr4 = {.sin_family = AF_INET}; 118 static struct sockaddr_in cfg_saddr4 = {.sin_family = AF_INET}; 119 static struct sockaddr_in6 cfg_daddr6 = {.sin6_family = AF_INET6}; 120 static struct sockaddr_in6 cfg_saddr6 = {.sin6_family = AF_INET6}; 121 122 #define ENC_HEADER_LEN (sizeof(struct udphdr) + sizeof(struct udp_encap_hdr)) 123 #define MAX_HEADER_LEN (sizeof(struct ipv6hdr) + ENC_HEADER_LEN + sizeof(struct tcphdr)) 124 #define MAX_PAYLOAD_LEN 1024 125 126 /* Trivial demo encap. Stand-in for transport layer protocols like ESP or PSP */ 127 struct udp_encap_hdr { 128 uint8_t nexthdr; 129 uint8_t padding[3]; 130 }; 131 132 /* Ipaddrs, for pseudo csum. Global var is ugly, pass through funcs was worse */ 133 static void *iph_addr_p; 134 135 static unsigned long gettimeofday_ms(void) 136 { 137 struct timeval tv; 138 139 gettimeofday(&tv, NULL); 140 return (tv.tv_sec * 1000UL) + (tv.tv_usec / 1000UL); 141 } 142 143 static uint32_t checksum_nofold(char *data, size_t len, uint32_t sum) 144 { 145 uint16_t *words = (uint16_t *)data; 146 int i; 147 148 for (i = 0; i < len / 2; i++) 149 sum += words[i]; 150 151 if (len & 1) 152 sum += ((unsigned char *)data)[len - 1]; 153 154 return sum; 155 } 156 157 static uint16_t checksum_fold(void *data, size_t len, uint32_t sum) 158 { 159 sum = checksum_nofold(data, len, sum); 160 161 while (sum > 0xFFFF) 162 sum = (sum & 0xFFFF) + (sum >> 16); 163 164 return ~sum; 165 } 166 167 static uint16_t checksum(void *th, uint16_t proto, size_t len) 168 { 169 uint32_t sum; 170 int alen; 171 172 alen = cfg_family == PF_INET6 ? 32 : 8; 173 174 sum = checksum_nofold(iph_addr_p, alen, 0); 175 sum += htons(proto); 176 sum += htons(len); 177 178 /* With CHECKSUM_PARTIAL kernel expects non-inverted pseudo csum */ 179 if (cfg_do_tx && cfg_send_pfpacket) 180 return ~checksum_fold(NULL, 0, sum); 181 else 182 return checksum_fold(th, len, sum); 183 } 184 185 static void *build_packet_ipv4(void *_iph, uint8_t proto, unsigned int len) 186 { 187 struct iphdr *iph = _iph; 188 189 memset(iph, 0, sizeof(*iph)); 190 191 iph->version = 4; 192 iph->ihl = 5; 193 iph->ttl = 8; 194 iph->protocol = proto; 195 iph->saddr = cfg_saddr4.sin_addr.s_addr; 196 iph->daddr = cfg_daddr4.sin_addr.s_addr; 197 iph->tot_len = htons(sizeof(*iph) + len); 198 iph->check = checksum_fold(iph, sizeof(*iph), 0); 199 200 iph_addr_p = &iph->saddr; 201 202 return iph + 1; 203 } 204 205 static void *build_packet_ipv6(void *_ip6h, uint8_t proto, unsigned int len) 206 { 207 struct ipv6hdr *ip6h = _ip6h; 208 209 memset(ip6h, 0, sizeof(*ip6h)); 210 211 ip6h->version = 6; 212 ip6h->payload_len = htons(len); 213 ip6h->nexthdr = proto; 214 ip6h->hop_limit = 64; 215 ip6h->saddr = cfg_saddr6.sin6_addr; 216 ip6h->daddr = cfg_daddr6.sin6_addr; 217 218 iph_addr_p = &ip6h->saddr; 219 220 return ip6h + 1; 221 } 222 223 static void *build_packet_udp(void *_uh) 224 { 225 struct udphdr *uh = _uh; 226 227 uh->source = htons(cfg_port_src); 228 uh->dest = htons(cfg_port_dst); 229 uh->len = htons(sizeof(*uh) + cfg_payload_len); 230 uh->check = 0; 231 232 /* choose source port so that uh->check adds up to zero */ 233 if (cfg_zero_sum) { 234 uh->source = 0; 235 uh->source = checksum(uh, IPPROTO_UDP, sizeof(*uh) + cfg_payload_len); 236 237 fprintf(stderr, "tx: changing sport: %hu -> %hu\n", 238 cfg_port_src, ntohs(uh->source)); 239 cfg_port_src = ntohs(uh->source); 240 } 241 242 if (cfg_zero_disable) 243 uh->check = 0; 244 else 245 uh->check = checksum(uh, IPPROTO_UDP, sizeof(*uh) + cfg_payload_len); 246 247 if (cfg_bad_csum) 248 uh->check = ~uh->check; 249 250 fprintf(stderr, "tx: sending checksum: 0x%x\n", uh->check); 251 return uh + 1; 252 } 253 254 static void *build_packet_tcp(void *_th) 255 { 256 struct tcphdr *th = _th; 257 258 th->source = htons(cfg_port_src); 259 th->dest = htons(cfg_port_dst); 260 th->doff = 5; 261 th->check = 0; 262 263 th->check = checksum(th, IPPROTO_TCP, sizeof(*th) + cfg_payload_len); 264 265 if (cfg_bad_csum) 266 th->check = ~th->check; 267 268 fprintf(stderr, "tx: sending checksum: 0x%x\n", th->check); 269 return th + 1; 270 } 271 272 static char *build_packet_udp_encap(void *_uh) 273 { 274 struct udphdr *uh = _uh; 275 struct udp_encap_hdr *eh = _uh + sizeof(*uh); 276 277 /* outer dst == inner dst, to simplify BPF filter 278 * outer src != inner src, to demultiplex on recv 279 */ 280 uh->dest = htons(cfg_port_dst); 281 uh->source = htons(cfg_port_src_encap); 282 uh->check = 0; 283 uh->len = htons(sizeof(*uh) + 284 sizeof(*eh) + 285 sizeof(struct tcphdr) + 286 cfg_payload_len); 287 288 eh->nexthdr = IPPROTO_TCP; 289 290 return build_packet_tcp(eh + 1); 291 } 292 293 static char *build_packet(char *buf, int max_len, int *len) 294 { 295 uint8_t proto; 296 char *off; 297 int tlen; 298 299 if (cfg_random_seed) { 300 int *buf32 = (void *)buf; 301 int i; 302 303 for (i = 0; i < (max_len / sizeof(int)); i++) 304 buf32[i] = rand(); 305 } else { 306 memset(buf, cfg_payload_char, max_len); 307 } 308 309 if (cfg_proto == IPPROTO_UDP) 310 tlen = sizeof(struct udphdr) + cfg_payload_len; 311 else 312 tlen = sizeof(struct tcphdr) + cfg_payload_len; 313 314 if (cfg_encap) { 315 proto = IPPROTO_UDP; 316 tlen += ENC_HEADER_LEN; 317 } else { 318 proto = cfg_proto; 319 } 320 321 if (cfg_family == PF_INET) 322 off = build_packet_ipv4(buf, proto, tlen); 323 else 324 off = build_packet_ipv6(buf, proto, tlen); 325 326 if (cfg_encap) 327 off = build_packet_udp_encap(off); 328 else if (cfg_proto == IPPROTO_UDP) 329 off = build_packet_udp(off); 330 else 331 off = build_packet_tcp(off); 332 333 /* only pass the payload, but still compute headers for cfg_zero_sum */ 334 if (cfg_send_udp) { 335 *len = cfg_payload_len; 336 return off; 337 } 338 339 *len = off - buf + cfg_payload_len; 340 return buf; 341 } 342 343 static int open_inet(int ipproto, int protocol) 344 { 345 int fd; 346 347 fd = socket(cfg_family, ipproto, protocol); 348 if (fd == -1) 349 error(1, errno, "socket inet"); 350 351 if (cfg_family == PF_INET6) { 352 /* may have been updated by cfg_zero_sum */ 353 cfg_saddr6.sin6_port = htons(cfg_port_src); 354 355 if (bind(fd, (void *)&cfg_saddr6, sizeof(cfg_saddr6))) 356 error(1, errno, "bind dgram 6"); 357 if (connect(fd, (void *)&cfg_daddr6, sizeof(cfg_daddr6))) 358 error(1, errno, "connect dgram 6"); 359 } else { 360 /* may have been updated by cfg_zero_sum */ 361 cfg_saddr4.sin_port = htons(cfg_port_src); 362 363 if (bind(fd, (void *)&cfg_saddr4, sizeof(cfg_saddr4))) 364 error(1, errno, "bind dgram 4"); 365 if (connect(fd, (void *)&cfg_daddr4, sizeof(cfg_daddr4))) 366 error(1, errno, "connect dgram 4"); 367 } 368 369 return fd; 370 } 371 372 static int open_packet(void) 373 { 374 int fd, one = 1; 375 376 fd = socket(PF_PACKET, SOCK_RAW, 0); 377 if (fd == -1) 378 error(1, errno, "socket packet"); 379 380 if (setsockopt(fd, SOL_PACKET, PACKET_VNET_HDR, &one, sizeof(one))) 381 error(1, errno, "setsockopt packet_vnet_ndr"); 382 383 return fd; 384 } 385 386 static void send_inet(int fd, const char *buf, int len) 387 { 388 int ret; 389 390 ret = write(fd, buf, len); 391 if (ret == -1) 392 error(1, errno, "write"); 393 if (ret != len) 394 error(1, 0, "write: %d", ret); 395 } 396 397 static void eth_str_to_addr(const char *str, unsigned char *eth) 398 { 399 if (sscanf(str, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", 400 ð[0], ð[1], ð[2], ð[3], ð[4], ð[5]) != 6) 401 error(1, 0, "cannot parse mac addr %s", str); 402 } 403 404 static void send_packet(int fd, const char *buf, int len) 405 { 406 struct virtio_net_hdr vh = {0}; 407 struct sockaddr_ll addr = {0}; 408 struct msghdr msg = {0}; 409 struct ethhdr eth; 410 struct iovec iov[3]; 411 int ret; 412 413 addr.sll_family = AF_PACKET; 414 addr.sll_halen = ETH_ALEN; 415 addr.sll_ifindex = if_nametoindex(cfg_ifname); 416 if (!addr.sll_ifindex) 417 error(1, errno, "if_nametoindex %s", cfg_ifname); 418 419 vh.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM; 420 if (cfg_family == PF_INET6) { 421 vh.csum_start = sizeof(struct ethhdr) + sizeof(struct ipv6hdr); 422 addr.sll_protocol = htons(ETH_P_IPV6); 423 } else { 424 vh.csum_start = sizeof(struct ethhdr) + sizeof(struct iphdr); 425 addr.sll_protocol = htons(ETH_P_IP); 426 } 427 428 if (cfg_encap) 429 vh.csum_start += ENC_HEADER_LEN; 430 431 if (cfg_proto == IPPROTO_TCP) { 432 vh.csum_offset = __builtin_offsetof(struct tcphdr, check); 433 vh.hdr_len = vh.csum_start + sizeof(struct tcphdr); 434 } else { 435 vh.csum_offset = __builtin_offsetof(struct udphdr, check); 436 vh.hdr_len = vh.csum_start + sizeof(struct udphdr); 437 } 438 439 eth_str_to_addr(cfg_mac_src, eth.h_source); 440 eth_str_to_addr(cfg_mac_dst, eth.h_dest); 441 eth.h_proto = addr.sll_protocol; 442 443 iov[0].iov_base = &vh; 444 iov[0].iov_len = sizeof(vh); 445 446 iov[1].iov_base = ð 447 iov[1].iov_len = sizeof(eth); 448 449 iov[2].iov_base = (void *)buf; 450 iov[2].iov_len = len; 451 452 msg.msg_iov = iov; 453 msg.msg_iovlen = sizeof(iov) / sizeof(iov[0]); 454 455 msg.msg_name = &addr; 456 msg.msg_namelen = sizeof(addr); 457 458 ret = sendmsg(fd, &msg, 0); 459 if (ret == -1) 460 error(1, errno, "sendmsg packet"); 461 if (ret != sizeof(vh) + sizeof(eth) + len) 462 error(1, errno, "sendmsg packet: %u", ret); 463 } 464 465 static int recv_prepare_udp(void) 466 { 467 int fd; 468 469 fd = socket(cfg_family, SOCK_DGRAM, 0); 470 if (fd == -1) 471 error(1, errno, "socket r"); 472 473 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, 474 &cfg_rcvbuf, sizeof(cfg_rcvbuf))) 475 error(1, errno, "setsockopt SO_RCVBUF r"); 476 477 if (cfg_family == PF_INET6) { 478 if (bind(fd, (void *)&cfg_daddr6, sizeof(cfg_daddr6))) 479 error(1, errno, "bind r"); 480 } else { 481 if (bind(fd, (void *)&cfg_daddr4, sizeof(cfg_daddr4))) 482 error(1, errno, "bind r"); 483 } 484 485 return fd; 486 } 487 488 /* Filter out all traffic that is not cfg_proto with our destination port. 489 * 490 * Otherwise background noise may cause PF_PACKET receive queue overflow, 491 * dropping the expected packets and failing the test. 492 */ 493 static void __recv_prepare_packet_filter(int fd, int off_nexthdr, int off_dport) 494 { 495 struct sock_filter filter[] = { 496 BPF_STMT(BPF_LD + BPF_B + BPF_ABS, SKF_AD_OFF + SKF_AD_PKTTYPE), 497 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, PACKET_HOST, 0, 4), 498 BPF_STMT(BPF_LD + BPF_B + BPF_ABS, off_nexthdr), 499 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, cfg_encap ? IPPROTO_UDP : cfg_proto, 0, 2), 500 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, off_dport), 501 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, cfg_port_dst, 1, 0), 502 BPF_STMT(BPF_RET + BPF_K, 0), 503 BPF_STMT(BPF_RET + BPF_K, 0xFFFF), 504 }; 505 struct sock_fprog prog = {}; 506 507 prog.filter = filter; 508 prog.len = sizeof(filter) / sizeof(struct sock_filter); 509 if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog))) 510 error(1, errno, "setsockopt filter"); 511 } 512 513 static void recv_prepare_packet_filter(int fd) 514 { 515 const int off_dport = offsetof(struct tcphdr, dest); /* same for udp */ 516 517 if (cfg_family == AF_INET) 518 __recv_prepare_packet_filter(fd, offsetof(struct iphdr, protocol), 519 sizeof(struct iphdr) + off_dport); 520 else 521 __recv_prepare_packet_filter(fd, offsetof(struct ipv6hdr, nexthdr), 522 sizeof(struct ipv6hdr) + off_dport); 523 } 524 525 static void recv_prepare_packet_bind(int fd) 526 { 527 struct sockaddr_ll laddr = {0}; 528 529 laddr.sll_family = AF_PACKET; 530 531 if (cfg_family == PF_INET) 532 laddr.sll_protocol = htons(ETH_P_IP); 533 else 534 laddr.sll_protocol = htons(ETH_P_IPV6); 535 536 laddr.sll_ifindex = if_nametoindex(cfg_ifname); 537 if (!laddr.sll_ifindex) 538 error(1, 0, "if_nametoindex %s", cfg_ifname); 539 540 if (bind(fd, (void *)&laddr, sizeof(laddr))) 541 error(1, errno, "bind pf_packet"); 542 } 543 544 static int recv_prepare_packet(void) 545 { 546 int fd, one = 1; 547 548 fd = socket(PF_PACKET, SOCK_DGRAM, 0); 549 if (fd == -1) 550 error(1, errno, "socket p"); 551 552 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, 553 &cfg_rcvbuf, sizeof(cfg_rcvbuf))) 554 error(1, errno, "setsockopt SO_RCVBUF p"); 555 556 /* enable auxdata to recv checksum status (valid vs unknown) */ 557 if (setsockopt(fd, SOL_PACKET, PACKET_AUXDATA, &one, sizeof(one))) 558 error(1, errno, "setsockopt auxdata"); 559 560 /* install filter to restrict packet flow to match */ 561 recv_prepare_packet_filter(fd); 562 563 /* bind to address family to start packet flow */ 564 recv_prepare_packet_bind(fd); 565 566 return fd; 567 } 568 569 static int recv_udp(int fd) 570 { 571 static char buf[MAX_PAYLOAD_LEN]; 572 int ret, count = 0; 573 574 while (1) { 575 ret = recv(fd, buf, sizeof(buf), MSG_DONTWAIT); 576 if (ret == -1 && errno == EAGAIN) 577 break; 578 if (ret == -1) 579 error(1, errno, "recv r"); 580 581 fprintf(stderr, "rx: udp: len=%u\n", ret); 582 count++; 583 } 584 585 return count; 586 } 587 588 static int recv_verify_csum(void *th, int len, uint16_t sport, uint16_t csum_field) 589 { 590 uint16_t csum; 591 592 csum = checksum(th, cfg_proto, len); 593 594 fprintf(stderr, "rx: pkt: sport=%hu len=%u csum=0x%hx verify=0x%hx\n", 595 sport, len, csum_field, csum); 596 597 /* csum must be zero unless cfg_bad_csum indicates bad csum */ 598 if (csum && !cfg_bad_csum) { 599 fprintf(stderr, "pkt: bad csum\n"); 600 return 1; 601 } else if (cfg_bad_csum && !csum) { 602 fprintf(stderr, "pkt: good csum, while bad expected\n"); 603 return 1; 604 } 605 606 if (cfg_zero_sum && csum_field != 0xFFFF) { 607 fprintf(stderr, "pkt: zero csum: field should be 0xFFFF, is 0x%hx\n", csum_field); 608 return 1; 609 } 610 611 return 0; 612 } 613 614 static int recv_verify_packet_tcp(void *th, int len) 615 { 616 struct tcphdr *tcph = th; 617 618 if (len < sizeof(*tcph) || tcph->dest != htons(cfg_port_dst)) 619 return -1; 620 621 return recv_verify_csum(th, len, ntohs(tcph->source), tcph->check); 622 } 623 624 static int recv_verify_packet_udp_encap(void *th, int len) 625 { 626 struct udp_encap_hdr *eh = th; 627 628 if (len < sizeof(*eh) || eh->nexthdr != IPPROTO_TCP) 629 return -1; 630 631 return recv_verify_packet_tcp(eh + 1, len - sizeof(*eh)); 632 } 633 634 static int recv_verify_packet_udp(void *th, int len) 635 { 636 struct udphdr *udph = th; 637 638 if (len < sizeof(*udph)) 639 return -1; 640 641 if (udph->dest != htons(cfg_port_dst)) 642 return -1; 643 644 if (udph->source == htons(cfg_port_src_encap)) 645 return recv_verify_packet_udp_encap(udph + 1, 646 len - sizeof(*udph)); 647 648 return recv_verify_csum(th, len, ntohs(udph->source), udph->check); 649 } 650 651 static int recv_verify_packet_ipv4(void *nh, int len) 652 { 653 struct iphdr *iph = nh; 654 uint16_t proto = cfg_encap ? IPPROTO_UDP : cfg_proto; 655 656 if (len < sizeof(*iph) || iph->protocol != proto) 657 return -1; 658 659 iph_addr_p = &iph->saddr; 660 if (proto == IPPROTO_TCP) 661 return recv_verify_packet_tcp(iph + 1, len - sizeof(*iph)); 662 else 663 return recv_verify_packet_udp(iph + 1, len - sizeof(*iph)); 664 } 665 666 static int recv_verify_packet_ipv6(void *nh, int len) 667 { 668 struct ipv6hdr *ip6h = nh; 669 uint16_t proto = cfg_encap ? IPPROTO_UDP : cfg_proto; 670 671 if (len < sizeof(*ip6h) || ip6h->nexthdr != proto) 672 return -1; 673 674 iph_addr_p = &ip6h->saddr; 675 676 if (proto == IPPROTO_TCP) 677 return recv_verify_packet_tcp(ip6h + 1, len - sizeof(*ip6h)); 678 else 679 return recv_verify_packet_udp(ip6h + 1, len - sizeof(*ip6h)); 680 } 681 682 /* return whether auxdata includes TP_STATUS_CSUM_VALID */ 683 static bool recv_verify_packet_csum(struct msghdr *msg) 684 { 685 struct tpacket_auxdata *aux = NULL; 686 struct cmsghdr *cm; 687 688 if (msg->msg_flags & MSG_CTRUNC) 689 error(1, 0, "cmsg: truncated"); 690 691 for (cm = CMSG_FIRSTHDR(msg); cm; cm = CMSG_NXTHDR(msg, cm)) { 692 if (cm->cmsg_level != SOL_PACKET || 693 cm->cmsg_type != PACKET_AUXDATA) 694 error(1, 0, "cmsg: level=%d type=%d\n", 695 cm->cmsg_level, cm->cmsg_type); 696 697 if (cm->cmsg_len != CMSG_LEN(sizeof(struct tpacket_auxdata))) 698 error(1, 0, "cmsg: len=%lu expected=%lu", 699 cm->cmsg_len, CMSG_LEN(sizeof(struct tpacket_auxdata))); 700 701 aux = (void *)CMSG_DATA(cm); 702 } 703 704 if (!aux) 705 error(1, 0, "cmsg: no auxdata"); 706 707 return aux->tp_status & TP_STATUS_CSUM_VALID; 708 } 709 710 static int recv_packet(int fd) 711 { 712 static char _buf[MAX_HEADER_LEN + MAX_PAYLOAD_LEN]; 713 unsigned long total = 0, bad_csums = 0, bad_validations = 0; 714 char ctrl[CMSG_SPACE(sizeof(struct tpacket_auxdata))]; 715 struct pkt *buf = (void *)_buf; 716 struct msghdr msg = {0}; 717 struct iovec iov; 718 int len, ret; 719 720 iov.iov_base = _buf; 721 iov.iov_len = sizeof(_buf); 722 723 msg.msg_iov = &iov; 724 msg.msg_iovlen = 1; 725 726 msg.msg_control = ctrl; 727 msg.msg_controllen = sizeof(ctrl); 728 729 while (1) { 730 msg.msg_flags = 0; 731 732 len = recvmsg(fd, &msg, MSG_DONTWAIT); 733 if (len == -1 && errno == EAGAIN) 734 break; 735 if (len == -1) 736 error(1, errno, "recv p"); 737 738 if (cfg_family == PF_INET6) 739 ret = recv_verify_packet_ipv6(buf, len); 740 else 741 ret = recv_verify_packet_ipv4(buf, len); 742 743 if (ret == -1 /* skip: non-matching */) 744 continue; 745 746 total++; 747 if (ret == 1) 748 bad_csums++; 749 750 /* Fail if kernel returns valid for known bad csum. 751 * Do not fail if kernel does not validate a good csum: 752 * Absence of validation does not imply invalid. 753 */ 754 if (recv_verify_packet_csum(&msg) && cfg_bad_csum) { 755 fprintf(stderr, "cmsg: expected bad csum, pf_packet returns valid\n"); 756 bad_validations++; 757 } 758 } 759 760 if (bad_csums || bad_validations) 761 error(1, 0, "rx: errors at pf_packet: total=%lu bad_csums=%lu bad_valids=%lu\n", 762 total, bad_csums, bad_validations); 763 764 return total; 765 } 766 767 static void parse_args(int argc, char *const argv[]) 768 { 769 const char *daddr = NULL, *saddr = NULL; 770 int c; 771 772 while ((c = getopt(argc, argv, "46d:D:eEi:l:L:n:r:PRs:S:tTuUzZ")) != -1) { 773 switch (c) { 774 case '4': 775 cfg_family = PF_INET; 776 break; 777 case '6': 778 cfg_family = PF_INET6; 779 break; 780 case 'd': 781 cfg_mac_dst = optarg; 782 break; 783 case 'D': 784 daddr = optarg; 785 break; 786 case 'e': 787 cfg_encap = true; 788 break; 789 case 'E': 790 cfg_bad_csum = true; 791 break; 792 case 'i': 793 cfg_ifname = optarg; 794 break; 795 case 'l': 796 cfg_payload_len = strtol(optarg, NULL, 0); 797 break; 798 case 'L': 799 cfg_timeout_ms = strtol(optarg, NULL, 0) * 1000; 800 break; 801 case 'n': 802 cfg_num_pkt = strtol(optarg, NULL, 0); 803 break; 804 case 'r': 805 cfg_random_seed = strtol(optarg, NULL, 0); 806 break; 807 case 'P': 808 cfg_send_pfpacket = true; 809 break; 810 case 'R': 811 /* only Rx: used with two machine tests */ 812 cfg_do_tx = false; 813 break; 814 case 's': 815 cfg_mac_src = optarg; 816 break; 817 case 'S': 818 saddr = optarg; 819 break; 820 case 't': 821 cfg_proto = IPPROTO_TCP; 822 break; 823 case 'T': 824 /* only Tx: used with two machine tests */ 825 cfg_do_rx = false; 826 break; 827 case 'u': 828 cfg_proto = IPPROTO_UDP; 829 break; 830 case 'U': 831 /* send using real udp socket, 832 * to exercise tx checksum offload 833 */ 834 cfg_send_udp = true; 835 break; 836 case 'z': 837 cfg_zero_disable = true; 838 break; 839 case 'Z': 840 cfg_zero_sum = true; 841 break; 842 default: 843 error(1, 0, "unknown arg %c", c); 844 } 845 } 846 847 if (!daddr || !saddr) 848 error(1, 0, "Must pass -D <daddr> and -S <saddr>"); 849 850 if (cfg_do_tx && cfg_send_pfpacket && (!cfg_mac_src || !cfg_mac_dst)) 851 error(1, 0, "Transmit with pf_packet requires mac addresses"); 852 853 if (cfg_payload_len > MAX_PAYLOAD_LEN) 854 error(1, 0, "Payload length exceeds max"); 855 856 if (cfg_proto != IPPROTO_UDP && (cfg_zero_sum || cfg_zero_disable)) 857 error(1, 0, "Only UDP supports zero csum"); 858 859 if (cfg_zero_sum && !cfg_send_udp) 860 error(1, 0, "Zero checksum conversion requires -U for tx csum offload"); 861 if (cfg_zero_sum && cfg_bad_csum) 862 error(1, 0, "Cannot combine zero checksum conversion and invalid checksum"); 863 if (cfg_zero_sum && cfg_random_seed) 864 error(1, 0, "Cannot combine zero checksum conversion with randomization"); 865 866 if (cfg_family == PF_INET6) { 867 cfg_saddr6.sin6_port = htons(cfg_port_src); 868 cfg_daddr6.sin6_port = htons(cfg_port_dst); 869 870 if (inet_pton(cfg_family, daddr, &cfg_daddr6.sin6_addr) != 1) 871 error(1, errno, "Cannot parse ipv6 -D"); 872 if (inet_pton(cfg_family, saddr, &cfg_saddr6.sin6_addr) != 1) 873 error(1, errno, "Cannot parse ipv6 -S"); 874 } else { 875 cfg_saddr4.sin_port = htons(cfg_port_src); 876 cfg_daddr4.sin_port = htons(cfg_port_dst); 877 878 if (inet_pton(cfg_family, daddr, &cfg_daddr4.sin_addr) != 1) 879 error(1, errno, "Cannot parse ipv4 -D"); 880 if (inet_pton(cfg_family, saddr, &cfg_saddr4.sin_addr) != 1) 881 error(1, errno, "Cannot parse ipv4 -S"); 882 } 883 884 if (cfg_do_tx && cfg_random_seed) { 885 /* special case: time-based seed */ 886 if (cfg_random_seed == 1) 887 cfg_random_seed = (unsigned int)gettimeofday_ms(); 888 srand(cfg_random_seed); 889 fprintf(stderr, "randomization seed: %u\n", cfg_random_seed); 890 } 891 } 892 893 static void do_tx(void) 894 { 895 static char _buf[MAX_HEADER_LEN + MAX_PAYLOAD_LEN]; 896 char *buf; 897 int fd, len, i; 898 899 buf = build_packet(_buf, sizeof(_buf), &len); 900 901 if (cfg_send_pfpacket) 902 fd = open_packet(); 903 else if (cfg_send_udp) 904 fd = open_inet(SOCK_DGRAM, 0); 905 else 906 fd = open_inet(SOCK_RAW, IPPROTO_RAW); 907 908 for (i = 0; i < cfg_num_pkt; i++) { 909 if (cfg_send_pfpacket) 910 send_packet(fd, buf, len); 911 else 912 send_inet(fd, buf, len); 913 914 /* randomize each packet individually to increase coverage */ 915 if (cfg_random_seed) { 916 cfg_payload_len = rand() % MAX_PAYLOAD_LEN; 917 buf = build_packet(_buf, sizeof(_buf), &len); 918 } 919 } 920 921 if (close(fd)) 922 error(1, errno, "close tx"); 923 } 924 925 static void do_rx(int fdp, int fdr) 926 { 927 unsigned long count_udp = 0, count_pkt = 0; 928 long tleft, tstop; 929 struct pollfd pfd; 930 931 tstop = gettimeofday_ms() + cfg_timeout_ms; 932 tleft = cfg_timeout_ms; 933 934 do { 935 pfd.events = POLLIN; 936 pfd.fd = fdp; 937 if (poll(&pfd, 1, tleft) == -1) 938 error(1, errno, "poll"); 939 940 if (pfd.revents & POLLIN) 941 count_pkt += recv_packet(fdp); 942 943 if (cfg_proto == IPPROTO_UDP) 944 count_udp += recv_udp(fdr); 945 946 tleft = tstop - gettimeofday_ms(); 947 } while (tleft > 0); 948 949 if (close(fdr)) 950 error(1, errno, "close r"); 951 if (close(fdp)) 952 error(1, errno, "close p"); 953 954 if (count_pkt < cfg_num_pkt) 955 error(1, 0, "rx: missing packets at pf_packet: %lu < %u", 956 count_pkt, cfg_num_pkt); 957 958 if (cfg_proto == IPPROTO_UDP) { 959 if (cfg_bad_csum && count_udp) 960 error(1, 0, "rx: unexpected packets at udp"); 961 if (!cfg_bad_csum && !count_udp) 962 error(1, 0, "rx: missing packets at udp"); 963 } 964 } 965 966 int main(int argc, char *const argv[]) 967 { 968 int fdp = -1, fdr = -1; /* -1 to silence -Wmaybe-uninitialized */ 969 970 parse_args(argc, argv); 971 972 /* open receive sockets before transmitting */ 973 if (cfg_do_rx) { 974 fdp = recv_prepare_packet(); 975 fdr = recv_prepare_udp(); 976 } 977 978 if (cfg_do_tx) 979 do_tx(); 980 981 if (cfg_do_rx) 982 do_rx(fdp, fdr); 983 984 fprintf(stderr, "OK\n"); 985 return 0; 986 } 987