1 // SPDX-License-Identifier: GPL-2.0 2 3 #define _GNU_SOURCE 4 5 #include <stddef.h> 6 #include <arpa/inet.h> 7 #include <error.h> 8 #include <errno.h> 9 #include <net/if.h> 10 #include <linux/in.h> 11 #include <linux/netlink.h> 12 #include <linux/rtnetlink.h> 13 #include <netinet/if_ether.h> 14 #include <netinet/ip.h> 15 #include <netinet/ip6.h> 16 #include <netinet/udp.h> 17 #include <stdbool.h> 18 #include <stdlib.h> 19 #include <stdio.h> 20 #include <string.h> 21 #include <sys/ioctl.h> 22 #include <sys/socket.h> 23 #include <sys/stat.h> 24 #include <sys/time.h> 25 #include <sys/types.h> 26 #include <unistd.h> 27 28 #ifndef ETH_MAX_MTU 29 #define ETH_MAX_MTU 0xFFFFU 30 #endif 31 32 #ifndef UDP_SEGMENT 33 #define UDP_SEGMENT 103 34 #endif 35 36 #ifndef UDP_MAX_SEGMENTS 37 #define UDP_MAX_SEGMENTS (1 << 7UL) 38 #endif 39 40 #define CONST_MTU_TEST 1500 41 42 #define CONST_HDRLEN_V4 (sizeof(struct iphdr) + sizeof(struct udphdr)) 43 #define CONST_HDRLEN_V6 (sizeof(struct ip6_hdr) + sizeof(struct udphdr)) 44 45 #define CONST_MSS_V4 (CONST_MTU_TEST - CONST_HDRLEN_V4) 46 #define CONST_MSS_V6 (CONST_MTU_TEST - CONST_HDRLEN_V6) 47 48 #define CONST_MAX_SEGS_V4 (ETH_MAX_MTU / CONST_MSS_V4) 49 #define CONST_MAX_SEGS_V6 (ETH_MAX_MTU / CONST_MSS_V6) 50 51 static bool cfg_do_ipv4; 52 static bool cfg_do_ipv6; 53 static bool cfg_do_connected; 54 static bool cfg_do_connectionless; 55 static bool cfg_do_msgmore; 56 static bool cfg_do_recv = true; 57 static bool cfg_do_setsockopt; 58 static int cfg_specific_test_id = -1; 59 60 static unsigned short cfg_port = 9000; 61 62 static char buf[ETH_MAX_MTU]; 63 64 struct testcase { 65 int tlen; /* send() buffer size, may exceed mss */ 66 bool tfail; /* send() call is expected to fail */ 67 int gso_len; /* mss after applying gso */ 68 int r_num_mss; /* recv(): number of calls of full mss */ 69 int r_len_last; /* recv(): size of last non-mss dgram, if any */ 70 bool v6_ext_hdr; /* send() dgrams with IPv6 extension headers */ 71 }; 72 73 const struct in6_addr addr6 = { 74 { { 0xfd, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 } }, /* fd00::1 */ 75 }; 76 77 const struct in_addr addr4 = { 78 __constant_htonl(0x0a000001), /* 10.0.0.1 */ 79 }; 80 81 static const char ipv6_hopopts_pad1[8] = { 0 }; 82 83 struct testcase testcases_v4[] = { 84 { 85 /* no GSO: send a single byte */ 86 .tlen = 1, 87 .r_len_last = 1, 88 }, 89 { 90 /* no GSO: send a single MSS */ 91 .tlen = CONST_MSS_V4, 92 .r_num_mss = 1, 93 }, 94 { 95 /* no GSO: send a single MSS + 1B: fail */ 96 .tlen = CONST_MSS_V4 + 1, 97 .tfail = true, 98 }, 99 { 100 /* send a single MSS: will fall back to no GSO */ 101 .tlen = CONST_MSS_V4, 102 .gso_len = CONST_MSS_V4, 103 .r_num_mss = 1, 104 }, 105 { 106 /* datalen <= MSS < gso_len: will fall back to no GSO */ 107 .tlen = CONST_MSS_V4, 108 .gso_len = CONST_MSS_V4 + 1, 109 .r_num_mss = 0, 110 .r_len_last = CONST_MSS_V4, 111 }, 112 { 113 /* MSS < datalen < gso_len: fail */ 114 .tlen = CONST_MSS_V4 + 1, 115 .gso_len = CONST_MSS_V4 + 2, 116 .tfail = true, 117 }, 118 { 119 /* send a single MSS + 1B */ 120 .tlen = CONST_MSS_V4 + 1, 121 .gso_len = CONST_MSS_V4, 122 .r_num_mss = 1, 123 .r_len_last = 1, 124 }, 125 { 126 /* send exactly 2 MSS */ 127 .tlen = CONST_MSS_V4 * 2, 128 .gso_len = CONST_MSS_V4, 129 .r_num_mss = 2, 130 }, 131 { 132 /* send 2 MSS + 1B */ 133 .tlen = (CONST_MSS_V4 * 2) + 1, 134 .gso_len = CONST_MSS_V4, 135 .r_num_mss = 2, 136 .r_len_last = 1, 137 }, 138 { 139 /* send MAX segs */ 140 .tlen = (ETH_MAX_MTU / CONST_MSS_V4) * CONST_MSS_V4, 141 .gso_len = CONST_MSS_V4, 142 .r_num_mss = (ETH_MAX_MTU / CONST_MSS_V4), 143 }, 144 145 { 146 /* send MAX bytes */ 147 .tlen = ETH_MAX_MTU - CONST_HDRLEN_V4, 148 .gso_len = CONST_MSS_V4, 149 .r_num_mss = CONST_MAX_SEGS_V4, 150 .r_len_last = ETH_MAX_MTU - CONST_HDRLEN_V4 - 151 (CONST_MAX_SEGS_V4 * CONST_MSS_V4), 152 }, 153 { 154 /* send MAX + 1: fail */ 155 .tlen = ETH_MAX_MTU - CONST_HDRLEN_V4 + 1, 156 .gso_len = CONST_MSS_V4, 157 .tfail = true, 158 }, 159 { 160 /* send a single 1B MSS: will fall back to no GSO */ 161 .tlen = 1, 162 .gso_len = 1, 163 .r_num_mss = 1, 164 }, 165 { 166 /* send 2 1B segments */ 167 .tlen = 2, 168 .gso_len = 1, 169 .r_num_mss = 2, 170 }, 171 { 172 /* send 2B + 2B + 1B segments */ 173 .tlen = 5, 174 .gso_len = 2, 175 .r_num_mss = 2, 176 .r_len_last = 1, 177 }, 178 { 179 /* send max number of min sized segments */ 180 .tlen = UDP_MAX_SEGMENTS, 181 .gso_len = 1, 182 .r_num_mss = UDP_MAX_SEGMENTS, 183 }, 184 { 185 /* send max number + 1 of min sized segments: fail */ 186 .tlen = UDP_MAX_SEGMENTS + 1, 187 .gso_len = 1, 188 .tfail = true, 189 }, 190 { 191 /* EOL */ 192 } 193 }; 194 195 #ifndef IP6_MAX_MTU 196 #define IP6_MAX_MTU (ETH_MAX_MTU + sizeof(struct ip6_hdr)) 197 #endif 198 199 struct testcase testcases_v6[] = { 200 { 201 /* no GSO: send a single byte */ 202 .tlen = 1, 203 .r_len_last = 1, 204 }, 205 { 206 /* no GSO: send a single MSS */ 207 .tlen = CONST_MSS_V6, 208 .r_num_mss = 1, 209 }, 210 { 211 /* no GSO: send a single MSS + 1B: fail */ 212 .tlen = CONST_MSS_V6 + 1, 213 .tfail = true, 214 }, 215 { 216 /* send a single MSS: will fall back to no GSO */ 217 .tlen = CONST_MSS_V6, 218 .gso_len = CONST_MSS_V6, 219 .r_num_mss = 1, 220 }, 221 { 222 /* datalen <= MSS < gso_len: will fall back to no GSO */ 223 .tlen = CONST_MSS_V6, 224 .gso_len = CONST_MSS_V6 + 1, 225 .r_num_mss = 0, 226 .r_len_last = CONST_MSS_V6, 227 }, 228 { 229 /* MSS < datalen < gso_len: fail */ 230 .tlen = CONST_MSS_V6 + 1, 231 .gso_len = CONST_MSS_V6 + 2, 232 .tfail = true 233 }, 234 { 235 /* send a single MSS + 1B */ 236 .tlen = CONST_MSS_V6 + 1, 237 .gso_len = CONST_MSS_V6, 238 .r_num_mss = 1, 239 .r_len_last = 1, 240 }, 241 { 242 /* send exactly 2 MSS */ 243 .tlen = CONST_MSS_V6 * 2, 244 .gso_len = CONST_MSS_V6, 245 .r_num_mss = 2, 246 }, 247 { 248 /* send 2 MSS + 1B */ 249 .tlen = (CONST_MSS_V6 * 2) + 1, 250 .gso_len = CONST_MSS_V6, 251 .r_num_mss = 2, 252 .r_len_last = 1, 253 }, 254 { 255 /* send MAX segs */ 256 .tlen = (IP6_MAX_MTU / CONST_MSS_V6) * CONST_MSS_V6, 257 .gso_len = CONST_MSS_V6, 258 .r_num_mss = (IP6_MAX_MTU / CONST_MSS_V6), 259 }, 260 261 { 262 /* send MAX bytes */ 263 .tlen = IP6_MAX_MTU - CONST_HDRLEN_V6, 264 .gso_len = CONST_MSS_V6, 265 .r_num_mss = CONST_MAX_SEGS_V6, 266 .r_len_last = IP6_MAX_MTU - CONST_HDRLEN_V6 - 267 (CONST_MAX_SEGS_V6 * CONST_MSS_V6), 268 }, 269 { 270 /* send MAX + 1: fail */ 271 .tlen = IP6_MAX_MTU - CONST_HDRLEN_V6 + 1, 272 .gso_len = CONST_MSS_V6, 273 .tfail = true, 274 }, 275 { 276 /* send a single 1B MSS: will fall back to no GSO */ 277 .tlen = 1, 278 .gso_len = 1, 279 .r_num_mss = 1, 280 }, 281 { 282 /* send 2 1B segments */ 283 .tlen = 2, 284 .gso_len = 1, 285 .r_num_mss = 2, 286 }, 287 { 288 /* send 2 1B segments with extension headers */ 289 .tlen = 2, 290 .gso_len = 1, 291 .r_num_mss = 2, 292 .v6_ext_hdr = true, 293 }, 294 { 295 /* send 2B + 2B + 1B segments */ 296 .tlen = 5, 297 .gso_len = 2, 298 .r_num_mss = 2, 299 .r_len_last = 1, 300 }, 301 { 302 /* send max number of min sized segments */ 303 .tlen = UDP_MAX_SEGMENTS, 304 .gso_len = 1, 305 .r_num_mss = UDP_MAX_SEGMENTS, 306 }, 307 { 308 /* send max number + 1 of min sized segments: fail */ 309 .tlen = UDP_MAX_SEGMENTS + 1, 310 .gso_len = 1, 311 .tfail = true, 312 }, 313 { 314 /* EOL */ 315 } 316 }; 317 318 static void set_pmtu_discover(int fd, bool is_ipv4) 319 { 320 int level, name, val; 321 322 if (is_ipv4) { 323 level = SOL_IP; 324 name = IP_MTU_DISCOVER; 325 val = IP_PMTUDISC_DO; 326 } else { 327 level = SOL_IPV6; 328 name = IPV6_MTU_DISCOVER; 329 val = IPV6_PMTUDISC_DO; 330 } 331 332 if (setsockopt(fd, level, name, &val, sizeof(val))) 333 error(1, errno, "setsockopt path mtu"); 334 } 335 336 static unsigned int get_path_mtu(int fd, bool is_ipv4) 337 { 338 socklen_t vallen; 339 unsigned int mtu; 340 int ret; 341 342 vallen = sizeof(mtu); 343 if (is_ipv4) 344 ret = getsockopt(fd, SOL_IP, IP_MTU, &mtu, &vallen); 345 else 346 ret = getsockopt(fd, SOL_IPV6, IPV6_MTU, &mtu, &vallen); 347 348 if (ret) 349 error(1, errno, "getsockopt mtu"); 350 351 352 fprintf(stderr, "path mtu (read): %u\n", mtu); 353 return mtu; 354 } 355 356 static bool __send_one(int fd, struct msghdr *msg, int flags) 357 { 358 int ret; 359 360 ret = sendmsg(fd, msg, flags); 361 if (ret == -1 && 362 (errno == EMSGSIZE || errno == ENOMEM || errno == EINVAL)) 363 return false; 364 if (ret == -1) 365 error(1, errno, "sendmsg"); 366 if (ret != msg->msg_iov->iov_len) 367 error(1, 0, "sendto: %d != %llu", ret, 368 (unsigned long long)msg->msg_iov->iov_len); 369 if (msg->msg_flags) 370 error(1, 0, "sendmsg: return flags 0x%x\n", msg->msg_flags); 371 372 return true; 373 } 374 375 static bool send_one(int fd, int len, int gso_len, 376 struct sockaddr *addr, socklen_t alen) 377 { 378 char control[CMSG_SPACE(sizeof(uint16_t))] = {0}; 379 struct msghdr msg = {0}; 380 struct iovec iov = {0}; 381 struct cmsghdr *cm; 382 383 iov.iov_base = buf; 384 iov.iov_len = len; 385 386 msg.msg_iov = &iov; 387 msg.msg_iovlen = 1; 388 389 msg.msg_name = addr; 390 msg.msg_namelen = alen; 391 392 if (gso_len && !cfg_do_setsockopt) { 393 msg.msg_control = control; 394 msg.msg_controllen = sizeof(control); 395 396 cm = CMSG_FIRSTHDR(&msg); 397 cm->cmsg_level = SOL_UDP; 398 cm->cmsg_type = UDP_SEGMENT; 399 cm->cmsg_len = CMSG_LEN(sizeof(uint16_t)); 400 *((uint16_t *) CMSG_DATA(cm)) = gso_len; 401 } 402 403 /* If MSG_MORE, send 1 byte followed by remainder */ 404 if (cfg_do_msgmore && len > 1) { 405 iov.iov_len = 1; 406 if (!__send_one(fd, &msg, MSG_MORE)) 407 error(1, 0, "send 1B failed"); 408 409 iov.iov_base++; 410 iov.iov_len = len - 1; 411 } 412 413 return __send_one(fd, &msg, 0); 414 } 415 416 static int recv_one(int fd, int flags) 417 { 418 int ret; 419 420 ret = recv(fd, buf, sizeof(buf), flags); 421 if (ret == -1 && errno == EAGAIN && (flags & MSG_DONTWAIT)) 422 return 0; 423 if (ret == -1) 424 error(1, errno, "recv"); 425 426 return ret; 427 } 428 429 static void run_one(struct testcase *test, int fdt, int fdr, 430 struct sockaddr *addr, socklen_t alen) 431 { 432 int i, ret, val, mss; 433 bool sent; 434 435 fprintf(stderr, "ipv%d tx:%d gso:%d %s%s\n", 436 addr->sa_family == AF_INET ? 4 : 6, 437 test->tlen, test->gso_len, 438 test->v6_ext_hdr ? "ext-hdr " : "", 439 test->tfail ? "(fail)" : ""); 440 441 if (test->v6_ext_hdr) { 442 if (setsockopt(fdt, IPPROTO_IPV6, IPV6_HOPOPTS, 443 ipv6_hopopts_pad1, sizeof(ipv6_hopopts_pad1))) 444 error(1, errno, "setsockopt ipv6 hopopts"); 445 } 446 447 val = test->gso_len; 448 if (cfg_do_setsockopt) { 449 if (setsockopt(fdt, SOL_UDP, UDP_SEGMENT, &val, sizeof(val))) 450 error(1, errno, "setsockopt udp segment"); 451 } 452 453 sent = send_one(fdt, test->tlen, test->gso_len, addr, alen); 454 if (sent && test->tfail) 455 error(1, 0, "send succeeded while expecting failure"); 456 if (!sent && !test->tfail) 457 error(1, 0, "send failed while expecting success"); 458 459 if (test->v6_ext_hdr) { 460 if (setsockopt(fdt, IPPROTO_IPV6, IPV6_HOPOPTS, NULL, 0)) 461 error(1, errno, "setsockopt ipv6 hopopts clear"); 462 } 463 464 if (!sent) 465 return; 466 467 if (!cfg_do_recv) 468 return; 469 470 if (test->gso_len) 471 mss = test->gso_len; 472 else 473 mss = addr->sa_family == AF_INET ? CONST_MSS_V4 : CONST_MSS_V6; 474 475 476 /* Recv all full MSS datagrams */ 477 for (i = 0; i < test->r_num_mss; i++) { 478 ret = recv_one(fdr, 0); 479 if (ret != mss) 480 error(1, 0, "recv.%d: %d != %d", i, ret, mss); 481 } 482 483 /* Recv the non-full last datagram, if tlen was not a multiple of mss */ 484 if (test->r_len_last) { 485 ret = recv_one(fdr, 0); 486 if (ret != test->r_len_last) 487 error(1, 0, "recv.%d: %d != %d (last)", 488 i, ret, test->r_len_last); 489 } 490 491 /* Verify received all data */ 492 ret = recv_one(fdr, MSG_DONTWAIT); 493 if (ret) 494 error(1, 0, "recv: unexpected datagram"); 495 } 496 497 static void run_all(int fdt, int fdr, struct sockaddr *addr, socklen_t alen) 498 { 499 struct testcase *tests, *test; 500 501 tests = addr->sa_family == AF_INET ? testcases_v4 : testcases_v6; 502 503 for (test = tests; test->tlen; test++) { 504 /* if a specific test is given, then skip all others */ 505 if (cfg_specific_test_id == -1 || 506 cfg_specific_test_id == test - tests) 507 run_one(test, fdt, fdr, addr, alen); 508 } 509 } 510 511 static void run_test(struct sockaddr *addr, socklen_t alen) 512 { 513 struct timeval tv = { .tv_usec = 100 * 1000 }; 514 int fdr, fdt, val; 515 516 fdr = socket(addr->sa_family, SOCK_DGRAM, 0); 517 if (fdr == -1) 518 error(1, errno, "socket r"); 519 520 if (cfg_do_recv) { 521 if (bind(fdr, addr, alen)) 522 error(1, errno, "bind"); 523 } 524 525 /* Have tests fail quickly instead of hang */ 526 if (setsockopt(fdr, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv))) 527 error(1, errno, "setsockopt rcv timeout"); 528 529 fdt = socket(addr->sa_family, SOCK_DGRAM, 0); 530 if (fdt == -1) 531 error(1, errno, "socket t"); 532 533 /* Do not fragment these datagrams: only succeed if GSO works */ 534 set_pmtu_discover(fdt, addr->sa_family == AF_INET); 535 536 if (cfg_do_connectionless) 537 run_all(fdt, fdr, addr, alen); 538 539 if (cfg_do_connected) { 540 if (connect(fdt, addr, alen)) 541 error(1, errno, "connect"); 542 543 val = get_path_mtu(fdt, addr->sa_family == AF_INET); 544 if (val != CONST_MTU_TEST) 545 error(1, 0, "bad path mtu %u\n", val); 546 547 run_all(fdt, fdr, addr, 0 /* use connected addr */); 548 } 549 550 if (close(fdt)) 551 error(1, errno, "close t"); 552 if (close(fdr)) 553 error(1, errno, "close r"); 554 } 555 556 static void run_test_v4(void) 557 { 558 struct sockaddr_in addr = {0}; 559 560 addr.sin_family = AF_INET; 561 addr.sin_port = htons(cfg_port); 562 addr.sin_addr = addr4; 563 564 run_test((void *)&addr, sizeof(addr)); 565 } 566 567 static void run_test_v6(void) 568 { 569 struct sockaddr_in6 addr = {0}; 570 571 addr.sin6_family = AF_INET6; 572 addr.sin6_port = htons(cfg_port); 573 addr.sin6_addr = addr6; 574 575 run_test((void *)&addr, sizeof(addr)); 576 } 577 578 static void parse_opts(int argc, char **argv) 579 { 580 int c; 581 582 while ((c = getopt(argc, argv, "46cCmRst:")) != -1) { 583 switch (c) { 584 case '4': 585 cfg_do_ipv4 = true; 586 break; 587 case '6': 588 cfg_do_ipv6 = true; 589 break; 590 case 'c': 591 cfg_do_connected = true; 592 break; 593 case 'C': 594 cfg_do_connectionless = true; 595 break; 596 case 'm': 597 cfg_do_msgmore = true; 598 break; 599 case 'R': 600 cfg_do_recv = false; 601 break; 602 case 's': 603 cfg_do_setsockopt = true; 604 break; 605 case 't': 606 cfg_specific_test_id = strtoul(optarg, NULL, 0); 607 break; 608 default: 609 error(1, 0, "%s: parse error", argv[0]); 610 } 611 } 612 } 613 614 int main(int argc, char **argv) 615 { 616 parse_opts(argc, argv); 617 618 if (cfg_do_ipv4) 619 run_test_v4(); 620 if (cfg_do_ipv6) 621 run_test_v6(); 622 623 fprintf(stderr, "OK\n"); 624 return 0; 625 } 626