1// SPDX-License-Identifier: GPL-2.0 2/* 3 * This testsuite provides conformance testing for GRO coalescing. 4 * 5 * Test cases: 6 * 1.data 7 * Data packets of the same size and same header setup with correct 8 * sequence numbers coalesce. The one exception being the last data 9 * packet coalesced: it can be smaller than the rest and coalesced 10 * as long as it is in the same flow. 11 * 2.ack 12 * Pure ACK does not coalesce. 13 * 3.flags 14 * Specific test cases: no packets with PSH, SYN, URG, RST set will 15 * be coalesced. 16 * 4.tcp 17 * Packets with incorrect checksum, non-consecutive seqno and 18 * different TCP header options shouldn't coalesce. Nit: given that 19 * some extension headers have paddings, such as timestamp, headers 20 * that are padding differently would not be coalesced. 21 * 5.ip: 22 * Packets with different (ECN, TTL, TOS) header, ip options or 23 * ip fragments (ipv6) shouldn't coalesce. 24 * 6.large: 25 * Packets larger than GRO_MAX_SIZE packets shouldn't coalesce. 26 * 27 * MSS is defined as 4096 - header because if it is too small 28 * (i.e. 1500 MTU - header), it will result in many packets, 29 * increasing the "large" test case's flakiness. This is because 30 * due to time sensitivity in the coalescing window, the receiver 31 * may not coalesce all of the packets. 32 * 33 * Note the timing issue applies to all of the test cases, so some 34 * flakiness is to be expected. 35 * 36 */ 37 38#define _GNU_SOURCE 39 40#include <arpa/inet.h> 41#include <errno.h> 42#include <error.h> 43#include <getopt.h> 44#include <linux/filter.h> 45#include <linux/if_packet.h> 46#include <linux/ipv6.h> 47#include <net/ethernet.h> 48#include <net/if.h> 49#include <netinet/in.h> 50#include <netinet/ip.h> 51#include <netinet/ip6.h> 52#include <netinet/tcp.h> 53#include <stdbool.h> 54#include <stddef.h> 55#include <stdio.h> 56#include <stdarg.h> 57#include <string.h> 58#include <unistd.h> 59 60#include "../kselftest.h" 61 62#define DPORT 8000 63#define SPORT 1500 64#define PAYLOAD_LEN 100 65#define NUM_PACKETS 4 66#define START_SEQ 100 67#define START_ACK 100 68#define ETH_P_NONE 0 69#define TOTAL_HDR_LEN (ETH_HLEN + sizeof(struct ipv6hdr) + sizeof(struct tcphdr)) 70#define MSS (4096 - sizeof(struct tcphdr) - sizeof(struct ipv6hdr)) 71#define MAX_PAYLOAD (IP_MAXPACKET - sizeof(struct tcphdr) - sizeof(struct ipv6hdr)) 72#define NUM_LARGE_PKT (MAX_PAYLOAD / MSS) 73#define MAX_HDR_LEN (ETH_HLEN + sizeof(struct ipv6hdr) + sizeof(struct tcphdr)) 74#define MIN_EXTHDR_SIZE 8 75#define EXT_PAYLOAD_1 "\x00\x00\x00\x00\x00\x00" 76#define EXT_PAYLOAD_2 "\x11\x11\x11\x11\x11\x11" 77 78#define ipv6_optlen(p) (((p)->hdrlen+1) << 3) /* calculate IPv6 extension header len */ 79#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)])) 80 81static const char *addr6_src = "fdaa::2"; 82static const char *addr6_dst = "fdaa::1"; 83static const char *addr4_src = "192.168.1.200"; 84static const char *addr4_dst = "192.168.1.100"; 85static int proto = -1; 86static uint8_t src_mac[ETH_ALEN], dst_mac[ETH_ALEN]; 87static char *testname = "data"; 88static char *ifname = "eth0"; 89static char *smac = "aa:00:00:00:00:02"; 90static char *dmac = "aa:00:00:00:00:01"; 91static bool verbose; 92static bool tx_socket = true; 93static int tcp_offset = -1; 94static int total_hdr_len = -1; 95static int ethhdr_proto = -1; 96 97static void vlog(const char *fmt, ...) 98{ 99 va_list args; 100 101 if (verbose) { 102 va_start(args, fmt); 103 vfprintf(stderr, fmt, args); 104 va_end(args); 105 } 106} 107 108static void setup_sock_filter(int fd) 109{ 110 const int dport_off = tcp_offset + offsetof(struct tcphdr, dest); 111 const int ethproto_off = offsetof(struct ethhdr, h_proto); 112 int optlen = 0; 113 int ipproto_off, opt_ipproto_off; 114 int next_off; 115 116 if (proto == PF_INET) 117 next_off = offsetof(struct iphdr, protocol); 118 else 119 next_off = offsetof(struct ipv6hdr, nexthdr); 120 ipproto_off = ETH_HLEN + next_off; 121 122 if (strcmp(testname, "ip") == 0) { 123 if (proto == PF_INET) 124 optlen = sizeof(struct ip_timestamp); 125 else { 126 BUILD_BUG_ON(sizeof(struct ip6_hbh) > MIN_EXTHDR_SIZE); 127 BUILD_BUG_ON(sizeof(struct ip6_dest) > MIN_EXTHDR_SIZE); 128 BUILD_BUG_ON(sizeof(struct ip6_frag) > MIN_EXTHDR_SIZE); 129 130 /* same size for HBH and Fragment extension header types */ 131 optlen = MIN_EXTHDR_SIZE; 132 opt_ipproto_off = ETH_HLEN + sizeof(struct ipv6hdr) 133 + offsetof(struct ip6_ext, ip6e_nxt); 134 } 135 } 136 137 /* this filter validates the following: 138 * - packet is IPv4/IPv6 according to the running test. 139 * - packet is TCP. Also handles the case of one extension header and then TCP. 140 * - checks the packet tcp dport equals to DPORT. Also handles the case of one 141 * extension header and then TCP. 142 */ 143 struct sock_filter filter[] = { 144 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, ethproto_off), 145 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ntohs(ethhdr_proto), 0, 9), 146 BPF_STMT(BPF_LD + BPF_B + BPF_ABS, ipproto_off), 147 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_TCP, 2, 0), 148 BPF_STMT(BPF_LD + BPF_B + BPF_ABS, opt_ipproto_off), 149 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_TCP, 0, 5), 150 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, dport_off), 151 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, DPORT, 2, 0), 152 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, dport_off + optlen), 153 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, DPORT, 0, 1), 154 BPF_STMT(BPF_RET + BPF_K, 0xFFFFFFFF), 155 BPF_STMT(BPF_RET + BPF_K, 0), 156 }; 157 158 struct sock_fprog bpf = { 159 .len = ARRAY_SIZE(filter), 160 .filter = filter, 161 }; 162 163 if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf)) < 0) 164 error(1, errno, "error setting filter"); 165} 166 167static uint32_t checksum_nofold(void *data, size_t len, uint32_t sum) 168{ 169 uint16_t *words = data; 170 int i; 171 172 for (i = 0; i < len / 2; i++) 173 sum += words[i]; 174 if (len & 1) 175 sum += ((char *)data)[len - 1]; 176 return sum; 177} 178 179static uint16_t checksum_fold(void *data, size_t len, uint32_t sum) 180{ 181 sum = checksum_nofold(data, len, sum); 182 while (sum > 0xFFFF) 183 sum = (sum & 0xFFFF) + (sum >> 16); 184 return ~sum; 185} 186 187static uint16_t tcp_checksum(void *buf, int payload_len) 188{ 189 struct pseudo_header6 { 190 struct in6_addr saddr; 191 struct in6_addr daddr; 192 uint16_t protocol; 193 uint16_t payload_len; 194 } ph6; 195 struct pseudo_header4 { 196 struct in_addr saddr; 197 struct in_addr daddr; 198 uint16_t protocol; 199 uint16_t payload_len; 200 } ph4; 201 uint32_t sum = 0; 202 203 if (proto == PF_INET6) { 204 if (inet_pton(AF_INET6, addr6_src, &ph6.saddr) != 1) 205 error(1, errno, "inet_pton6 source ip pseudo"); 206 if (inet_pton(AF_INET6, addr6_dst, &ph6.daddr) != 1) 207 error(1, errno, "inet_pton6 dest ip pseudo"); 208 ph6.protocol = htons(IPPROTO_TCP); 209 ph6.payload_len = htons(sizeof(struct tcphdr) + payload_len); 210 211 sum = checksum_nofold(&ph6, sizeof(ph6), 0); 212 } else if (proto == PF_INET) { 213 if (inet_pton(AF_INET, addr4_src, &ph4.saddr) != 1) 214 error(1, errno, "inet_pton source ip pseudo"); 215 if (inet_pton(AF_INET, addr4_dst, &ph4.daddr) != 1) 216 error(1, errno, "inet_pton dest ip pseudo"); 217 ph4.protocol = htons(IPPROTO_TCP); 218 ph4.payload_len = htons(sizeof(struct tcphdr) + payload_len); 219 220 sum = checksum_nofold(&ph4, sizeof(ph4), 0); 221 } 222 223 return checksum_fold(buf, sizeof(struct tcphdr) + payload_len, sum); 224} 225 226static void read_MAC(uint8_t *mac_addr, char *mac) 227{ 228 if (sscanf(mac, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", 229 &mac_addr[0], &mac_addr[1], &mac_addr[2], 230 &mac_addr[3], &mac_addr[4], &mac_addr[5]) != 6) 231 error(1, 0, "sscanf"); 232} 233 234static void fill_datalinklayer(void *buf) 235{ 236 struct ethhdr *eth = buf; 237 238 memcpy(eth->h_dest, dst_mac, ETH_ALEN); 239 memcpy(eth->h_source, src_mac, ETH_ALEN); 240 eth->h_proto = ethhdr_proto; 241} 242 243static void fill_networklayer(void *buf, int payload_len) 244{ 245 struct ipv6hdr *ip6h = buf; 246 struct iphdr *iph = buf; 247 248 if (proto == PF_INET6) { 249 memset(ip6h, 0, sizeof(*ip6h)); 250 251 ip6h->version = 6; 252 ip6h->payload_len = htons(sizeof(struct tcphdr) + payload_len); 253 ip6h->nexthdr = IPPROTO_TCP; 254 ip6h->hop_limit = 8; 255 if (inet_pton(AF_INET6, addr6_src, &ip6h->saddr) != 1) 256 error(1, errno, "inet_pton source ip6"); 257 if (inet_pton(AF_INET6, addr6_dst, &ip6h->daddr) != 1) 258 error(1, errno, "inet_pton dest ip6"); 259 } else if (proto == PF_INET) { 260 memset(iph, 0, sizeof(*iph)); 261 262 iph->version = 4; 263 iph->ihl = 5; 264 iph->ttl = 8; 265 iph->protocol = IPPROTO_TCP; 266 iph->tot_len = htons(sizeof(struct tcphdr) + 267 payload_len + sizeof(struct iphdr)); 268 iph->frag_off = htons(0x4000); /* DF = 1, MF = 0 */ 269 if (inet_pton(AF_INET, addr4_src, &iph->saddr) != 1) 270 error(1, errno, "inet_pton source ip"); 271 if (inet_pton(AF_INET, addr4_dst, &iph->daddr) != 1) 272 error(1, errno, "inet_pton dest ip"); 273 iph->check = checksum_fold(buf, sizeof(struct iphdr), 0); 274 } 275} 276 277static void fill_transportlayer(void *buf, int seq_offset, int ack_offset, 278 int payload_len, int fin) 279{ 280 struct tcphdr *tcph = buf; 281 282 memset(tcph, 0, sizeof(*tcph)); 283 284 tcph->source = htons(SPORT); 285 tcph->dest = htons(DPORT); 286 tcph->seq = ntohl(START_SEQ + seq_offset); 287 tcph->ack_seq = ntohl(START_ACK + ack_offset); 288 tcph->ack = 1; 289 tcph->fin = fin; 290 tcph->doff = 5; 291 tcph->window = htons(TCP_MAXWIN); 292 tcph->urg_ptr = 0; 293 tcph->check = tcp_checksum(tcph, payload_len); 294} 295 296static void write_packet(int fd, char *buf, int len, struct sockaddr_ll *daddr) 297{ 298 int ret = -1; 299 300 ret = sendto(fd, buf, len, 0, (struct sockaddr *)daddr, sizeof(*daddr)); 301 if (ret == -1) 302 error(1, errno, "sendto failure"); 303 if (ret != len) 304 error(1, errno, "sendto wrong length"); 305} 306 307static void create_packet(void *buf, int seq_offset, int ack_offset, 308 int payload_len, int fin) 309{ 310 memset(buf, 0, total_hdr_len); 311 memset(buf + total_hdr_len, 'a', payload_len); 312 fill_transportlayer(buf + tcp_offset, seq_offset, ack_offset, 313 payload_len, fin); 314 fill_networklayer(buf + ETH_HLEN, payload_len); 315 fill_datalinklayer(buf); 316} 317 318/* send one extra flag, not first and not last pkt */ 319static void send_flags(int fd, struct sockaddr_ll *daddr, int psh, int syn, 320 int rst, int urg) 321{ 322 static char flag_buf[MAX_HDR_LEN + PAYLOAD_LEN]; 323 static char buf[MAX_HDR_LEN + PAYLOAD_LEN]; 324 int payload_len, pkt_size, flag, i; 325 struct tcphdr *tcph; 326 327 payload_len = PAYLOAD_LEN * psh; 328 pkt_size = total_hdr_len + payload_len; 329 flag = NUM_PACKETS / 2; 330 331 create_packet(flag_buf, flag * payload_len, 0, payload_len, 0); 332 333 tcph = (struct tcphdr *)(flag_buf + tcp_offset); 334 tcph->psh = psh; 335 tcph->syn = syn; 336 tcph->rst = rst; 337 tcph->urg = urg; 338 tcph->check = 0; 339 tcph->check = tcp_checksum(tcph, payload_len); 340 341 for (i = 0; i < NUM_PACKETS + 1; i++) { 342 if (i == flag) { 343 write_packet(fd, flag_buf, pkt_size, daddr); 344 continue; 345 } 346 create_packet(buf, i * PAYLOAD_LEN, 0, PAYLOAD_LEN, 0); 347 write_packet(fd, buf, total_hdr_len + PAYLOAD_LEN, daddr); 348 } 349} 350 351/* Test for data of same length, smaller than previous 352 * and of different lengths 353 */ 354static void send_data_pkts(int fd, struct sockaddr_ll *daddr, 355 int payload_len1, int payload_len2) 356{ 357 static char buf[ETH_HLEN + IP_MAXPACKET]; 358 359 create_packet(buf, 0, 0, payload_len1, 0); 360 write_packet(fd, buf, total_hdr_len + payload_len1, daddr); 361 create_packet(buf, payload_len1, 0, payload_len2, 0); 362 write_packet(fd, buf, total_hdr_len + payload_len2, daddr); 363} 364 365/* If incoming segments make tracked segment length exceed 366 * legal IP datagram length, do not coalesce 367 */ 368static void send_large(int fd, struct sockaddr_ll *daddr, int remainder) 369{ 370 static char pkts[NUM_LARGE_PKT][TOTAL_HDR_LEN + MSS]; 371 static char last[TOTAL_HDR_LEN + MSS]; 372 static char new_seg[TOTAL_HDR_LEN + MSS]; 373 int i; 374 375 for (i = 0; i < NUM_LARGE_PKT; i++) 376 create_packet(pkts[i], i * MSS, 0, MSS, 0); 377 create_packet(last, NUM_LARGE_PKT * MSS, 0, remainder, 0); 378 create_packet(new_seg, (NUM_LARGE_PKT + 1) * MSS, 0, remainder, 0); 379 380 for (i = 0; i < NUM_LARGE_PKT; i++) 381 write_packet(fd, pkts[i], total_hdr_len + MSS, daddr); 382 write_packet(fd, last, total_hdr_len + remainder, daddr); 383 write_packet(fd, new_seg, total_hdr_len + remainder, daddr); 384} 385 386/* Pure acks and dup acks don't coalesce */ 387static void send_ack(int fd, struct sockaddr_ll *daddr) 388{ 389 static char buf[MAX_HDR_LEN]; 390 391 create_packet(buf, 0, 0, 0, 0); 392 write_packet(fd, buf, total_hdr_len, daddr); 393 write_packet(fd, buf, total_hdr_len, daddr); 394 create_packet(buf, 0, 1, 0, 0); 395 write_packet(fd, buf, total_hdr_len, daddr); 396} 397 398static void recompute_packet(char *buf, char *no_ext, int extlen) 399{ 400 struct tcphdr *tcphdr = (struct tcphdr *)(buf + tcp_offset); 401 struct ipv6hdr *ip6h = (struct ipv6hdr *)(buf + ETH_HLEN); 402 struct iphdr *iph = (struct iphdr *)(buf + ETH_HLEN); 403 404 memmove(buf, no_ext, total_hdr_len); 405 memmove(buf + total_hdr_len + extlen, 406 no_ext + total_hdr_len, PAYLOAD_LEN); 407 408 tcphdr->doff = tcphdr->doff + (extlen / 4); 409 tcphdr->check = 0; 410 tcphdr->check = tcp_checksum(tcphdr, PAYLOAD_LEN + extlen); 411 if (proto == PF_INET) { 412 iph->tot_len = htons(ntohs(iph->tot_len) + extlen); 413 iph->check = 0; 414 iph->check = checksum_fold(iph, sizeof(struct iphdr), 0); 415 } else { 416 ip6h->payload_len = htons(ntohs(ip6h->payload_len) + extlen); 417 } 418} 419 420static void tcp_write_options(char *buf, int kind, int ts) 421{ 422 struct tcp_option_ts { 423 uint8_t kind; 424 uint8_t len; 425 uint32_t tsval; 426 uint32_t tsecr; 427 } *opt_ts = (void *)buf; 428 struct tcp_option_window { 429 uint8_t kind; 430 uint8_t len; 431 uint8_t shift; 432 } *opt_window = (void *)buf; 433 434 switch (kind) { 435 case TCPOPT_NOP: 436 buf[0] = TCPOPT_NOP; 437 break; 438 case TCPOPT_WINDOW: 439 memset(opt_window, 0, sizeof(struct tcp_option_window)); 440 opt_window->kind = TCPOPT_WINDOW; 441 opt_window->len = TCPOLEN_WINDOW; 442 opt_window->shift = 0; 443 break; 444 case TCPOPT_TIMESTAMP: 445 memset(opt_ts, 0, sizeof(struct tcp_option_ts)); 446 opt_ts->kind = TCPOPT_TIMESTAMP; 447 opt_ts->len = TCPOLEN_TIMESTAMP; 448 opt_ts->tsval = ts; 449 opt_ts->tsecr = 0; 450 break; 451 default: 452 error(1, 0, "unimplemented TCP option"); 453 break; 454 } 455} 456 457/* TCP with options is always a permutation of {TS, NOP, NOP}. 458 * Implement different orders to verify coalescing stops. 459 */ 460static void add_standard_tcp_options(char *buf, char *no_ext, int ts, int order) 461{ 462 switch (order) { 463 case 0: 464 tcp_write_options(buf + total_hdr_len, TCPOPT_NOP, 0); 465 tcp_write_options(buf + total_hdr_len + 1, TCPOPT_NOP, 0); 466 tcp_write_options(buf + total_hdr_len + 2 /* two NOP opts */, 467 TCPOPT_TIMESTAMP, ts); 468 break; 469 case 1: 470 tcp_write_options(buf + total_hdr_len, TCPOPT_NOP, 0); 471 tcp_write_options(buf + total_hdr_len + 1, 472 TCPOPT_TIMESTAMP, ts); 473 tcp_write_options(buf + total_hdr_len + 1 + TCPOLEN_TIMESTAMP, 474 TCPOPT_NOP, 0); 475 break; 476 case 2: 477 tcp_write_options(buf + total_hdr_len, TCPOPT_TIMESTAMP, ts); 478 tcp_write_options(buf + total_hdr_len + TCPOLEN_TIMESTAMP + 1, 479 TCPOPT_NOP, 0); 480 tcp_write_options(buf + total_hdr_len + TCPOLEN_TIMESTAMP + 2, 481 TCPOPT_NOP, 0); 482 break; 483 default: 484 error(1, 0, "unknown order"); 485 break; 486 } 487 recompute_packet(buf, no_ext, TCPOLEN_TSTAMP_APPA); 488} 489 490/* Packets with invalid checksum don't coalesce. */ 491static void send_changed_checksum(int fd, struct sockaddr_ll *daddr) 492{ 493 static char buf[MAX_HDR_LEN + PAYLOAD_LEN]; 494 struct tcphdr *tcph = (struct tcphdr *)(buf + tcp_offset); 495 int pkt_size = total_hdr_len + PAYLOAD_LEN; 496 497 create_packet(buf, 0, 0, PAYLOAD_LEN, 0); 498 write_packet(fd, buf, pkt_size, daddr); 499 500 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0); 501 tcph->check = tcph->check - 1; 502 write_packet(fd, buf, pkt_size, daddr); 503} 504 505 /* Packets with non-consecutive sequence number don't coalesce.*/ 506static void send_changed_seq(int fd, struct sockaddr_ll *daddr) 507{ 508 static char buf[MAX_HDR_LEN + PAYLOAD_LEN]; 509 struct tcphdr *tcph = (struct tcphdr *)(buf + tcp_offset); 510 int pkt_size = total_hdr_len + PAYLOAD_LEN; 511 512 create_packet(buf, 0, 0, PAYLOAD_LEN, 0); 513 write_packet(fd, buf, pkt_size, daddr); 514 515 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0); 516 tcph->seq = ntohl(htonl(tcph->seq) + 1); 517 tcph->check = 0; 518 tcph->check = tcp_checksum(tcph, PAYLOAD_LEN); 519 write_packet(fd, buf, pkt_size, daddr); 520} 521 522 /* Packet with different timestamp option or different timestamps 523 * don't coalesce. 524 */ 525static void send_changed_ts(int fd, struct sockaddr_ll *daddr) 526{ 527 static char buf[MAX_HDR_LEN + PAYLOAD_LEN]; 528 static char extpkt[sizeof(buf) + TCPOLEN_TSTAMP_APPA]; 529 int pkt_size = total_hdr_len + PAYLOAD_LEN + TCPOLEN_TSTAMP_APPA; 530 531 create_packet(buf, 0, 0, PAYLOAD_LEN, 0); 532 add_standard_tcp_options(extpkt, buf, 0, 0); 533 write_packet(fd, extpkt, pkt_size, daddr); 534 535 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0); 536 add_standard_tcp_options(extpkt, buf, 0, 0); 537 write_packet(fd, extpkt, pkt_size, daddr); 538 539 create_packet(buf, PAYLOAD_LEN * 2, 0, PAYLOAD_LEN, 0); 540 add_standard_tcp_options(extpkt, buf, 100, 0); 541 write_packet(fd, extpkt, pkt_size, daddr); 542 543 create_packet(buf, PAYLOAD_LEN * 3, 0, PAYLOAD_LEN, 0); 544 add_standard_tcp_options(extpkt, buf, 100, 1); 545 write_packet(fd, extpkt, pkt_size, daddr); 546 547 create_packet(buf, PAYLOAD_LEN * 4, 0, PAYLOAD_LEN, 0); 548 add_standard_tcp_options(extpkt, buf, 100, 2); 549 write_packet(fd, extpkt, pkt_size, daddr); 550} 551 552/* Packet with different tcp options don't coalesce. */ 553static void send_diff_opt(int fd, struct sockaddr_ll *daddr) 554{ 555 static char buf[MAX_HDR_LEN + PAYLOAD_LEN]; 556 static char extpkt1[sizeof(buf) + TCPOLEN_TSTAMP_APPA]; 557 static char extpkt2[sizeof(buf) + TCPOLEN_MAXSEG]; 558 int extpkt1_size = total_hdr_len + PAYLOAD_LEN + TCPOLEN_TSTAMP_APPA; 559 int extpkt2_size = total_hdr_len + PAYLOAD_LEN + TCPOLEN_MAXSEG; 560 561 create_packet(buf, 0, 0, PAYLOAD_LEN, 0); 562 add_standard_tcp_options(extpkt1, buf, 0, 0); 563 write_packet(fd, extpkt1, extpkt1_size, daddr); 564 565 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0); 566 add_standard_tcp_options(extpkt1, buf, 0, 0); 567 write_packet(fd, extpkt1, extpkt1_size, daddr); 568 569 create_packet(buf, PAYLOAD_LEN * 2, 0, PAYLOAD_LEN, 0); 570 tcp_write_options(extpkt2 + MAX_HDR_LEN, TCPOPT_NOP, 0); 571 tcp_write_options(extpkt2 + MAX_HDR_LEN + 1, TCPOPT_WINDOW, 0); 572 recompute_packet(extpkt2, buf, TCPOLEN_WINDOW + 1); 573 write_packet(fd, extpkt2, extpkt2_size, daddr); 574} 575 576static void add_ipv4_ts_option(void *buf, void *optpkt) 577{ 578 struct ip_timestamp *ts = (struct ip_timestamp *)(optpkt + tcp_offset); 579 int optlen = sizeof(struct ip_timestamp); 580 struct iphdr *iph; 581 582 if (optlen % 4) 583 error(1, 0, "ipv4 timestamp length is not a multiple of 4B"); 584 585 ts->ipt_code = IPOPT_TS; 586 ts->ipt_len = optlen; 587 ts->ipt_ptr = 5; 588 ts->ipt_flg = IPOPT_TS_TSONLY; 589 590 memcpy(optpkt, buf, tcp_offset); 591 memcpy(optpkt + tcp_offset + optlen, buf + tcp_offset, 592 sizeof(struct tcphdr) + PAYLOAD_LEN); 593 594 iph = (struct iphdr *)(optpkt + ETH_HLEN); 595 iph->ihl = 5 + (optlen / 4); 596 iph->tot_len = htons(ntohs(iph->tot_len) + optlen); 597 iph->check = 0; 598 iph->check = checksum_fold(iph, sizeof(struct iphdr) + optlen, 0); 599} 600 601static void add_ipv6_exthdr(void *buf, void *optpkt, __u8 exthdr_type, char *ext_payload) 602{ 603 struct ipv6_opt_hdr *exthdr = (struct ipv6_opt_hdr *)(optpkt + tcp_offset); 604 struct ipv6hdr *iph = (struct ipv6hdr *)(optpkt + ETH_HLEN); 605 char *exthdr_payload_start = (char *)(exthdr + 1); 606 607 exthdr->hdrlen = 0; 608 exthdr->nexthdr = IPPROTO_TCP; 609 610 memcpy(exthdr_payload_start, ext_payload, MIN_EXTHDR_SIZE - sizeof(*exthdr)); 611 612 memcpy(optpkt, buf, tcp_offset); 613 memcpy(optpkt + tcp_offset + MIN_EXTHDR_SIZE, buf + tcp_offset, 614 sizeof(struct tcphdr) + PAYLOAD_LEN); 615 616 iph->nexthdr = exthdr_type; 617 iph->payload_len = htons(ntohs(iph->payload_len) + MIN_EXTHDR_SIZE); 618} 619 620static void send_ipv6_exthdr(int fd, struct sockaddr_ll *daddr, char *ext_data1, char *ext_data2) 621{ 622 static char buf[MAX_HDR_LEN + PAYLOAD_LEN]; 623 static char exthdr_pck[sizeof(buf) + MIN_EXTHDR_SIZE]; 624 625 create_packet(buf, 0, 0, PAYLOAD_LEN, 0); 626 add_ipv6_exthdr(buf, exthdr_pck, IPPROTO_HOPOPTS, ext_data1); 627 write_packet(fd, exthdr_pck, total_hdr_len + PAYLOAD_LEN + MIN_EXTHDR_SIZE, daddr); 628 629 create_packet(buf, PAYLOAD_LEN * 1, 0, PAYLOAD_LEN, 0); 630 add_ipv6_exthdr(buf, exthdr_pck, IPPROTO_HOPOPTS, ext_data2); 631 write_packet(fd, exthdr_pck, total_hdr_len + PAYLOAD_LEN + MIN_EXTHDR_SIZE, daddr); 632} 633 634/* IPv4 options shouldn't coalesce */ 635static void send_ip_options(int fd, struct sockaddr_ll *daddr) 636{ 637 static char buf[MAX_HDR_LEN + PAYLOAD_LEN]; 638 static char optpkt[sizeof(buf) + sizeof(struct ip_timestamp)]; 639 int optlen = sizeof(struct ip_timestamp); 640 int pkt_size = total_hdr_len + PAYLOAD_LEN + optlen; 641 642 create_packet(buf, 0, 0, PAYLOAD_LEN, 0); 643 write_packet(fd, buf, total_hdr_len + PAYLOAD_LEN, daddr); 644 645 create_packet(buf, PAYLOAD_LEN * 1, 0, PAYLOAD_LEN, 0); 646 add_ipv4_ts_option(buf, optpkt); 647 write_packet(fd, optpkt, pkt_size, daddr); 648 649 create_packet(buf, PAYLOAD_LEN * 2, 0, PAYLOAD_LEN, 0); 650 write_packet(fd, buf, total_hdr_len + PAYLOAD_LEN, daddr); 651} 652 653/* IPv4 fragments shouldn't coalesce */ 654static void send_fragment4(int fd, struct sockaddr_ll *daddr) 655{ 656 static char buf[IP_MAXPACKET]; 657 struct iphdr *iph = (struct iphdr *)(buf + ETH_HLEN); 658 int pkt_size = total_hdr_len + PAYLOAD_LEN; 659 660 create_packet(buf, 0, 0, PAYLOAD_LEN, 0); 661 write_packet(fd, buf, pkt_size, daddr); 662 663 /* Once fragmented, packet would retain the total_len. 664 * Tcp header is prepared as if rest of data is in follow-up frags, 665 * but follow up frags aren't actually sent. 666 */ 667 memset(buf + total_hdr_len, 'a', PAYLOAD_LEN * 2); 668 fill_transportlayer(buf + tcp_offset, PAYLOAD_LEN, 0, PAYLOAD_LEN * 2, 0); 669 fill_networklayer(buf + ETH_HLEN, PAYLOAD_LEN); 670 fill_datalinklayer(buf); 671 672 iph->frag_off = htons(0x6000); // DF = 1, MF = 1 673 iph->check = 0; 674 iph->check = checksum_fold(iph, sizeof(struct iphdr), 0); 675 write_packet(fd, buf, pkt_size, daddr); 676} 677 678/* IPv4 packets with different ttl don't coalesce.*/ 679static void send_changed_ttl(int fd, struct sockaddr_ll *daddr) 680{ 681 int pkt_size = total_hdr_len + PAYLOAD_LEN; 682 static char buf[MAX_HDR_LEN + PAYLOAD_LEN]; 683 struct iphdr *iph = (struct iphdr *)(buf + ETH_HLEN); 684 685 create_packet(buf, 0, 0, PAYLOAD_LEN, 0); 686 write_packet(fd, buf, pkt_size, daddr); 687 688 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0); 689 iph->ttl = 7; 690 iph->check = 0; 691 iph->check = checksum_fold(iph, sizeof(struct iphdr), 0); 692 write_packet(fd, buf, pkt_size, daddr); 693} 694 695/* Packets with different tos don't coalesce.*/ 696static void send_changed_tos(int fd, struct sockaddr_ll *daddr) 697{ 698 int pkt_size = total_hdr_len + PAYLOAD_LEN; 699 static char buf[MAX_HDR_LEN + PAYLOAD_LEN]; 700 struct iphdr *iph = (struct iphdr *)(buf + ETH_HLEN); 701 struct ipv6hdr *ip6h = (struct ipv6hdr *)(buf + ETH_HLEN); 702 703 create_packet(buf, 0, 0, PAYLOAD_LEN, 0); 704 write_packet(fd, buf, pkt_size, daddr); 705 706 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0); 707 if (proto == PF_INET) { 708 iph->tos = 1; 709 iph->check = 0; 710 iph->check = checksum_fold(iph, sizeof(struct iphdr), 0); 711 } else if (proto == PF_INET6) { 712 ip6h->priority = 0xf; 713 } 714 write_packet(fd, buf, pkt_size, daddr); 715} 716 717/* Packets with different ECN don't coalesce.*/ 718static void send_changed_ECN(int fd, struct sockaddr_ll *daddr) 719{ 720 int pkt_size = total_hdr_len + PAYLOAD_LEN; 721 static char buf[MAX_HDR_LEN + PAYLOAD_LEN]; 722 struct iphdr *iph = (struct iphdr *)(buf + ETH_HLEN); 723 724 create_packet(buf, 0, 0, PAYLOAD_LEN, 0); 725 write_packet(fd, buf, pkt_size, daddr); 726 727 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0); 728 if (proto == PF_INET) { 729 buf[ETH_HLEN + 1] ^= 0x2; // ECN set to 10 730 iph->check = 0; 731 iph->check = checksum_fold(iph, sizeof(struct iphdr), 0); 732 } else { 733 buf[ETH_HLEN + 1] ^= 0x20; // ECN set to 10 734 } 735 write_packet(fd, buf, pkt_size, daddr); 736} 737 738/* IPv6 fragments and packets with extensions don't coalesce.*/ 739static void send_fragment6(int fd, struct sockaddr_ll *daddr) 740{ 741 static char buf[MAX_HDR_LEN + PAYLOAD_LEN]; 742 static char extpkt[MAX_HDR_LEN + PAYLOAD_LEN + 743 sizeof(struct ip6_frag)]; 744 struct ipv6hdr *ip6h = (struct ipv6hdr *)(buf + ETH_HLEN); 745 struct ip6_frag *frag = (void *)(extpkt + tcp_offset); 746 int extlen = sizeof(struct ip6_frag); 747 int bufpkt_len = total_hdr_len + PAYLOAD_LEN; 748 int extpkt_len = bufpkt_len + extlen; 749 int i; 750 751 for (i = 0; i < 2; i++) { 752 create_packet(buf, PAYLOAD_LEN * i, 0, PAYLOAD_LEN, 0); 753 write_packet(fd, buf, bufpkt_len, daddr); 754 } 755 sleep(1); 756 create_packet(buf, PAYLOAD_LEN * 2, 0, PAYLOAD_LEN, 0); 757 memset(extpkt, 0, extpkt_len); 758 759 ip6h->nexthdr = IPPROTO_FRAGMENT; 760 ip6h->payload_len = htons(ntohs(ip6h->payload_len) + extlen); 761 frag->ip6f_nxt = IPPROTO_TCP; 762 763 memcpy(extpkt, buf, tcp_offset); 764 memcpy(extpkt + tcp_offset + extlen, buf + tcp_offset, 765 sizeof(struct tcphdr) + PAYLOAD_LEN); 766 write_packet(fd, extpkt, extpkt_len, daddr); 767 768 create_packet(buf, PAYLOAD_LEN * 3, 0, PAYLOAD_LEN, 0); 769 write_packet(fd, buf, bufpkt_len, daddr); 770} 771 772static void bind_packetsocket(int fd) 773{ 774 struct sockaddr_ll daddr = {}; 775 776 daddr.sll_family = AF_PACKET; 777 daddr.sll_protocol = ethhdr_proto; 778 daddr.sll_ifindex = if_nametoindex(ifname); 779 if (daddr.sll_ifindex == 0) 780 error(1, errno, "if_nametoindex"); 781 782 if (bind(fd, (void *)&daddr, sizeof(daddr)) < 0) 783 error(1, errno, "could not bind socket"); 784} 785 786static void set_timeout(int fd) 787{ 788 struct timeval timeout; 789 790 timeout.tv_sec = 3; 791 timeout.tv_usec = 0; 792 if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, 793 sizeof(timeout)) < 0) 794 error(1, errno, "cannot set timeout, setsockopt failed"); 795} 796 797static void check_recv_pkts(int fd, int *correct_payload, 798 int correct_num_pkts) 799{ 800 static char buffer[IP_MAXPACKET + ETH_HLEN + 1]; 801 struct iphdr *iph = (struct iphdr *)(buffer + ETH_HLEN); 802 struct ipv6hdr *ip6h = (struct ipv6hdr *)(buffer + ETH_HLEN); 803 struct tcphdr *tcph; 804 bool bad_packet = false; 805 int tcp_ext_len = 0; 806 int ip_ext_len = 0; 807 int pkt_size = -1; 808 int data_len = 0; 809 int num_pkt = 0; 810 int i; 811 812 vlog("Expected {"); 813 for (i = 0; i < correct_num_pkts; i++) 814 vlog("%d ", correct_payload[i]); 815 vlog("}, Total %d packets\nReceived {", correct_num_pkts); 816 817 while (1) { 818 ip_ext_len = 0; 819 pkt_size = recv(fd, buffer, IP_MAXPACKET + ETH_HLEN + 1, 0); 820 if (pkt_size < 0) 821 error(1, errno, "could not receive"); 822 823 if (iph->version == 4) 824 ip_ext_len = (iph->ihl - 5) * 4; 825 else if (ip6h->version == 6 && ip6h->nexthdr != IPPROTO_TCP) 826 ip_ext_len = MIN_EXTHDR_SIZE; 827 828 tcph = (struct tcphdr *)(buffer + tcp_offset + ip_ext_len); 829 830 if (tcph->fin) 831 break; 832 833 tcp_ext_len = (tcph->doff - 5) * 4; 834 data_len = pkt_size - total_hdr_len - tcp_ext_len - ip_ext_len; 835 /* Min ethernet frame payload is 46(ETH_ZLEN - ETH_HLEN) by RFC 802.3. 836 * Ipv4/tcp packets without at least 6 bytes of data will be padded. 837 * Packet sockets are protocol agnostic, and will not trim the padding. 838 */ 839 if (pkt_size == ETH_ZLEN && iph->version == 4) { 840 data_len = ntohs(iph->tot_len) 841 - sizeof(struct tcphdr) - sizeof(struct iphdr); 842 } 843 vlog("%d ", data_len); 844 if (data_len != correct_payload[num_pkt]) { 845 vlog("[!=%d]", correct_payload[num_pkt]); 846 bad_packet = true; 847 } 848 num_pkt++; 849 } 850 vlog("}, Total %d packets.\n", num_pkt); 851 if (num_pkt != correct_num_pkts) 852 error(1, 0, "incorrect number of packets"); 853 if (bad_packet) 854 error(1, 0, "incorrect packet geometry"); 855 856 printf("Test succeeded\n\n"); 857} 858 859static void gro_sender(void) 860{ 861 static char fin_pkt[MAX_HDR_LEN]; 862 struct sockaddr_ll daddr = {}; 863 int txfd = -1; 864 865 txfd = socket(PF_PACKET, SOCK_RAW, IPPROTO_RAW); 866 if (txfd < 0) 867 error(1, errno, "socket creation"); 868 869 memset(&daddr, 0, sizeof(daddr)); 870 daddr.sll_ifindex = if_nametoindex(ifname); 871 if (daddr.sll_ifindex == 0) 872 error(1, errno, "if_nametoindex"); 873 daddr.sll_family = AF_PACKET; 874 memcpy(daddr.sll_addr, dst_mac, ETH_ALEN); 875 daddr.sll_halen = ETH_ALEN; 876 create_packet(fin_pkt, PAYLOAD_LEN * 2, 0, 0, 1); 877 878 if (strcmp(testname, "data") == 0) { 879 send_data_pkts(txfd, &daddr, PAYLOAD_LEN, PAYLOAD_LEN); 880 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 881 882 send_data_pkts(txfd, &daddr, PAYLOAD_LEN, PAYLOAD_LEN / 2); 883 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 884 885 send_data_pkts(txfd, &daddr, PAYLOAD_LEN / 2, PAYLOAD_LEN); 886 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 887 } else if (strcmp(testname, "ack") == 0) { 888 send_ack(txfd, &daddr); 889 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 890 } else if (strcmp(testname, "flags") == 0) { 891 send_flags(txfd, &daddr, 1, 0, 0, 0); 892 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 893 894 send_flags(txfd, &daddr, 0, 1, 0, 0); 895 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 896 897 send_flags(txfd, &daddr, 0, 0, 1, 0); 898 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 899 900 send_flags(txfd, &daddr, 0, 0, 0, 1); 901 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 902 } else if (strcmp(testname, "tcp") == 0) { 903 send_changed_checksum(txfd, &daddr); 904 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 905 906 send_changed_seq(txfd, &daddr); 907 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 908 909 send_changed_ts(txfd, &daddr); 910 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 911 912 send_diff_opt(txfd, &daddr); 913 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 914 } else if (strcmp(testname, "ip") == 0) { 915 send_changed_ECN(txfd, &daddr); 916 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 917 918 send_changed_tos(txfd, &daddr); 919 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 920 if (proto == PF_INET) { 921 /* Modified packets may be received out of order. 922 * Sleep function added to enforce test boundaries 923 * so that fin pkts are not received prior to other pkts. 924 */ 925 sleep(1); 926 send_changed_ttl(txfd, &daddr); 927 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 928 929 sleep(1); 930 send_ip_options(txfd, &daddr); 931 sleep(1); 932 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 933 934 sleep(1); 935 send_fragment4(txfd, &daddr); 936 sleep(1); 937 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 938 } else if (proto == PF_INET6) { 939 sleep(1); 940 send_fragment6(txfd, &daddr); 941 sleep(1); 942 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 943 944 sleep(1); 945 /* send IPv6 packets with ext header with same payload */ 946 send_ipv6_exthdr(txfd, &daddr, EXT_PAYLOAD_1, EXT_PAYLOAD_1); 947 sleep(1); 948 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 949 950 sleep(1); 951 /* send IPv6 packets with ext header with different payload */ 952 send_ipv6_exthdr(txfd, &daddr, EXT_PAYLOAD_1, EXT_PAYLOAD_2); 953 sleep(1); 954 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 955 } 956 } else if (strcmp(testname, "large") == 0) { 957 /* 20 is the difference between min iphdr size 958 * and min ipv6hdr size. Like MAX_HDR_SIZE, 959 * MAX_PAYLOAD is defined with the larger header of the two. 960 */ 961 int offset = proto == PF_INET ? 20 : 0; 962 int remainder = (MAX_PAYLOAD + offset) % MSS; 963 964 send_large(txfd, &daddr, remainder); 965 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 966 967 send_large(txfd, &daddr, remainder + 1); 968 write_packet(txfd, fin_pkt, total_hdr_len, &daddr); 969 } else { 970 error(1, 0, "Unknown testcase"); 971 } 972 973 if (close(txfd)) 974 error(1, errno, "socket close"); 975} 976 977static void gro_receiver(void) 978{ 979 static int correct_payload[NUM_PACKETS]; 980 int rxfd = -1; 981 982 rxfd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_NONE)); 983 if (rxfd < 0) 984 error(1, 0, "socket creation"); 985 setup_sock_filter(rxfd); 986 set_timeout(rxfd); 987 bind_packetsocket(rxfd); 988 989 memset(correct_payload, 0, sizeof(correct_payload)); 990 991 if (strcmp(testname, "data") == 0) { 992 printf("pure data packet of same size: "); 993 correct_payload[0] = PAYLOAD_LEN * 2; 994 check_recv_pkts(rxfd, correct_payload, 1); 995 996 printf("large data packets followed by a smaller one: "); 997 correct_payload[0] = PAYLOAD_LEN * 1.5; 998 check_recv_pkts(rxfd, correct_payload, 1); 999 1000 printf("small data packets followed by a larger one: "); 1001 correct_payload[0] = PAYLOAD_LEN / 2; 1002 correct_payload[1] = PAYLOAD_LEN; 1003 check_recv_pkts(rxfd, correct_payload, 2); 1004 } else if (strcmp(testname, "ack") == 0) { 1005 printf("duplicate ack and pure ack: "); 1006 check_recv_pkts(rxfd, correct_payload, 3); 1007 } else if (strcmp(testname, "flags") == 0) { 1008 correct_payload[0] = PAYLOAD_LEN * 3; 1009 correct_payload[1] = PAYLOAD_LEN * 2; 1010 1011 printf("psh flag ends coalescing: "); 1012 check_recv_pkts(rxfd, correct_payload, 2); 1013 1014 correct_payload[0] = PAYLOAD_LEN * 2; 1015 correct_payload[1] = 0; 1016 correct_payload[2] = PAYLOAD_LEN * 2; 1017 printf("syn flag ends coalescing: "); 1018 check_recv_pkts(rxfd, correct_payload, 3); 1019 1020 printf("rst flag ends coalescing: "); 1021 check_recv_pkts(rxfd, correct_payload, 3); 1022 1023 printf("urg flag ends coalescing: "); 1024 check_recv_pkts(rxfd, correct_payload, 3); 1025 } else if (strcmp(testname, "tcp") == 0) { 1026 correct_payload[0] = PAYLOAD_LEN; 1027 correct_payload[1] = PAYLOAD_LEN; 1028 correct_payload[2] = PAYLOAD_LEN; 1029 correct_payload[3] = PAYLOAD_LEN; 1030 1031 printf("changed checksum does not coalesce: "); 1032 check_recv_pkts(rxfd, correct_payload, 2); 1033 1034 printf("Wrong Seq number doesn't coalesce: "); 1035 check_recv_pkts(rxfd, correct_payload, 2); 1036 1037 printf("Different timestamp doesn't coalesce: "); 1038 correct_payload[0] = PAYLOAD_LEN * 2; 1039 check_recv_pkts(rxfd, correct_payload, 4); 1040 1041 printf("Different options doesn't coalesce: "); 1042 correct_payload[0] = PAYLOAD_LEN * 2; 1043 check_recv_pkts(rxfd, correct_payload, 2); 1044 } else if (strcmp(testname, "ip") == 0) { 1045 correct_payload[0] = PAYLOAD_LEN; 1046 correct_payload[1] = PAYLOAD_LEN; 1047 1048 printf("different ECN doesn't coalesce: "); 1049 check_recv_pkts(rxfd, correct_payload, 2); 1050 1051 printf("different tos doesn't coalesce: "); 1052 check_recv_pkts(rxfd, correct_payload, 2); 1053 1054 if (proto == PF_INET) { 1055 printf("different ttl doesn't coalesce: "); 1056 check_recv_pkts(rxfd, correct_payload, 2); 1057 1058 printf("ip options doesn't coalesce: "); 1059 correct_payload[2] = PAYLOAD_LEN; 1060 check_recv_pkts(rxfd, correct_payload, 3); 1061 1062 printf("fragmented ip4 doesn't coalesce: "); 1063 check_recv_pkts(rxfd, correct_payload, 2); 1064 } else if (proto == PF_INET6) { 1065 /* GRO doesn't check for ipv6 hop limit when flushing. 1066 * Hence no corresponding test to the ipv4 case. 1067 */ 1068 printf("fragmented ip6 doesn't coalesce: "); 1069 correct_payload[0] = PAYLOAD_LEN * 2; 1070 correct_payload[1] = PAYLOAD_LEN; 1071 correct_payload[2] = PAYLOAD_LEN; 1072 check_recv_pkts(rxfd, correct_payload, 3); 1073 1074 printf("ipv6 with ext header does coalesce: "); 1075 correct_payload[0] = PAYLOAD_LEN * 2; 1076 check_recv_pkts(rxfd, correct_payload, 1); 1077 1078 printf("ipv6 with ext header with different payloads doesn't coalesce: "); 1079 correct_payload[0] = PAYLOAD_LEN; 1080 correct_payload[1] = PAYLOAD_LEN; 1081 check_recv_pkts(rxfd, correct_payload, 2); 1082 } 1083 } else if (strcmp(testname, "large") == 0) { 1084 int offset = proto == PF_INET ? 20 : 0; 1085 int remainder = (MAX_PAYLOAD + offset) % MSS; 1086 1087 correct_payload[0] = (MAX_PAYLOAD + offset); 1088 correct_payload[1] = remainder; 1089 printf("Shouldn't coalesce if exceed IP max pkt size: "); 1090 check_recv_pkts(rxfd, correct_payload, 2); 1091 1092 /* last segment sent individually, doesn't start new segment */ 1093 correct_payload[0] = correct_payload[0] - remainder; 1094 correct_payload[1] = remainder + 1; 1095 correct_payload[2] = remainder + 1; 1096 check_recv_pkts(rxfd, correct_payload, 3); 1097 } else { 1098 error(1, 0, "Test case error, should never trigger"); 1099 } 1100 1101 if (close(rxfd)) 1102 error(1, 0, "socket close"); 1103} 1104 1105static void parse_args(int argc, char **argv) 1106{ 1107 static const struct option opts[] = { 1108 { "daddr", required_argument, NULL, 'd' }, 1109 { "dmac", required_argument, NULL, 'D' }, 1110 { "iface", required_argument, NULL, 'i' }, 1111 { "ipv4", no_argument, NULL, '4' }, 1112 { "ipv6", no_argument, NULL, '6' }, 1113 { "rx", no_argument, NULL, 'r' }, 1114 { "saddr", required_argument, NULL, 's' }, 1115 { "smac", required_argument, NULL, 'S' }, 1116 { "test", required_argument, NULL, 't' }, 1117 { "verbose", no_argument, NULL, 'v' }, 1118 { 0, 0, 0, 0 } 1119 }; 1120 int c; 1121 1122 while ((c = getopt_long(argc, argv, "46d:D:i:rs:S:t:v", opts, NULL)) != -1) { 1123 switch (c) { 1124 case '4': 1125 proto = PF_INET; 1126 ethhdr_proto = htons(ETH_P_IP); 1127 break; 1128 case '6': 1129 proto = PF_INET6; 1130 ethhdr_proto = htons(ETH_P_IPV6); 1131 break; 1132 case 'd': 1133 addr4_dst = addr6_dst = optarg; 1134 break; 1135 case 'D': 1136 dmac = optarg; 1137 break; 1138 case 'i': 1139 ifname = optarg; 1140 break; 1141 case 'r': 1142 tx_socket = false; 1143 break; 1144 case 's': 1145 addr4_src = addr6_src = optarg; 1146 break; 1147 case 'S': 1148 smac = optarg; 1149 break; 1150 case 't': 1151 testname = optarg; 1152 break; 1153 case 'v': 1154 verbose = true; 1155 break; 1156 default: 1157 error(1, 0, "%s invalid option %c\n", __func__, c); 1158 break; 1159 } 1160 } 1161} 1162 1163int main(int argc, char **argv) 1164{ 1165 parse_args(argc, argv); 1166 1167 if (proto == PF_INET) { 1168 tcp_offset = ETH_HLEN + sizeof(struct iphdr); 1169 total_hdr_len = tcp_offset + sizeof(struct tcphdr); 1170 } else if (proto == PF_INET6) { 1171 tcp_offset = ETH_HLEN + sizeof(struct ipv6hdr); 1172 total_hdr_len = MAX_HDR_LEN; 1173 } else { 1174 error(1, 0, "Protocol family is not ipv4 or ipv6"); 1175 } 1176 1177 read_MAC(src_mac, smac); 1178 read_MAC(dst_mac, dmac); 1179 1180 if (tx_socket) 1181 gro_sender(); 1182 else 1183 gro_receiver(); 1184 1185 fprintf(stderr, "Gro::%s test passed.\n", testname); 1186 return 0; 1187} 1188