1 // SPDX-License-Identifier: GPL-2.0 2 3 #define _GNU_SOURCE 4 5 #include <assert.h> 6 #include <errno.h> 7 #include <fcntl.h> 8 #include <limits.h> 9 #include <string.h> 10 #include <stdarg.h> 11 #include <stdbool.h> 12 #include <stdint.h> 13 #include <inttypes.h> 14 #include <stdio.h> 15 #include <stdlib.h> 16 #include <strings.h> 17 #include <time.h> 18 #include <unistd.h> 19 20 #include <sys/socket.h> 21 #include <sys/types.h> 22 #include <sys/wait.h> 23 24 #include <netdb.h> 25 #include <netinet/in.h> 26 27 #include <linux/tcp.h> 28 29 static int pf = AF_INET; 30 31 #ifndef IPPROTO_MPTCP 32 #define IPPROTO_MPTCP 262 33 #endif 34 #ifndef SOL_MPTCP 35 #define SOL_MPTCP 284 36 #endif 37 38 #ifndef MPTCP_INFO 39 struct mptcp_info { 40 __u8 mptcpi_subflows; 41 __u8 mptcpi_add_addr_signal; 42 __u8 mptcpi_add_addr_accepted; 43 __u8 mptcpi_subflows_max; 44 __u8 mptcpi_add_addr_signal_max; 45 __u8 mptcpi_add_addr_accepted_max; 46 __u32 mptcpi_flags; 47 __u32 mptcpi_token; 48 __u64 mptcpi_write_seq; 49 __u64 mptcpi_snd_una; 50 __u64 mptcpi_rcv_nxt; 51 __u8 mptcpi_local_addr_used; 52 __u8 mptcpi_local_addr_max; 53 __u8 mptcpi_csum_enabled; 54 }; 55 56 struct mptcp_subflow_data { 57 __u32 size_subflow_data; /* size of this structure in userspace */ 58 __u32 num_subflows; /* must be 0, set by kernel */ 59 __u32 size_kernel; /* must be 0, set by kernel */ 60 __u32 size_user; /* size of one element in data[] */ 61 } __attribute__((aligned(8))); 62 63 struct mptcp_subflow_addrs { 64 union { 65 __kernel_sa_family_t sa_family; 66 struct sockaddr sa_local; 67 struct sockaddr_in sin_local; 68 struct sockaddr_in6 sin6_local; 69 struct __kernel_sockaddr_storage ss_local; 70 }; 71 union { 72 struct sockaddr sa_remote; 73 struct sockaddr_in sin_remote; 74 struct sockaddr_in6 sin6_remote; 75 struct __kernel_sockaddr_storage ss_remote; 76 }; 77 }; 78 79 #define MPTCP_INFO 1 80 #define MPTCP_TCPINFO 2 81 #define MPTCP_SUBFLOW_ADDRS 3 82 #endif 83 84 struct so_state { 85 struct mptcp_info mi; 86 uint64_t mptcpi_rcv_delta; 87 uint64_t tcpi_rcv_delta; 88 }; 89 90 static void die_perror(const char *msg) 91 { 92 perror(msg); 93 exit(1); 94 } 95 96 static void die_usage(int r) 97 { 98 fprintf(stderr, "Usage: mptcp_sockopt [-6]\n"); 99 exit(r); 100 } 101 102 static void xerror(const char *fmt, ...) 103 { 104 va_list ap; 105 106 va_start(ap, fmt); 107 vfprintf(stderr, fmt, ap); 108 va_end(ap); 109 fputc('\n', stderr); 110 exit(1); 111 } 112 113 static const char *getxinfo_strerr(int err) 114 { 115 if (err == EAI_SYSTEM) 116 return strerror(errno); 117 118 return gai_strerror(err); 119 } 120 121 static void xgetaddrinfo(const char *node, const char *service, 122 const struct addrinfo *hints, 123 struct addrinfo **res) 124 { 125 int err = getaddrinfo(node, service, hints, res); 126 127 if (err) { 128 const char *errstr = getxinfo_strerr(err); 129 130 fprintf(stderr, "Fatal: getaddrinfo(%s:%s): %s\n", 131 node ? node : "", service ? service : "", errstr); 132 exit(1); 133 } 134 } 135 136 static int sock_listen_mptcp(const char * const listenaddr, 137 const char * const port) 138 { 139 int sock = -1; 140 struct addrinfo hints = { 141 .ai_protocol = IPPROTO_TCP, 142 .ai_socktype = SOCK_STREAM, 143 .ai_flags = AI_PASSIVE | AI_NUMERICHOST 144 }; 145 146 hints.ai_family = pf; 147 148 struct addrinfo *a, *addr; 149 int one = 1; 150 151 xgetaddrinfo(listenaddr, port, &hints, &addr); 152 hints.ai_family = pf; 153 154 for (a = addr; a; a = a->ai_next) { 155 sock = socket(a->ai_family, a->ai_socktype, IPPROTO_MPTCP); 156 if (sock < 0) 157 continue; 158 159 if (-1 == setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one, 160 sizeof(one))) 161 perror("setsockopt"); 162 163 if (bind(sock, a->ai_addr, a->ai_addrlen) == 0) 164 break; /* success */ 165 166 perror("bind"); 167 close(sock); 168 sock = -1; 169 } 170 171 freeaddrinfo(addr); 172 173 if (sock < 0) 174 xerror("could not create listen socket"); 175 176 if (listen(sock, 20)) 177 die_perror("listen"); 178 179 return sock; 180 } 181 182 static int sock_connect_mptcp(const char * const remoteaddr, 183 const char * const port, int proto) 184 { 185 struct addrinfo hints = { 186 .ai_protocol = IPPROTO_TCP, 187 .ai_socktype = SOCK_STREAM, 188 }; 189 struct addrinfo *a, *addr; 190 int sock = -1; 191 192 hints.ai_family = pf; 193 194 xgetaddrinfo(remoteaddr, port, &hints, &addr); 195 for (a = addr; a; a = a->ai_next) { 196 sock = socket(a->ai_family, a->ai_socktype, proto); 197 if (sock < 0) 198 continue; 199 200 if (connect(sock, a->ai_addr, a->ai_addrlen) == 0) 201 break; /* success */ 202 203 die_perror("connect"); 204 } 205 206 if (sock < 0) 207 xerror("could not create connect socket"); 208 209 freeaddrinfo(addr); 210 return sock; 211 } 212 213 static void parse_opts(int argc, char **argv) 214 { 215 int c; 216 217 while ((c = getopt(argc, argv, "h6")) != -1) { 218 switch (c) { 219 case 'h': 220 die_usage(0); 221 break; 222 case '6': 223 pf = AF_INET6; 224 break; 225 default: 226 die_usage(1); 227 break; 228 } 229 } 230 } 231 232 static void do_getsockopt_bogus_sf_data(int fd, int optname) 233 { 234 struct mptcp_subflow_data good_data; 235 struct bogus_data { 236 struct mptcp_subflow_data d; 237 char buf[2]; 238 } bd; 239 socklen_t olen, _olen; 240 int ret; 241 242 memset(&bd, 0, sizeof(bd)); 243 memset(&good_data, 0, sizeof(good_data)); 244 245 olen = sizeof(good_data); 246 good_data.size_subflow_data = olen; 247 248 ret = getsockopt(fd, SOL_MPTCP, optname, &bd, &olen); 249 assert(ret < 0); /* 0 size_subflow_data */ 250 assert(olen == sizeof(good_data)); 251 252 bd.d = good_data; 253 254 ret = getsockopt(fd, SOL_MPTCP, optname, &bd, &olen); 255 assert(ret == 0); 256 assert(olen == sizeof(good_data)); 257 assert(bd.d.num_subflows == 1); 258 assert(bd.d.size_kernel > 0); 259 assert(bd.d.size_user == 0); 260 261 bd.d = good_data; 262 _olen = rand() % olen; 263 olen = _olen; 264 ret = getsockopt(fd, SOL_MPTCP, optname, &bd, &olen); 265 assert(ret < 0); /* bogus olen */ 266 assert(olen == _olen); /* must be unchanged */ 267 268 bd.d = good_data; 269 olen = sizeof(good_data); 270 bd.d.size_kernel = 1; 271 ret = getsockopt(fd, SOL_MPTCP, optname, &bd, &olen); 272 assert(ret < 0); /* size_kernel not 0 */ 273 274 bd.d = good_data; 275 olen = sizeof(good_data); 276 bd.d.num_subflows = 1; 277 ret = getsockopt(fd, SOL_MPTCP, optname, &bd, &olen); 278 assert(ret < 0); /* num_subflows not 0 */ 279 280 /* forward compat check: larger struct mptcp_subflow_data on 'old' kernel */ 281 bd.d = good_data; 282 olen = sizeof(bd); 283 bd.d.size_subflow_data = sizeof(bd); 284 285 ret = getsockopt(fd, SOL_MPTCP, optname, &bd, &olen); 286 assert(ret == 0); 287 288 /* olen must be truncated to real data size filled by kernel: */ 289 assert(olen == sizeof(good_data)); 290 291 assert(bd.d.size_subflow_data == sizeof(bd)); 292 293 bd.d = good_data; 294 bd.d.size_subflow_data += 1; 295 bd.d.size_user = 1; 296 olen = bd.d.size_subflow_data + 1; 297 _olen = olen; 298 299 ret = getsockopt(fd, SOL_MPTCP, optname, &bd, &_olen); 300 assert(ret == 0); 301 302 /* no truncation, kernel should have filled 1 byte of optname payload in buf[1]: */ 303 assert(olen == _olen); 304 305 assert(bd.d.size_subflow_data == sizeof(good_data) + 1); 306 assert(bd.buf[0] == 0); 307 } 308 309 static void do_getsockopt_mptcp_info(struct so_state *s, int fd, size_t w) 310 { 311 struct mptcp_info i; 312 socklen_t olen; 313 int ret; 314 315 olen = sizeof(i); 316 ret = getsockopt(fd, SOL_MPTCP, MPTCP_INFO, &i, &olen); 317 318 if (ret < 0) 319 die_perror("getsockopt MPTCP_INFO"); 320 321 assert(olen == sizeof(i)); 322 323 if (s->mi.mptcpi_write_seq == 0) 324 s->mi = i; 325 326 assert(s->mi.mptcpi_write_seq + w == i.mptcpi_write_seq); 327 328 s->mptcpi_rcv_delta = i.mptcpi_rcv_nxt - s->mi.mptcpi_rcv_nxt; 329 } 330 331 static void do_getsockopt_tcp_info(struct so_state *s, int fd, size_t r, size_t w) 332 { 333 struct my_tcp_info { 334 struct mptcp_subflow_data d; 335 struct tcp_info ti[2]; 336 } ti; 337 int ret, tries = 5; 338 socklen_t olen; 339 340 do { 341 memset(&ti, 0, sizeof(ti)); 342 343 ti.d.size_subflow_data = sizeof(struct mptcp_subflow_data); 344 ti.d.size_user = sizeof(struct tcp_info); 345 olen = sizeof(ti); 346 347 ret = getsockopt(fd, SOL_MPTCP, MPTCP_TCPINFO, &ti, &olen); 348 if (ret < 0) 349 xerror("getsockopt MPTCP_TCPINFO (tries %d, %m)"); 350 351 assert(olen <= sizeof(ti)); 352 assert(ti.d.size_user == ti.d.size_kernel); 353 assert(ti.d.size_user == sizeof(struct tcp_info)); 354 assert(ti.d.num_subflows == 1); 355 356 assert(olen > (socklen_t)sizeof(struct mptcp_subflow_data)); 357 olen -= sizeof(struct mptcp_subflow_data); 358 assert(olen == sizeof(struct tcp_info)); 359 360 if (ti.ti[0].tcpi_bytes_sent == w && 361 ti.ti[0].tcpi_bytes_received == r) 362 goto done; 363 364 if (r == 0 && ti.ti[0].tcpi_bytes_sent == w && 365 ti.ti[0].tcpi_bytes_received) { 366 s->tcpi_rcv_delta = ti.ti[0].tcpi_bytes_received; 367 goto done; 368 } 369 370 /* wait and repeat, might be that tx is still ongoing */ 371 sleep(1); 372 } while (tries-- > 0); 373 374 xerror("tcpi_bytes_sent %" PRIu64 ", want %zu. tcpi_bytes_received %" PRIu64 ", want %zu", 375 ti.ti[0].tcpi_bytes_sent, w, ti.ti[0].tcpi_bytes_received, r); 376 377 done: 378 do_getsockopt_bogus_sf_data(fd, MPTCP_TCPINFO); 379 } 380 381 static void do_getsockopt_subflow_addrs(int fd) 382 { 383 struct sockaddr_storage remote, local; 384 socklen_t olen, rlen, llen; 385 int ret; 386 struct my_addrs { 387 struct mptcp_subflow_data d; 388 struct mptcp_subflow_addrs addr[2]; 389 } addrs; 390 391 memset(&addrs, 0, sizeof(addrs)); 392 memset(&local, 0, sizeof(local)); 393 memset(&remote, 0, sizeof(remote)); 394 395 addrs.d.size_subflow_data = sizeof(struct mptcp_subflow_data); 396 addrs.d.size_user = sizeof(struct mptcp_subflow_addrs); 397 olen = sizeof(addrs); 398 399 ret = getsockopt(fd, SOL_MPTCP, MPTCP_SUBFLOW_ADDRS, &addrs, &olen); 400 if (ret < 0) 401 die_perror("getsockopt MPTCP_SUBFLOW_ADDRS"); 402 403 assert(olen <= sizeof(addrs)); 404 assert(addrs.d.size_user == addrs.d.size_kernel); 405 assert(addrs.d.size_user == sizeof(struct mptcp_subflow_addrs)); 406 assert(addrs.d.num_subflows == 1); 407 408 assert(olen > (socklen_t)sizeof(struct mptcp_subflow_data)); 409 olen -= sizeof(struct mptcp_subflow_data); 410 assert(olen == sizeof(struct mptcp_subflow_addrs)); 411 412 llen = sizeof(local); 413 ret = getsockname(fd, (struct sockaddr *)&local, &llen); 414 if (ret < 0) 415 die_perror("getsockname"); 416 rlen = sizeof(remote); 417 ret = getpeername(fd, (struct sockaddr *)&remote, &rlen); 418 if (ret < 0) 419 die_perror("getpeername"); 420 421 assert(rlen > 0); 422 assert(rlen == llen); 423 424 assert(remote.ss_family == local.ss_family); 425 426 assert(memcmp(&local, &addrs.addr[0].ss_local, sizeof(local)) == 0); 427 assert(memcmp(&remote, &addrs.addr[0].ss_remote, sizeof(remote)) == 0); 428 429 memset(&addrs, 0, sizeof(addrs)); 430 431 addrs.d.size_subflow_data = sizeof(struct mptcp_subflow_data); 432 addrs.d.size_user = sizeof(sa_family_t); 433 olen = sizeof(addrs.d) + sizeof(sa_family_t); 434 435 ret = getsockopt(fd, SOL_MPTCP, MPTCP_SUBFLOW_ADDRS, &addrs, &olen); 436 assert(ret == 0); 437 assert(olen == sizeof(addrs.d) + sizeof(sa_family_t)); 438 439 assert(addrs.addr[0].sa_family == pf); 440 assert(addrs.addr[0].sa_family == local.ss_family); 441 442 assert(memcmp(&local, &addrs.addr[0].ss_local, sizeof(local)) != 0); 443 assert(memcmp(&remote, &addrs.addr[0].ss_remote, sizeof(remote)) != 0); 444 445 do_getsockopt_bogus_sf_data(fd, MPTCP_SUBFLOW_ADDRS); 446 } 447 448 static void do_getsockopts(struct so_state *s, int fd, size_t r, size_t w) 449 { 450 do_getsockopt_mptcp_info(s, fd, w); 451 452 do_getsockopt_tcp_info(s, fd, r, w); 453 454 do_getsockopt_subflow_addrs(fd); 455 } 456 457 static void connect_one_server(int fd, int pipefd) 458 { 459 char buf[4096], buf2[4096]; 460 size_t len, i, total; 461 struct so_state s; 462 bool eof = false; 463 ssize_t ret; 464 465 memset(&s, 0, sizeof(s)); 466 467 len = rand() % (sizeof(buf) - 1); 468 469 if (len < 128) 470 len = 128; 471 472 for (i = 0; i < len ; i++) { 473 buf[i] = rand() % 26; 474 buf[i] += 'A'; 475 } 476 477 buf[i] = '\n'; 478 479 do_getsockopts(&s, fd, 0, 0); 480 481 /* un-block server */ 482 ret = read(pipefd, buf2, 4); 483 assert(ret == 4); 484 close(pipefd); 485 486 assert(strncmp(buf2, "xmit", 4) == 0); 487 488 ret = write(fd, buf, len); 489 if (ret < 0) 490 die_perror("write"); 491 492 if (ret != (ssize_t)len) 493 xerror("short write"); 494 495 total = 0; 496 do { 497 ret = read(fd, buf2 + total, sizeof(buf2) - total); 498 if (ret < 0) 499 die_perror("read"); 500 if (ret == 0) { 501 eof = true; 502 break; 503 } 504 505 total += ret; 506 } while (total < len); 507 508 if (total != len) 509 xerror("total %lu, len %lu eof %d\n", total, len, eof); 510 511 if (memcmp(buf, buf2, len)) 512 xerror("data corruption"); 513 514 if (s.tcpi_rcv_delta) 515 assert(s.tcpi_rcv_delta <= total); 516 517 do_getsockopts(&s, fd, ret, ret); 518 519 if (eof) 520 total += 1; /* sequence advances due to FIN */ 521 522 assert(s.mptcpi_rcv_delta == (uint64_t)total); 523 close(fd); 524 } 525 526 static void process_one_client(int fd, int pipefd) 527 { 528 ssize_t ret, ret2, ret3; 529 struct so_state s; 530 char buf[4096]; 531 532 memset(&s, 0, sizeof(s)); 533 do_getsockopts(&s, fd, 0, 0); 534 535 ret = write(pipefd, "xmit", 4); 536 assert(ret == 4); 537 538 ret = read(fd, buf, sizeof(buf)); 539 if (ret < 0) 540 die_perror("read"); 541 542 assert(s.mptcpi_rcv_delta <= (uint64_t)ret); 543 544 if (s.tcpi_rcv_delta) 545 assert(s.tcpi_rcv_delta == (uint64_t)ret); 546 547 ret2 = write(fd, buf, ret); 548 if (ret2 < 0) 549 die_perror("write"); 550 551 /* wait for hangup */ 552 ret3 = read(fd, buf, 1); 553 if (ret3 != 0) 554 xerror("expected EOF, got %lu", ret3); 555 556 do_getsockopts(&s, fd, ret, ret2); 557 if (s.mptcpi_rcv_delta != (uint64_t)ret + 1) 558 xerror("mptcpi_rcv_delta %" PRIu64 ", expect %" PRIu64, s.mptcpi_rcv_delta, ret + 1, s.mptcpi_rcv_delta - ret); 559 close(fd); 560 } 561 562 static int xaccept(int s) 563 { 564 int fd = accept(s, NULL, 0); 565 566 if (fd < 0) 567 die_perror("accept"); 568 569 return fd; 570 } 571 572 static int server(int pipefd) 573 { 574 int fd = -1, r; 575 576 switch (pf) { 577 case AF_INET: 578 fd = sock_listen_mptcp("127.0.0.1", "15432"); 579 break; 580 case AF_INET6: 581 fd = sock_listen_mptcp("::1", "15432"); 582 break; 583 default: 584 xerror("Unknown pf %d\n", pf); 585 break; 586 } 587 588 r = write(pipefd, "conn", 4); 589 assert(r == 4); 590 591 alarm(15); 592 r = xaccept(fd); 593 594 process_one_client(r, pipefd); 595 596 return 0; 597 } 598 599 static void test_ip_tos_sockopt(int fd) 600 { 601 uint8_t tos_in, tos_out; 602 socklen_t s; 603 int r; 604 605 tos_in = rand() & 0xfc; 606 r = setsockopt(fd, SOL_IP, IP_TOS, &tos_in, sizeof(tos_out)); 607 if (r != 0) 608 die_perror("setsockopt IP_TOS"); 609 610 tos_out = 0; 611 s = sizeof(tos_out); 612 r = getsockopt(fd, SOL_IP, IP_TOS, &tos_out, &s); 613 if (r != 0) 614 die_perror("getsockopt IP_TOS"); 615 616 if (tos_in != tos_out) 617 xerror("tos %x != %x socklen_t %d\n", tos_in, tos_out, s); 618 619 if (s != 1) 620 xerror("tos should be 1 byte"); 621 622 s = 0; 623 r = getsockopt(fd, SOL_IP, IP_TOS, &tos_out, &s); 624 if (r != 0) 625 die_perror("getsockopt IP_TOS 0"); 626 if (s != 0) 627 xerror("expect socklen_t == 0"); 628 629 s = -1; 630 r = getsockopt(fd, SOL_IP, IP_TOS, &tos_out, &s); 631 if (r != -1 && errno != EINVAL) 632 die_perror("getsockopt IP_TOS did not indicate -EINVAL"); 633 if (s != -1) 634 xerror("expect socklen_t == -1"); 635 } 636 637 static int client(int pipefd) 638 { 639 int fd = -1; 640 641 alarm(15); 642 643 switch (pf) { 644 case AF_INET: 645 fd = sock_connect_mptcp("127.0.0.1", "15432", IPPROTO_MPTCP); 646 break; 647 case AF_INET6: 648 fd = sock_connect_mptcp("::1", "15432", IPPROTO_MPTCP); 649 break; 650 default: 651 xerror("Unknown pf %d\n", pf); 652 } 653 654 test_ip_tos_sockopt(fd); 655 656 connect_one_server(fd, pipefd); 657 658 return 0; 659 } 660 661 static pid_t xfork(void) 662 { 663 pid_t p = fork(); 664 665 if (p < 0) 666 die_perror("fork"); 667 668 return p; 669 } 670 671 static int rcheck(int wstatus, const char *what) 672 { 673 if (WIFEXITED(wstatus)) { 674 if (WEXITSTATUS(wstatus) == 0) 675 return 0; 676 fprintf(stderr, "%s exited, status=%d\n", what, WEXITSTATUS(wstatus)); 677 return WEXITSTATUS(wstatus); 678 } else if (WIFSIGNALED(wstatus)) { 679 xerror("%s killed by signal %d\n", what, WTERMSIG(wstatus)); 680 } else if (WIFSTOPPED(wstatus)) { 681 xerror("%s stopped by signal %d\n", what, WSTOPSIG(wstatus)); 682 } 683 684 return 111; 685 } 686 687 static void init_rng(void) 688 { 689 int fd = open("/dev/urandom", O_RDONLY); 690 691 if (fd >= 0) { 692 unsigned int foo; 693 ssize_t ret; 694 695 /* can't fail */ 696 ret = read(fd, &foo, sizeof(foo)); 697 assert(ret == sizeof(foo)); 698 699 close(fd); 700 srand(foo); 701 } else { 702 srand(time(NULL)); 703 } 704 } 705 706 int main(int argc, char *argv[]) 707 { 708 int e1, e2, wstatus; 709 pid_t s, c, ret; 710 int pipefds[2]; 711 712 parse_opts(argc, argv); 713 714 init_rng(); 715 716 e1 = pipe(pipefds); 717 if (e1 < 0) 718 die_perror("pipe"); 719 720 s = xfork(); 721 if (s == 0) 722 return server(pipefds[1]); 723 724 close(pipefds[1]); 725 726 /* wait until server bound a socket */ 727 e1 = read(pipefds[0], &e1, 4); 728 assert(e1 == 4); 729 730 c = xfork(); 731 if (c == 0) 732 return client(pipefds[0]); 733 734 close(pipefds[0]); 735 736 ret = waitpid(s, &wstatus, 0); 737 if (ret == -1) 738 die_perror("waitpid"); 739 e1 = rcheck(wstatus, "server"); 740 ret = waitpid(c, &wstatus, 0); 741 if (ret == -1) 742 die_perror("waitpid"); 743 e2 = rcheck(wstatus, "client"); 744 745 return e1 ? e1 : e2; 746 } 747