tools/testing/selftests/net/nettest.c

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