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