1 // SPDX-License-Identifier: GPL-2.0 2 /* nettest - used for functional tests of networking APIs 3 * 4 * Copyright (c) 2013-2019 David Ahern <dsahern@gmail.com>. All rights reserved. 5 */ 6 7 #define _GNU_SOURCE 8 #include <features.h> 9 #include <sys/types.h> 10 #include <sys/ioctl.h> 11 #include <sys/socket.h> 12 #include <sys/wait.h> 13 #include <linux/tcp.h> 14 #include <arpa/inet.h> 15 #include <net/if.h> 16 #include <netinet/in.h> 17 #include <netdb.h> 18 #include <fcntl.h> 19 #include <libgen.h> 20 #include <limits.h> 21 #include <sched.h> 22 #include <stdarg.h> 23 #include <stdio.h> 24 #include <stdlib.h> 25 #include <string.h> 26 #include <unistd.h> 27 #include <time.h> 28 #include <errno.h> 29 30 #ifndef IPV6_UNICAST_IF 31 #define IPV6_UNICAST_IF 76 32 #endif 33 #ifndef IPV6_MULTICAST_IF 34 #define IPV6_MULTICAST_IF 17 35 #endif 36 37 #define DEFAULT_PORT 12345 38 39 #define NS_PREFIX "/run/netns/" 40 41 #ifndef MAX 42 #define MAX(a, b) ((a) > (b) ? (a) : (b)) 43 #endif 44 #ifndef MIN 45 #define MIN(a, b) ((a) < (b) ? (a) : (b)) 46 #endif 47 48 struct sock_args { 49 /* local address */ 50 const char *local_addr_str; 51 const char *client_local_addr_str; 52 union { 53 struct in_addr in; 54 struct in6_addr in6; 55 } local_addr; 56 57 /* remote address */ 58 const char *remote_addr_str; 59 union { 60 struct in_addr in; 61 struct in6_addr in6; 62 } remote_addr; 63 int scope_id; /* remote scope; v6 send only */ 64 65 struct in_addr grp; /* multicast group */ 66 67 unsigned int has_local_ip:1, 68 has_remote_ip:1, 69 has_grp:1, 70 has_expected_laddr:1, 71 has_expected_raddr:1, 72 bind_test_only:1; 73 74 unsigned short port; 75 76 int type; /* DGRAM, STREAM, RAW */ 77 int protocol; 78 int version; /* AF_INET/AF_INET6 */ 79 80 int use_setsockopt; 81 int use_cmsg; 82 const char *dev; 83 const char *server_dev; 84 int ifindex; 85 86 const char *clientns; 87 const char *serverns; 88 89 const char *password; 90 const char *client_pw; 91 /* prefix for MD5 password */ 92 const char *md5_prefix_str; 93 union { 94 struct sockaddr_in v4; 95 struct sockaddr_in6 v6; 96 } md5_prefix; 97 unsigned int prefix_len; 98 99 /* expected addresses and device index for connection */ 100 const char *expected_dev; 101 const char *expected_server_dev; 102 int expected_ifindex; 103 104 /* local address */ 105 const char *expected_laddr_str; 106 union { 107 struct in_addr in; 108 struct in6_addr in6; 109 } expected_laddr; 110 111 /* remote address */ 112 const char *expected_raddr_str; 113 union { 114 struct in_addr in; 115 struct in6_addr in6; 116 } expected_raddr; 117 }; 118 119 static int server_mode; 120 static unsigned int prog_timeout = 5; 121 static unsigned int interactive; 122 static int iter = 1; 123 static char *msg = "Hello world!"; 124 static int msglen; 125 static int quiet; 126 static int try_broadcast = 1; 127 128 static char *timestamp(char *timebuf, int buflen) 129 { 130 time_t now; 131 132 now = time(NULL); 133 if (strftime(timebuf, buflen, "%T", localtime(&now)) == 0) { 134 memset(timebuf, 0, buflen); 135 strncpy(timebuf, "00:00:00", buflen-1); 136 } 137 138 return timebuf; 139 } 140 141 static void log_msg(const char *format, ...) 142 { 143 char timebuf[64]; 144 va_list args; 145 146 if (quiet) 147 return; 148 149 fprintf(stdout, "%s %s:", 150 timestamp(timebuf, sizeof(timebuf)), 151 server_mode ? "server" : "client"); 152 va_start(args, format); 153 vfprintf(stdout, format, args); 154 va_end(args); 155 156 fflush(stdout); 157 } 158 159 static void log_error(const char *format, ...) 160 { 161 char timebuf[64]; 162 va_list args; 163 164 if (quiet) 165 return; 166 167 fprintf(stderr, "%s %s:", 168 timestamp(timebuf, sizeof(timebuf)), 169 server_mode ? "server" : "client"); 170 va_start(args, format); 171 vfprintf(stderr, format, args); 172 va_end(args); 173 174 fflush(stderr); 175 } 176 177 static void log_err_errno(const char *fmt, ...) 178 { 179 char timebuf[64]; 180 va_list args; 181 182 if (quiet) 183 return; 184 185 fprintf(stderr, "%s %s: ", 186 timestamp(timebuf, sizeof(timebuf)), 187 server_mode ? "server" : "client"); 188 va_start(args, fmt); 189 vfprintf(stderr, fmt, args); 190 va_end(args); 191 192 fprintf(stderr, ": %d: %s\n", errno, strerror(errno)); 193 fflush(stderr); 194 } 195 196 static void log_address(const char *desc, struct sockaddr *sa) 197 { 198 char addrstr[64]; 199 200 if (quiet) 201 return; 202 203 if (sa->sa_family == AF_INET) { 204 struct sockaddr_in *s = (struct sockaddr_in *) sa; 205 206 log_msg("%s %s:%d\n", 207 desc, 208 inet_ntop(AF_INET, &s->sin_addr, addrstr, 209 sizeof(addrstr)), 210 ntohs(s->sin_port)); 211 212 } else if (sa->sa_family == AF_INET6) { 213 struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) sa; 214 215 log_msg("%s [%s]:%d\n", 216 desc, 217 inet_ntop(AF_INET6, &s6->sin6_addr, addrstr, 218 sizeof(addrstr)), 219 ntohs(s6->sin6_port)); 220 } 221 222 fflush(stdout); 223 } 224 225 static int switch_ns(const char *ns) 226 { 227 char path[PATH_MAX]; 228 int fd, ret; 229 230 if (geteuid()) 231 log_error("warning: likely need root to set netns %s!\n", ns); 232 233 snprintf(path, sizeof(path), "%s%s", NS_PREFIX, ns); 234 fd = open(path, 0); 235 if (fd < 0) { 236 log_err_errno("Failed to open netns path; can not switch netns"); 237 return 1; 238 } 239 240 ret = setns(fd, CLONE_NEWNET); 241 close(fd); 242 243 return ret; 244 } 245 246 static int tcp_md5sig(int sd, void *addr, socklen_t alen, struct sock_args *args) 247 { 248 int keylen = strlen(args->password); 249 struct tcp_md5sig md5sig = {}; 250 int opt = TCP_MD5SIG; 251 int rc; 252 253 md5sig.tcpm_keylen = keylen; 254 memcpy(md5sig.tcpm_key, args->password, keylen); 255 256 if (args->prefix_len) { 257 opt = TCP_MD5SIG_EXT; 258 md5sig.tcpm_flags |= TCP_MD5SIG_FLAG_PREFIX; 259 260 md5sig.tcpm_prefixlen = args->prefix_len; 261 addr = &args->md5_prefix; 262 } 263 memcpy(&md5sig.tcpm_addr, addr, alen); 264 265 if (args->ifindex) { 266 opt = TCP_MD5SIG_EXT; 267 md5sig.tcpm_flags |= TCP_MD5SIG_FLAG_IFINDEX; 268 269 md5sig.tcpm_ifindex = args->ifindex; 270 } 271 272 rc = setsockopt(sd, IPPROTO_TCP, opt, &md5sig, sizeof(md5sig)); 273 if (rc < 0) { 274 /* ENOENT is harmless. Returned when a password is cleared */ 275 if (errno == ENOENT) 276 rc = 0; 277 else 278 log_err_errno("setsockopt(TCP_MD5SIG)"); 279 } 280 281 return rc; 282 } 283 284 static int tcp_md5_remote(int sd, struct sock_args *args) 285 { 286 struct sockaddr_in sin = { 287 .sin_family = AF_INET, 288 }; 289 struct sockaddr_in6 sin6 = { 290 .sin6_family = AF_INET6, 291 }; 292 void *addr; 293 int alen; 294 295 switch (args->version) { 296 case AF_INET: 297 sin.sin_port = htons(args->port); 298 sin.sin_addr = args->md5_prefix.v4.sin_addr; 299 addr = &sin; 300 alen = sizeof(sin); 301 break; 302 case AF_INET6: 303 sin6.sin6_port = htons(args->port); 304 sin6.sin6_addr = args->md5_prefix.v6.sin6_addr; 305 addr = &sin6; 306 alen = sizeof(sin6); 307 break; 308 default: 309 log_error("unknown address family\n"); 310 exit(1); 311 } 312 313 if (tcp_md5sig(sd, addr, alen, args)) 314 return -1; 315 316 return 0; 317 } 318 319 static int get_ifidx(const char *ifname) 320 { 321 struct ifreq ifdata; 322 int sd, rc; 323 324 if (!ifname || *ifname == '\0') 325 return -1; 326 327 memset(&ifdata, 0, sizeof(ifdata)); 328 329 strcpy(ifdata.ifr_name, ifname); 330 331 sd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP); 332 if (sd < 0) { 333 log_err_errno("socket failed"); 334 return -1; 335 } 336 337 rc = ioctl(sd, SIOCGIFINDEX, (char *)&ifdata); 338 close(sd); 339 if (rc != 0) { 340 log_err_errno("ioctl(SIOCGIFINDEX) failed"); 341 return -1; 342 } 343 344 return ifdata.ifr_ifindex; 345 } 346 347 static int bind_to_device(int sd, const char *name) 348 { 349 int rc; 350 351 rc = setsockopt(sd, SOL_SOCKET, SO_BINDTODEVICE, name, strlen(name)+1); 352 if (rc < 0) 353 log_err_errno("setsockopt(SO_BINDTODEVICE)"); 354 355 return rc; 356 } 357 358 static int get_bind_to_device(int sd, char *name, size_t len) 359 { 360 int rc; 361 socklen_t optlen = len; 362 363 name[0] = '\0'; 364 rc = getsockopt(sd, SOL_SOCKET, SO_BINDTODEVICE, name, &optlen); 365 if (rc < 0) 366 log_err_errno("setsockopt(SO_BINDTODEVICE)"); 367 368 return rc; 369 } 370 371 static int check_device(int sd, struct sock_args *args) 372 { 373 int ifindex = 0; 374 char name[32]; 375 376 if (get_bind_to_device(sd, name, sizeof(name))) 377 *name = '\0'; 378 else 379 ifindex = get_ifidx(name); 380 381 log_msg(" bound to device %s/%d\n", 382 *name ? name : "<none>", ifindex); 383 384 if (!args->expected_ifindex) 385 return 0; 386 387 if (args->expected_ifindex != ifindex) { 388 log_error("Device index mismatch: expected %d have %d\n", 389 args->expected_ifindex, ifindex); 390 return 1; 391 } 392 393 log_msg("Device index matches: expected %d have %d\n", 394 args->expected_ifindex, ifindex); 395 396 return 0; 397 } 398 399 static int set_pktinfo_v4(int sd) 400 { 401 int one = 1; 402 int rc; 403 404 rc = setsockopt(sd, SOL_IP, IP_PKTINFO, &one, sizeof(one)); 405 if (rc < 0 && rc != -ENOTSUP) 406 log_err_errno("setsockopt(IP_PKTINFO)"); 407 408 return rc; 409 } 410 411 static int set_recvpktinfo_v6(int sd) 412 { 413 int one = 1; 414 int rc; 415 416 rc = setsockopt(sd, SOL_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one)); 417 if (rc < 0 && rc != -ENOTSUP) 418 log_err_errno("setsockopt(IPV6_RECVPKTINFO)"); 419 420 return rc; 421 } 422 423 static int set_recverr_v4(int sd) 424 { 425 int one = 1; 426 int rc; 427 428 rc = setsockopt(sd, SOL_IP, IP_RECVERR, &one, sizeof(one)); 429 if (rc < 0 && rc != -ENOTSUP) 430 log_err_errno("setsockopt(IP_RECVERR)"); 431 432 return rc; 433 } 434 435 static int set_recverr_v6(int sd) 436 { 437 int one = 1; 438 int rc; 439 440 rc = setsockopt(sd, SOL_IPV6, IPV6_RECVERR, &one, sizeof(one)); 441 if (rc < 0 && rc != -ENOTSUP) 442 log_err_errno("setsockopt(IPV6_RECVERR)"); 443 444 return rc; 445 } 446 447 static int set_unicast_if(int sd, int ifindex, int version) 448 { 449 int opt = IP_UNICAST_IF; 450 int level = SOL_IP; 451 int rc; 452 453 ifindex = htonl(ifindex); 454 455 if (version == AF_INET6) { 456 opt = IPV6_UNICAST_IF; 457 level = SOL_IPV6; 458 } 459 rc = setsockopt(sd, level, opt, &ifindex, sizeof(ifindex)); 460 if (rc < 0) 461 log_err_errno("setsockopt(IP_UNICAST_IF)"); 462 463 return rc; 464 } 465 466 static int set_multicast_if(int sd, int ifindex) 467 { 468 struct ip_mreqn mreq = { .imr_ifindex = ifindex }; 469 int rc; 470 471 rc = setsockopt(sd, SOL_IP, IP_MULTICAST_IF, &mreq, sizeof(mreq)); 472 if (rc < 0) 473 log_err_errno("setsockopt(IP_MULTICAST_IF)"); 474 475 return rc; 476 } 477 478 static int set_membership(int sd, uint32_t grp, uint32_t addr, int ifindex) 479 { 480 uint32_t if_addr = addr; 481 struct ip_mreqn mreq; 482 int rc; 483 484 if (addr == htonl(INADDR_ANY) && !ifindex) { 485 log_error("Either local address or device needs to be given for multicast membership\n"); 486 return -1; 487 } 488 489 mreq.imr_multiaddr.s_addr = grp; 490 mreq.imr_address.s_addr = if_addr; 491 mreq.imr_ifindex = ifindex; 492 493 rc = setsockopt(sd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)); 494 if (rc < 0) { 495 log_err_errno("setsockopt(IP_ADD_MEMBERSHIP)"); 496 return -1; 497 } 498 499 return 0; 500 } 501 502 static int set_broadcast(int sd) 503 { 504 unsigned int one = 1; 505 int rc = 0; 506 507 if (setsockopt(sd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) != 0) { 508 log_err_errno("setsockopt(SO_BROADCAST)"); 509 rc = -1; 510 } 511 512 return rc; 513 } 514 515 static int set_reuseport(int sd) 516 { 517 unsigned int one = 1; 518 int rc = 0; 519 520 if (setsockopt(sd, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one)) != 0) { 521 log_err_errno("setsockopt(SO_REUSEPORT)"); 522 rc = -1; 523 } 524 525 return rc; 526 } 527 528 static int set_reuseaddr(int sd) 529 { 530 unsigned int one = 1; 531 int rc = 0; 532 533 if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) != 0) { 534 log_err_errno("setsockopt(SO_REUSEADDR)"); 535 rc = -1; 536 } 537 538 return rc; 539 } 540 541 static int str_to_uint(const char *str, int min, int max, unsigned int *value) 542 { 543 int number; 544 char *end; 545 546 errno = 0; 547 number = (unsigned int) strtoul(str, &end, 0); 548 549 /* entire string should be consumed by conversion 550 * and value should be between min and max 551 */ 552 if (((*end == '\0') || (*end == '\n')) && (end != str) && 553 (errno != ERANGE) && (min <= number) && (number <= max)) { 554 *value = number; 555 return 0; 556 } 557 558 return -1; 559 } 560 561 static int resolve_devices(struct sock_args *args) 562 { 563 if (args->dev) { 564 args->ifindex = get_ifidx(args->dev); 565 if (args->ifindex < 0) { 566 log_error("Invalid device name\n"); 567 return 1; 568 } 569 } 570 571 if (args->expected_dev) { 572 unsigned int tmp; 573 574 if (str_to_uint(args->expected_dev, 0, INT_MAX, &tmp) == 0) { 575 args->expected_ifindex = (int)tmp; 576 } else { 577 args->expected_ifindex = get_ifidx(args->expected_dev); 578 if (args->expected_ifindex < 0) { 579 fprintf(stderr, "Invalid expected device\n"); 580 return 1; 581 } 582 } 583 } 584 585 return 0; 586 } 587 588 static int expected_addr_match(struct sockaddr *sa, void *expected, 589 const char *desc) 590 { 591 char addrstr[64]; 592 int rc = 0; 593 594 if (sa->sa_family == AF_INET) { 595 struct sockaddr_in *s = (struct sockaddr_in *) sa; 596 struct in_addr *exp_in = (struct in_addr *) expected; 597 598 if (s->sin_addr.s_addr != exp_in->s_addr) { 599 log_error("%s address does not match expected %s\n", 600 desc, 601 inet_ntop(AF_INET, exp_in, 602 addrstr, sizeof(addrstr))); 603 rc = 1; 604 } 605 } else if (sa->sa_family == AF_INET6) { 606 struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) sa; 607 struct in6_addr *exp_in = (struct in6_addr *) expected; 608 609 if (memcmp(&s6->sin6_addr, exp_in, sizeof(*exp_in))) { 610 log_error("%s address does not match expected %s\n", 611 desc, 612 inet_ntop(AF_INET6, exp_in, 613 addrstr, sizeof(addrstr))); 614 rc = 1; 615 } 616 } else { 617 log_error("%s address does not match expected - unknown family\n", 618 desc); 619 rc = 1; 620 } 621 622 if (!rc) 623 log_msg("%s address matches expected\n", desc); 624 625 return rc; 626 } 627 628 static int show_sockstat(int sd, struct sock_args *args) 629 { 630 struct sockaddr_in6 local_addr, remote_addr; 631 socklen_t alen = sizeof(local_addr); 632 struct sockaddr *sa; 633 const char *desc; 634 int rc = 0; 635 636 desc = server_mode ? "server local:" : "client local:"; 637 sa = (struct sockaddr *) &local_addr; 638 if (getsockname(sd, sa, &alen) == 0) { 639 log_address(desc, sa); 640 641 if (args->has_expected_laddr) { 642 rc = expected_addr_match(sa, &args->expected_laddr, 643 "local"); 644 } 645 } else { 646 log_err_errno("getsockname failed"); 647 } 648 649 sa = (struct sockaddr *) &remote_addr; 650 desc = server_mode ? "server peer:" : "client peer:"; 651 if (getpeername(sd, sa, &alen) == 0) { 652 log_address(desc, sa); 653 654 if (args->has_expected_raddr) { 655 rc |= expected_addr_match(sa, &args->expected_raddr, 656 "remote"); 657 } 658 } else { 659 log_err_errno("getpeername failed"); 660 } 661 662 return rc; 663 } 664 665 enum addr_type { 666 ADDR_TYPE_LOCAL, 667 ADDR_TYPE_REMOTE, 668 ADDR_TYPE_MCAST, 669 ADDR_TYPE_EXPECTED_LOCAL, 670 ADDR_TYPE_EXPECTED_REMOTE, 671 ADDR_TYPE_MD5_PREFIX, 672 }; 673 674 static int convert_addr(struct sock_args *args, const char *_str, 675 enum addr_type atype) 676 { 677 int pfx_len_max = args->version == AF_INET6 ? 128 : 32; 678 int family = args->version; 679 char *str, *dev, *sep; 680 struct in6_addr *in6; 681 struct in_addr *in; 682 const char *desc; 683 void *addr; 684 int rc = 0; 685 686 str = strdup(_str); 687 if (!str) 688 return -ENOMEM; 689 690 switch (atype) { 691 case ADDR_TYPE_LOCAL: 692 desc = "local"; 693 addr = &args->local_addr; 694 break; 695 case ADDR_TYPE_REMOTE: 696 desc = "remote"; 697 addr = &args->remote_addr; 698 break; 699 case ADDR_TYPE_MCAST: 700 desc = "mcast grp"; 701 addr = &args->grp; 702 break; 703 case ADDR_TYPE_EXPECTED_LOCAL: 704 desc = "expected local"; 705 addr = &args->expected_laddr; 706 break; 707 case ADDR_TYPE_EXPECTED_REMOTE: 708 desc = "expected remote"; 709 addr = &args->expected_raddr; 710 break; 711 case ADDR_TYPE_MD5_PREFIX: 712 desc = "md5 prefix"; 713 if (family == AF_INET) { 714 args->md5_prefix.v4.sin_family = AF_INET; 715 addr = &args->md5_prefix.v4.sin_addr; 716 } else if (family == AF_INET6) { 717 args->md5_prefix.v6.sin6_family = AF_INET6; 718 addr = &args->md5_prefix.v6.sin6_addr; 719 } else 720 return 1; 721 722 sep = strchr(str, '/'); 723 if (sep) { 724 *sep = '\0'; 725 sep++; 726 if (str_to_uint(sep, 1, pfx_len_max, 727 &args->prefix_len) != 0) { 728 fprintf(stderr, "Invalid port\n"); 729 return 1; 730 } 731 } else { 732 args->prefix_len = 0; 733 } 734 break; 735 default: 736 log_error("unknown address type\n"); 737 exit(1); 738 } 739 740 switch (family) { 741 case AF_INET: 742 in = (struct in_addr *) addr; 743 if (str) { 744 if (inet_pton(AF_INET, str, in) == 0) { 745 log_error("Invalid %s IP address\n", desc); 746 rc = -1; 747 goto out; 748 } 749 } else { 750 in->s_addr = htonl(INADDR_ANY); 751 } 752 break; 753 754 case AF_INET6: 755 dev = strchr(str, '%'); 756 if (dev) { 757 *dev = '\0'; 758 dev++; 759 } 760 761 in6 = (struct in6_addr *) addr; 762 if (str) { 763 if (inet_pton(AF_INET6, str, in6) == 0) { 764 log_error("Invalid %s IPv6 address\n", desc); 765 rc = -1; 766 goto out; 767 } 768 } else { 769 *in6 = in6addr_any; 770 } 771 if (dev) { 772 args->scope_id = get_ifidx(dev); 773 if (args->scope_id < 0) { 774 log_error("Invalid scope on %s IPv6 address\n", 775 desc); 776 rc = -1; 777 goto out; 778 } 779 } 780 break; 781 782 default: 783 log_error("Invalid address family\n"); 784 } 785 786 out: 787 free(str); 788 return rc; 789 } 790 791 static int validate_addresses(struct sock_args *args) 792 { 793 if (args->local_addr_str && 794 convert_addr(args, args->local_addr_str, ADDR_TYPE_LOCAL) < 0) 795 return 1; 796 797 if (args->remote_addr_str && 798 convert_addr(args, args->remote_addr_str, ADDR_TYPE_REMOTE) < 0) 799 return 1; 800 801 if (args->md5_prefix_str && 802 convert_addr(args, args->md5_prefix_str, 803 ADDR_TYPE_MD5_PREFIX) < 0) 804 return 1; 805 806 if (args->expected_laddr_str && 807 convert_addr(args, args->expected_laddr_str, 808 ADDR_TYPE_EXPECTED_LOCAL)) 809 return 1; 810 811 if (args->expected_raddr_str && 812 convert_addr(args, args->expected_raddr_str, 813 ADDR_TYPE_EXPECTED_REMOTE)) 814 return 1; 815 816 return 0; 817 } 818 819 static int get_index_from_cmsg(struct msghdr *m) 820 { 821 struct cmsghdr *cm; 822 int ifindex = 0; 823 char buf[64]; 824 825 for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(m); 826 m->msg_controllen != 0 && cm; 827 cm = (struct cmsghdr *)CMSG_NXTHDR(m, cm)) { 828 829 if (cm->cmsg_level == SOL_IP && 830 cm->cmsg_type == IP_PKTINFO) { 831 struct in_pktinfo *pi; 832 833 pi = (struct in_pktinfo *)(CMSG_DATA(cm)); 834 inet_ntop(AF_INET, &pi->ipi_addr, buf, sizeof(buf)); 835 ifindex = pi->ipi_ifindex; 836 } else if (cm->cmsg_level == SOL_IPV6 && 837 cm->cmsg_type == IPV6_PKTINFO) { 838 struct in6_pktinfo *pi6; 839 840 pi6 = (struct in6_pktinfo *)(CMSG_DATA(cm)); 841 inet_ntop(AF_INET6, &pi6->ipi6_addr, buf, sizeof(buf)); 842 ifindex = pi6->ipi6_ifindex; 843 } 844 } 845 846 if (ifindex) { 847 log_msg(" pktinfo: ifindex %d dest addr %s\n", 848 ifindex, buf); 849 } 850 return ifindex; 851 } 852 853 static int send_msg_no_cmsg(int sd, void *addr, socklen_t alen) 854 { 855 int err; 856 857 again: 858 err = sendto(sd, msg, msglen, 0, addr, alen); 859 if (err < 0) { 860 if (errno == EACCES && try_broadcast) { 861 try_broadcast = 0; 862 if (!set_broadcast(sd)) 863 goto again; 864 errno = EACCES; 865 } 866 867 log_err_errno("sendto failed"); 868 return 1; 869 } 870 871 return 0; 872 } 873 874 static int send_msg_cmsg(int sd, void *addr, socklen_t alen, 875 int ifindex, int version) 876 { 877 unsigned char cmsgbuf[64]; 878 struct iovec iov[2]; 879 struct cmsghdr *cm; 880 struct msghdr m; 881 int err; 882 883 iov[0].iov_base = msg; 884 iov[0].iov_len = msglen; 885 m.msg_iov = iov; 886 m.msg_iovlen = 1; 887 m.msg_name = (caddr_t)addr; 888 m.msg_namelen = alen; 889 890 memset(cmsgbuf, 0, sizeof(cmsgbuf)); 891 cm = (struct cmsghdr *)cmsgbuf; 892 m.msg_control = (caddr_t)cm; 893 894 if (version == AF_INET) { 895 struct in_pktinfo *pi; 896 897 cm->cmsg_level = SOL_IP; 898 cm->cmsg_type = IP_PKTINFO; 899 cm->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo)); 900 pi = (struct in_pktinfo *)(CMSG_DATA(cm)); 901 pi->ipi_ifindex = ifindex; 902 903 m.msg_controllen = cm->cmsg_len; 904 905 } else if (version == AF_INET6) { 906 struct in6_pktinfo *pi6; 907 908 cm->cmsg_level = SOL_IPV6; 909 cm->cmsg_type = IPV6_PKTINFO; 910 cm->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo)); 911 912 pi6 = (struct in6_pktinfo *)(CMSG_DATA(cm)); 913 pi6->ipi6_ifindex = ifindex; 914 915 m.msg_controllen = cm->cmsg_len; 916 } 917 918 again: 919 err = sendmsg(sd, &m, 0); 920 if (err < 0) { 921 if (errno == EACCES && try_broadcast) { 922 try_broadcast = 0; 923 if (!set_broadcast(sd)) 924 goto again; 925 errno = EACCES; 926 } 927 928 log_err_errno("sendmsg failed"); 929 return 1; 930 } 931 932 return 0; 933 } 934 935 936 static int send_msg(int sd, void *addr, socklen_t alen, struct sock_args *args) 937 { 938 if (args->type == SOCK_STREAM) { 939 if (write(sd, msg, msglen) < 0) { 940 log_err_errno("write failed sending msg to peer"); 941 return 1; 942 } 943 } else if (args->ifindex && args->use_cmsg) { 944 if (send_msg_cmsg(sd, addr, alen, args->ifindex, args->version)) 945 return 1; 946 } else { 947 if (send_msg_no_cmsg(sd, addr, alen)) 948 return 1; 949 } 950 951 log_msg("Sent message:\n"); 952 log_msg(" %.24s%s\n", msg, msglen > 24 ? " ..." : ""); 953 954 return 0; 955 } 956 957 static int socket_read_dgram(int sd, struct sock_args *args) 958 { 959 unsigned char addr[sizeof(struct sockaddr_in6)]; 960 struct sockaddr *sa = (struct sockaddr *) addr; 961 socklen_t alen = sizeof(addr); 962 struct iovec iov[2]; 963 struct msghdr m = { 964 .msg_name = (caddr_t)addr, 965 .msg_namelen = alen, 966 .msg_iov = iov, 967 .msg_iovlen = 1, 968 }; 969 unsigned char cmsgbuf[256]; 970 struct cmsghdr *cm = (struct cmsghdr *)cmsgbuf; 971 char buf[16*1024]; 972 int ifindex; 973 int len; 974 975 iov[0].iov_base = (caddr_t)buf; 976 iov[0].iov_len = sizeof(buf); 977 978 memset(cmsgbuf, 0, sizeof(cmsgbuf)); 979 m.msg_control = (caddr_t)cm; 980 m.msg_controllen = sizeof(cmsgbuf); 981 982 len = recvmsg(sd, &m, 0); 983 if (len == 0) { 984 log_msg("peer closed connection.\n"); 985 return 0; 986 } else if (len < 0) { 987 log_msg("failed to read message: %d: %s\n", 988 errno, strerror(errno)); 989 return -1; 990 } 991 992 buf[len] = '\0'; 993 994 log_address("Message from:", sa); 995 log_msg(" %.24s%s\n", buf, len > 24 ? " ..." : ""); 996 997 ifindex = get_index_from_cmsg(&m); 998 if (args->expected_ifindex) { 999 if (args->expected_ifindex != ifindex) { 1000 log_error("Device index mismatch: expected %d have %d\n", 1001 args->expected_ifindex, ifindex); 1002 return -1; 1003 } 1004 log_msg("Device index matches: expected %d have %d\n", 1005 args->expected_ifindex, ifindex); 1006 } 1007 1008 if (!interactive && server_mode) { 1009 if (sa->sa_family == AF_INET6) { 1010 struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) sa; 1011 struct in6_addr *in6 = &s6->sin6_addr; 1012 1013 if (IN6_IS_ADDR_V4MAPPED(in6)) { 1014 const uint32_t *pa = (uint32_t *) &in6->s6_addr; 1015 struct in_addr in4; 1016 struct sockaddr_in *sin; 1017 1018 sin = (struct sockaddr_in *) addr; 1019 pa += 3; 1020 in4.s_addr = *pa; 1021 sin->sin_addr = in4; 1022 sin->sin_family = AF_INET; 1023 if (send_msg_cmsg(sd, addr, alen, 1024 ifindex, AF_INET) < 0) 1025 goto out_err; 1026 } 1027 } 1028 again: 1029 iov[0].iov_len = len; 1030 1031 if (args->version == AF_INET6) { 1032 struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) sa; 1033 1034 if (args->dev) { 1035 /* avoid PKTINFO conflicts with bindtodev */ 1036 if (sendto(sd, buf, len, 0, 1037 (void *) addr, alen) < 0) 1038 goto out_err; 1039 } else { 1040 /* kernel is allowing scope_id to be set to VRF 1041 * index for LLA. for sends to global address 1042 * reset scope id 1043 */ 1044 s6->sin6_scope_id = ifindex; 1045 if (sendmsg(sd, &m, 0) < 0) 1046 goto out_err; 1047 } 1048 } else { 1049 int err; 1050 1051 err = sendmsg(sd, &m, 0); 1052 if (err < 0) { 1053 if (errno == EACCES && try_broadcast) { 1054 try_broadcast = 0; 1055 if (!set_broadcast(sd)) 1056 goto again; 1057 errno = EACCES; 1058 } 1059 goto out_err; 1060 } 1061 } 1062 log_msg("Sent message:\n"); 1063 log_msg(" %.24s%s\n", buf, len > 24 ? " ..." : ""); 1064 } 1065 1066 return 1; 1067 out_err: 1068 log_err_errno("failed to send msg to peer"); 1069 return -1; 1070 } 1071 1072 static int socket_read_stream(int sd) 1073 { 1074 char buf[1024]; 1075 int len; 1076 1077 len = read(sd, buf, sizeof(buf)-1); 1078 if (len == 0) { 1079 log_msg("client closed connection.\n"); 1080 return 0; 1081 } else if (len < 0) { 1082 log_msg("failed to read message\n"); 1083 return -1; 1084 } 1085 1086 buf[len] = '\0'; 1087 log_msg("Incoming message:\n"); 1088 log_msg(" %.24s%s\n", buf, len > 24 ? " ..." : ""); 1089 1090 if (!interactive && server_mode) { 1091 if (write(sd, buf, len) < 0) { 1092 log_err_errno("failed to send buf"); 1093 return -1; 1094 } 1095 log_msg("Sent message:\n"); 1096 log_msg(" %.24s%s\n", buf, len > 24 ? " ..." : ""); 1097 } 1098 1099 return 1; 1100 } 1101 1102 static int socket_read(int sd, struct sock_args *args) 1103 { 1104 if (args->type == SOCK_STREAM) 1105 return socket_read_stream(sd); 1106 1107 return socket_read_dgram(sd, args); 1108 } 1109 1110 static int stdin_to_socket(int sd, int type, void *addr, socklen_t alen) 1111 { 1112 char buf[1024]; 1113 int len; 1114 1115 if (fgets(buf, sizeof(buf), stdin) == NULL) 1116 return 0; 1117 1118 len = strlen(buf); 1119 if (type == SOCK_STREAM) { 1120 if (write(sd, buf, len) < 0) { 1121 log_err_errno("failed to send buf"); 1122 return -1; 1123 } 1124 } else { 1125 int err; 1126 1127 again: 1128 err = sendto(sd, buf, len, 0, addr, alen); 1129 if (err < 0) { 1130 if (errno == EACCES && try_broadcast) { 1131 try_broadcast = 0; 1132 if (!set_broadcast(sd)) 1133 goto again; 1134 errno = EACCES; 1135 } 1136 log_err_errno("failed to send msg to peer"); 1137 return -1; 1138 } 1139 } 1140 log_msg("Sent message:\n"); 1141 log_msg(" %.24s%s\n", buf, len > 24 ? " ..." : ""); 1142 1143 return 1; 1144 } 1145 1146 static void set_recv_attr(int sd, int version) 1147 { 1148 if (version == AF_INET6) { 1149 set_recvpktinfo_v6(sd); 1150 set_recverr_v6(sd); 1151 } else { 1152 set_pktinfo_v4(sd); 1153 set_recverr_v4(sd); 1154 } 1155 } 1156 1157 static int msg_loop(int client, int sd, void *addr, socklen_t alen, 1158 struct sock_args *args) 1159 { 1160 struct timeval timeout = { .tv_sec = prog_timeout }, *ptval = NULL; 1161 fd_set rfds; 1162 int nfds; 1163 int rc; 1164 1165 if (args->type != SOCK_STREAM) 1166 set_recv_attr(sd, args->version); 1167 1168 if (msg) { 1169 msglen = strlen(msg); 1170 1171 /* client sends first message */ 1172 if (client) { 1173 if (send_msg(sd, addr, alen, args)) 1174 return 1; 1175 } 1176 if (!interactive) { 1177 ptval = &timeout; 1178 if (!prog_timeout) 1179 timeout.tv_sec = 5; 1180 } 1181 } 1182 1183 nfds = interactive ? MAX(fileno(stdin), sd) + 1 : sd + 1; 1184 while (1) { 1185 FD_ZERO(&rfds); 1186 FD_SET(sd, &rfds); 1187 if (interactive) 1188 FD_SET(fileno(stdin), &rfds); 1189 1190 rc = select(nfds, &rfds, NULL, NULL, ptval); 1191 if (rc < 0) { 1192 if (errno == EINTR) 1193 continue; 1194 1195 rc = 1; 1196 log_err_errno("select failed"); 1197 break; 1198 } else if (rc == 0) { 1199 log_error("Timed out waiting for response\n"); 1200 rc = 2; 1201 break; 1202 } 1203 1204 if (FD_ISSET(sd, &rfds)) { 1205 rc = socket_read(sd, args); 1206 if (rc < 0) { 1207 rc = 1; 1208 break; 1209 } 1210 if (rc == 0) 1211 break; 1212 } 1213 1214 rc = 0; 1215 1216 if (FD_ISSET(fileno(stdin), &rfds)) { 1217 if (stdin_to_socket(sd, args->type, addr, alen) <= 0) 1218 break; 1219 } 1220 1221 if (interactive) 1222 continue; 1223 1224 if (iter != -1) { 1225 --iter; 1226 if (iter == 0) 1227 break; 1228 } 1229 1230 log_msg("Going into quiet mode\n"); 1231 quiet = 1; 1232 1233 if (client) { 1234 if (send_msg(sd, addr, alen, args)) { 1235 rc = 1; 1236 break; 1237 } 1238 } 1239 } 1240 1241 return rc; 1242 } 1243 1244 static int msock_init(struct sock_args *args, int server) 1245 { 1246 uint32_t if_addr = htonl(INADDR_ANY); 1247 struct sockaddr_in laddr = { 1248 .sin_family = AF_INET, 1249 .sin_port = htons(args->port), 1250 }; 1251 int one = 1; 1252 int sd; 1253 1254 if (!server && args->has_local_ip) 1255 if_addr = args->local_addr.in.s_addr; 1256 1257 sd = socket(PF_INET, SOCK_DGRAM, 0); 1258 if (sd < 0) { 1259 log_err_errno("socket"); 1260 return -1; 1261 } 1262 1263 if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, 1264 (char *)&one, sizeof(one)) < 0) { 1265 log_err_errno("Setting SO_REUSEADDR error"); 1266 goto out_err; 1267 } 1268 1269 if (setsockopt(sd, SOL_SOCKET, SO_BROADCAST, 1270 (char *)&one, sizeof(one)) < 0) 1271 log_err_errno("Setting SO_BROADCAST error"); 1272 1273 if (args->dev && bind_to_device(sd, args->dev) != 0) 1274 goto out_err; 1275 else if (args->use_setsockopt && 1276 set_multicast_if(sd, args->ifindex)) 1277 goto out_err; 1278 1279 laddr.sin_addr.s_addr = if_addr; 1280 1281 if (bind(sd, (struct sockaddr *) &laddr, sizeof(laddr)) < 0) { 1282 log_err_errno("bind failed"); 1283 goto out_err; 1284 } 1285 1286 if (server && 1287 set_membership(sd, args->grp.s_addr, 1288 args->local_addr.in.s_addr, args->ifindex)) 1289 goto out_err; 1290 1291 return sd; 1292 out_err: 1293 close(sd); 1294 return -1; 1295 } 1296 1297 static int msock_server(struct sock_args *args) 1298 { 1299 return msock_init(args, 1); 1300 } 1301 1302 static int msock_client(struct sock_args *args) 1303 { 1304 return msock_init(args, 0); 1305 } 1306 1307 static int bind_socket(int sd, struct sock_args *args) 1308 { 1309 struct sockaddr_in serv_addr = { 1310 .sin_family = AF_INET, 1311 }; 1312 struct sockaddr_in6 serv6_addr = { 1313 .sin6_family = AF_INET6, 1314 }; 1315 void *addr; 1316 socklen_t alen; 1317 1318 if (!args->has_local_ip && args->type == SOCK_RAW) 1319 return 0; 1320 1321 switch (args->version) { 1322 case AF_INET: 1323 serv_addr.sin_port = htons(args->port); 1324 serv_addr.sin_addr = args->local_addr.in; 1325 addr = &serv_addr; 1326 alen = sizeof(serv_addr); 1327 break; 1328 1329 case AF_INET6: 1330 serv6_addr.sin6_port = htons(args->port); 1331 serv6_addr.sin6_addr = args->local_addr.in6; 1332 addr = &serv6_addr; 1333 alen = sizeof(serv6_addr); 1334 break; 1335 1336 default: 1337 log_error("Invalid address family\n"); 1338 return -1; 1339 } 1340 1341 if (bind(sd, addr, alen) < 0) { 1342 log_err_errno("error binding socket"); 1343 return -1; 1344 } 1345 1346 return 0; 1347 } 1348 1349 static int lsock_init(struct sock_args *args) 1350 { 1351 long flags; 1352 int sd; 1353 1354 sd = socket(args->version, args->type, args->protocol); 1355 if (sd < 0) { 1356 log_err_errno("Error opening socket"); 1357 return -1; 1358 } 1359 1360 if (set_reuseaddr(sd) != 0) 1361 goto err; 1362 1363 if (set_reuseport(sd) != 0) 1364 goto err; 1365 1366 if (args->dev && bind_to_device(sd, args->dev) != 0) 1367 goto err; 1368 else if (args->use_setsockopt && 1369 set_unicast_if(sd, args->ifindex, args->version)) 1370 goto err; 1371 1372 if (bind_socket(sd, args)) 1373 goto err; 1374 1375 if (args->bind_test_only) 1376 goto out; 1377 1378 if (args->type == SOCK_STREAM && listen(sd, 1) < 0) { 1379 log_err_errno("listen failed"); 1380 goto err; 1381 } 1382 1383 flags = fcntl(sd, F_GETFL); 1384 if ((flags < 0) || (fcntl(sd, F_SETFL, flags|O_NONBLOCK) < 0)) { 1385 log_err_errno("Failed to set non-blocking option"); 1386 goto err; 1387 } 1388 1389 if (fcntl(sd, F_SETFD, FD_CLOEXEC) < 0) 1390 log_err_errno("Failed to set close-on-exec flag"); 1391 1392 out: 1393 return sd; 1394 1395 err: 1396 close(sd); 1397 return -1; 1398 } 1399 1400 static void ipc_write(int fd, int message) 1401 { 1402 /* Not in both_mode, so there's no process to signal */ 1403 if (fd < 0) 1404 return; 1405 1406 if (write(fd, &message, sizeof(message)) < 0) 1407 log_err_errno("Failed to send client status"); 1408 } 1409 1410 static int do_server(struct sock_args *args, int ipc_fd) 1411 { 1412 /* ipc_fd = -1 if no parent process to signal */ 1413 struct timeval timeout = { .tv_sec = prog_timeout }, *ptval = NULL; 1414 unsigned char addr[sizeof(struct sockaddr_in6)] = {}; 1415 socklen_t alen = sizeof(addr); 1416 int lsd, csd = -1; 1417 1418 fd_set rfds; 1419 int rc; 1420 1421 if (args->serverns) { 1422 if (switch_ns(args->serverns)) { 1423 log_error("Could not set server netns to %s\n", 1424 args->serverns); 1425 goto err_exit; 1426 } 1427 log_msg("Switched server netns\n"); 1428 } 1429 1430 args->dev = args->server_dev; 1431 args->expected_dev = args->expected_server_dev; 1432 if (resolve_devices(args) || validate_addresses(args)) 1433 goto err_exit; 1434 1435 if (prog_timeout) 1436 ptval = &timeout; 1437 1438 if (args->has_grp) 1439 lsd = msock_server(args); 1440 else 1441 lsd = lsock_init(args); 1442 1443 if (lsd < 0) 1444 goto err_exit; 1445 1446 if (args->bind_test_only) { 1447 close(lsd); 1448 ipc_write(ipc_fd, 1); 1449 return 0; 1450 } 1451 1452 if (args->type != SOCK_STREAM) { 1453 ipc_write(ipc_fd, 1); 1454 rc = msg_loop(0, lsd, (void *) addr, alen, args); 1455 close(lsd); 1456 return rc; 1457 } 1458 1459 if (args->password && tcp_md5_remote(lsd, args)) { 1460 close(lsd); 1461 goto err_exit; 1462 } 1463 1464 ipc_write(ipc_fd, 1); 1465 while (1) { 1466 log_msg("waiting for client connection.\n"); 1467 FD_ZERO(&rfds); 1468 FD_SET(lsd, &rfds); 1469 1470 rc = select(lsd+1, &rfds, NULL, NULL, ptval); 1471 if (rc == 0) { 1472 rc = 2; 1473 break; 1474 } 1475 1476 if (rc < 0) { 1477 if (errno == EINTR) 1478 continue; 1479 1480 log_err_errno("select failed"); 1481 break; 1482 } 1483 1484 if (FD_ISSET(lsd, &rfds)) { 1485 1486 csd = accept(lsd, (void *) addr, &alen); 1487 if (csd < 0) { 1488 log_err_errno("accept failed"); 1489 break; 1490 } 1491 1492 rc = show_sockstat(csd, args); 1493 if (rc) 1494 break; 1495 1496 rc = check_device(csd, args); 1497 if (rc) 1498 break; 1499 } 1500 1501 rc = msg_loop(0, csd, (void *) addr, alen, args); 1502 close(csd); 1503 1504 if (!interactive) 1505 break; 1506 } 1507 1508 close(lsd); 1509 1510 return rc; 1511 err_exit: 1512 ipc_write(ipc_fd, 0); 1513 return 1; 1514 } 1515 1516 static int wait_for_connect(int sd) 1517 { 1518 struct timeval _tv = { .tv_sec = prog_timeout }, *tv = NULL; 1519 fd_set wfd; 1520 int val = 0, sz = sizeof(val); 1521 int rc; 1522 1523 FD_ZERO(&wfd); 1524 FD_SET(sd, &wfd); 1525 1526 if (prog_timeout) 1527 tv = &_tv; 1528 1529 rc = select(FD_SETSIZE, NULL, &wfd, NULL, tv); 1530 if (rc == 0) { 1531 log_error("connect timed out\n"); 1532 return -2; 1533 } else if (rc < 0) { 1534 log_err_errno("select failed"); 1535 return -3; 1536 } 1537 1538 if (getsockopt(sd, SOL_SOCKET, SO_ERROR, &val, (socklen_t *)&sz) < 0) { 1539 log_err_errno("getsockopt(SO_ERROR) failed"); 1540 return -4; 1541 } 1542 1543 if (val != 0) { 1544 log_error("connect failed: %d: %s\n", val, strerror(val)); 1545 return -1; 1546 } 1547 1548 return 0; 1549 } 1550 1551 static int connectsock(void *addr, socklen_t alen, struct sock_args *args) 1552 { 1553 int sd, rc = -1; 1554 long flags; 1555 1556 sd = socket(args->version, args->type, args->protocol); 1557 if (sd < 0) { 1558 log_err_errno("Failed to create socket"); 1559 return -1; 1560 } 1561 1562 flags = fcntl(sd, F_GETFL); 1563 if ((flags < 0) || (fcntl(sd, F_SETFL, flags|O_NONBLOCK) < 0)) { 1564 log_err_errno("Failed to set non-blocking option"); 1565 goto err; 1566 } 1567 1568 if (set_reuseport(sd) != 0) 1569 goto err; 1570 1571 if (args->dev && bind_to_device(sd, args->dev) != 0) 1572 goto err; 1573 else if (args->use_setsockopt && 1574 set_unicast_if(sd, args->ifindex, args->version)) 1575 goto err; 1576 1577 if (args->has_local_ip && bind_socket(sd, args)) 1578 goto err; 1579 1580 if (args->type != SOCK_STREAM) 1581 goto out; 1582 1583 if (args->password && tcp_md5sig(sd, addr, alen, args)) 1584 goto err; 1585 1586 if (args->bind_test_only) 1587 goto out; 1588 1589 if (connect(sd, addr, alen) < 0) { 1590 if (errno != EINPROGRESS) { 1591 log_err_errno("Failed to connect to remote host"); 1592 rc = -1; 1593 goto err; 1594 } 1595 rc = wait_for_connect(sd); 1596 if (rc < 0) 1597 goto err; 1598 } 1599 out: 1600 return sd; 1601 1602 err: 1603 close(sd); 1604 return rc; 1605 } 1606 1607 static int do_client(struct sock_args *args) 1608 { 1609 struct sockaddr_in sin = { 1610 .sin_family = AF_INET, 1611 }; 1612 struct sockaddr_in6 sin6 = { 1613 .sin6_family = AF_INET6, 1614 }; 1615 void *addr; 1616 int alen; 1617 int rc = 0; 1618 int sd; 1619 1620 if (!args->has_remote_ip && !args->has_grp) { 1621 fprintf(stderr, "remote IP or multicast group not given\n"); 1622 return 1; 1623 } 1624 1625 if (args->clientns) { 1626 if (switch_ns(args->clientns)) { 1627 log_error("Could not set client netns to %s\n", 1628 args->clientns); 1629 return 1; 1630 } 1631 log_msg("Switched client netns\n"); 1632 } 1633 1634 args->local_addr_str = args->client_local_addr_str; 1635 if (resolve_devices(args) || validate_addresses(args)) 1636 return 1; 1637 1638 if ((args->use_setsockopt || args->use_cmsg) && !args->ifindex) { 1639 fprintf(stderr, "Device binding not specified\n"); 1640 return 1; 1641 } 1642 if (args->use_setsockopt || args->use_cmsg) 1643 args->dev = NULL; 1644 1645 switch (args->version) { 1646 case AF_INET: 1647 sin.sin_port = htons(args->port); 1648 if (args->has_grp) 1649 sin.sin_addr = args->grp; 1650 else 1651 sin.sin_addr = args->remote_addr.in; 1652 addr = &sin; 1653 alen = sizeof(sin); 1654 break; 1655 case AF_INET6: 1656 sin6.sin6_port = htons(args->port); 1657 sin6.sin6_addr = args->remote_addr.in6; 1658 sin6.sin6_scope_id = args->scope_id; 1659 addr = &sin6; 1660 alen = sizeof(sin6); 1661 break; 1662 } 1663 1664 args->password = args->client_pw; 1665 1666 if (args->has_grp) 1667 sd = msock_client(args); 1668 else 1669 sd = connectsock(addr, alen, args); 1670 1671 if (sd < 0) 1672 return -sd; 1673 1674 if (args->bind_test_only) 1675 goto out; 1676 1677 if (args->type == SOCK_STREAM) { 1678 rc = show_sockstat(sd, args); 1679 if (rc != 0) 1680 goto out; 1681 } 1682 1683 rc = msg_loop(1, sd, addr, alen, args); 1684 1685 out: 1686 close(sd); 1687 1688 return rc; 1689 } 1690 1691 static char *random_msg(int len) 1692 { 1693 int i, n = 0, olen = len + 1; 1694 char *m; 1695 1696 if (len <= 0) 1697 return NULL; 1698 1699 m = malloc(olen); 1700 if (!m) 1701 return NULL; 1702 1703 while (len > 26) { 1704 i = snprintf(m + n, olen - n, "%.26s", 1705 "abcdefghijklmnopqrstuvwxyz"); 1706 n += i; 1707 len -= i; 1708 } 1709 i = snprintf(m + n, olen - n, "%.*s", len, 1710 "abcdefghijklmnopqrstuvwxyz"); 1711 return m; 1712 } 1713 1714 static int ipc_child(int fd, struct sock_args *args) 1715 { 1716 char *outbuf, *errbuf; 1717 int rc = 1; 1718 1719 outbuf = malloc(4096); 1720 errbuf = malloc(4096); 1721 if (!outbuf || !errbuf) { 1722 fprintf(stderr, "server: Failed to allocate buffers for stdout and stderr\n"); 1723 goto out; 1724 } 1725 1726 setbuffer(stdout, outbuf, 4096); 1727 setbuffer(stderr, errbuf, 4096); 1728 1729 server_mode = 1; /* to tell log_msg in case we are in both_mode */ 1730 1731 /* when running in both mode, address validation applies 1732 * solely to client side 1733 */ 1734 args->has_expected_laddr = 0; 1735 args->has_expected_raddr = 0; 1736 1737 rc = do_server(args, fd); 1738 1739 out: 1740 free(outbuf); 1741 free(errbuf); 1742 1743 return rc; 1744 } 1745 1746 static int ipc_parent(int cpid, int fd, struct sock_args *args) 1747 { 1748 int client_status; 1749 int status; 1750 int buf; 1751 1752 /* do the client-side function here in the parent process, 1753 * waiting to be told when to continue 1754 */ 1755 if (read(fd, &buf, sizeof(buf)) <= 0) { 1756 log_err_errno("Failed to read IPC status from status"); 1757 return 1; 1758 } 1759 if (!buf) { 1760 log_error("Server failed; can not continue\n"); 1761 return 1; 1762 } 1763 log_msg("Server is ready\n"); 1764 1765 client_status = do_client(args); 1766 log_msg("parent is done!\n"); 1767 1768 if (kill(cpid, 0) == 0) 1769 kill(cpid, SIGKILL); 1770 1771 wait(&status); 1772 return client_status; 1773 } 1774 1775 #define GETOPT_STR "sr:l:c:p:t:g:P:DRn:M:X:m:d:I:BN:O:SCi6L:0:1:2:3:Fbq" 1776 1777 static void print_usage(char *prog) 1778 { 1779 printf( 1780 "usage: %s OPTS\n" 1781 "Required:\n" 1782 " -r addr remote address to connect to (client mode only)\n" 1783 " -p port port to connect to (client mode)/listen on (server mode)\n" 1784 " (default: %d)\n" 1785 " -s server mode (default: client mode)\n" 1786 " -t timeout seconds (default: none)\n" 1787 "\n" 1788 "Optional:\n" 1789 " -B do both client and server via fork and IPC\n" 1790 " -N ns set client to network namespace ns (requires root)\n" 1791 " -O ns set server to network namespace ns (requires root)\n" 1792 " -F Restart server loop\n" 1793 " -6 IPv6 (default is IPv4)\n" 1794 " -P proto protocol for socket: icmp, ospf (default: none)\n" 1795 " -D|R datagram (D) / raw (R) socket (default stream)\n" 1796 " -l addr local address to bind to in server mode\n" 1797 " -c addr local address to bind to in client mode\n" 1798 "\n" 1799 " -d dev bind socket to given device name\n" 1800 " -I dev bind socket to given device name - server mode\n" 1801 " -S use setsockopt (IP_UNICAST_IF or IP_MULTICAST_IF)\n" 1802 " to set device binding\n" 1803 " -C use cmsg and IP_PKTINFO to specify device binding\n" 1804 "\n" 1805 " -L len send random message of given length\n" 1806 " -n num number of times to send message\n" 1807 "\n" 1808 " -M password use MD5 sum protection\n" 1809 " -X password MD5 password for client mode\n" 1810 " -m prefix/len prefix and length to use for MD5 key\n" 1811 " -g grp multicast group (e.g., 239.1.1.1)\n" 1812 " -i interactive mode (default is echo and terminate)\n" 1813 "\n" 1814 " -0 addr Expected local address\n" 1815 " -1 addr Expected remote address\n" 1816 " -2 dev Expected device name (or index) to receive packet\n" 1817 " -3 dev Expected device name (or index) to receive packets - server mode\n" 1818 "\n" 1819 " -b Bind test only.\n" 1820 " -q Be quiet. Run test without printing anything.\n" 1821 , prog, DEFAULT_PORT); 1822 } 1823 1824 int main(int argc, char *argv[]) 1825 { 1826 struct sock_args args = { 1827 .version = AF_INET, 1828 .type = SOCK_STREAM, 1829 .port = DEFAULT_PORT, 1830 }; 1831 struct protoent *pe; 1832 int both_mode = 0; 1833 unsigned int tmp; 1834 int forever = 0; 1835 int fd[2]; 1836 int cpid; 1837 1838 /* process inputs */ 1839 extern char *optarg; 1840 int rc = 0; 1841 1842 /* 1843 * process input args 1844 */ 1845 1846 while ((rc = getopt(argc, argv, GETOPT_STR)) != -1) { 1847 switch (rc) { 1848 case 'B': 1849 both_mode = 1; 1850 break; 1851 case 's': 1852 server_mode = 1; 1853 break; 1854 case 'F': 1855 forever = 1; 1856 break; 1857 case 'l': 1858 args.has_local_ip = 1; 1859 args.local_addr_str = optarg; 1860 break; 1861 case 'r': 1862 args.has_remote_ip = 1; 1863 args.remote_addr_str = optarg; 1864 break; 1865 case 'c': 1866 args.has_local_ip = 1; 1867 args.client_local_addr_str = optarg; 1868 break; 1869 case 'p': 1870 if (str_to_uint(optarg, 1, 65535, &tmp) != 0) { 1871 fprintf(stderr, "Invalid port\n"); 1872 return 1; 1873 } 1874 args.port = (unsigned short) tmp; 1875 break; 1876 case 't': 1877 if (str_to_uint(optarg, 0, INT_MAX, 1878 &prog_timeout) != 0) { 1879 fprintf(stderr, "Invalid timeout\n"); 1880 return 1; 1881 } 1882 break; 1883 case 'D': 1884 args.type = SOCK_DGRAM; 1885 break; 1886 case 'R': 1887 args.type = SOCK_RAW; 1888 args.port = 0; 1889 if (!args.protocol) 1890 args.protocol = IPPROTO_RAW; 1891 break; 1892 case 'P': 1893 pe = getprotobyname(optarg); 1894 if (pe) { 1895 args.protocol = pe->p_proto; 1896 } else { 1897 if (str_to_uint(optarg, 0, 0xffff, &tmp) != 0) { 1898 fprintf(stderr, "Invalid protocol\n"); 1899 return 1; 1900 } 1901 args.protocol = tmp; 1902 } 1903 break; 1904 case 'n': 1905 iter = atoi(optarg); 1906 break; 1907 case 'N': 1908 args.clientns = optarg; 1909 break; 1910 case 'O': 1911 args.serverns = optarg; 1912 break; 1913 case 'L': 1914 msg = random_msg(atoi(optarg)); 1915 break; 1916 case 'M': 1917 args.password = optarg; 1918 break; 1919 case 'X': 1920 args.client_pw = optarg; 1921 break; 1922 case 'm': 1923 args.md5_prefix_str = optarg; 1924 break; 1925 case 'S': 1926 args.use_setsockopt = 1; 1927 break; 1928 case 'C': 1929 args.use_cmsg = 1; 1930 break; 1931 case 'd': 1932 args.dev = optarg; 1933 break; 1934 case 'I': 1935 args.server_dev = optarg; 1936 break; 1937 case 'i': 1938 interactive = 1; 1939 break; 1940 case 'g': 1941 args.has_grp = 1; 1942 if (convert_addr(&args, optarg, ADDR_TYPE_MCAST) < 0) 1943 return 1; 1944 args.type = SOCK_DGRAM; 1945 break; 1946 case '6': 1947 args.version = AF_INET6; 1948 break; 1949 case 'b': 1950 args.bind_test_only = 1; 1951 break; 1952 case '0': 1953 args.has_expected_laddr = 1; 1954 args.expected_laddr_str = optarg; 1955 break; 1956 case '1': 1957 args.has_expected_raddr = 1; 1958 args.expected_raddr_str = optarg; 1959 break; 1960 case '2': 1961 args.expected_dev = optarg; 1962 break; 1963 case '3': 1964 args.expected_server_dev = optarg; 1965 break; 1966 case 'q': 1967 quiet = 1; 1968 break; 1969 default: 1970 print_usage(argv[0]); 1971 return 1; 1972 } 1973 } 1974 1975 if (args.password && 1976 ((!args.has_remote_ip && !args.md5_prefix_str) || 1977 args.type != SOCK_STREAM)) { 1978 log_error("MD5 passwords apply to TCP only and require a remote ip for the password\n"); 1979 return 1; 1980 } 1981 1982 if (args.md5_prefix_str && !args.password) { 1983 log_error("Prefix range for MD5 protection specified without a password\n"); 1984 return 1; 1985 } 1986 1987 if (iter == 0) { 1988 fprintf(stderr, "Invalid number of messages to send\n"); 1989 return 1; 1990 } 1991 1992 if (args.type == SOCK_STREAM && !args.protocol) 1993 args.protocol = IPPROTO_TCP; 1994 if (args.type == SOCK_DGRAM && !args.protocol) 1995 args.protocol = IPPROTO_UDP; 1996 1997 if ((args.type == SOCK_STREAM || args.type == SOCK_DGRAM) && 1998 args.port == 0) { 1999 fprintf(stderr, "Invalid port number\n"); 2000 return 1; 2001 } 2002 2003 if ((both_mode || !server_mode) && !args.has_grp && 2004 !args.has_remote_ip && !args.has_local_ip) { 2005 fprintf(stderr, 2006 "Local (server mode) or remote IP (client IP) required\n"); 2007 return 1; 2008 } 2009 2010 if (interactive) { 2011 prog_timeout = 0; 2012 msg = NULL; 2013 } 2014 2015 if (both_mode) { 2016 if (pipe(fd) < 0) { 2017 perror("pipe"); 2018 exit(1); 2019 } 2020 2021 cpid = fork(); 2022 if (cpid < 0) { 2023 perror("fork"); 2024 exit(1); 2025 } 2026 if (cpid) 2027 return ipc_parent(cpid, fd[0], &args); 2028 2029 return ipc_child(fd[1], &args); 2030 } 2031 2032 if (server_mode) { 2033 do { 2034 rc = do_server(&args, -1); 2035 } while (forever); 2036 2037 return rc; 2038 } 2039 return do_client(&args); 2040 } 2041