1 // SPDX-License-Identifier: GPL-2.0
2 /* nettest - used for functional tests of networking APIs
3 *
4 * Copyright (c) 2013-2019 David Ahern <dsahern@gmail.com>. All rights reserved.
5 */
6
7 #define _GNU_SOURCE
8 #include <features.h>
9 #include <sys/types.h>
10 #include <sys/ioctl.h>
11 #include <sys/socket.h>
12 #include <sys/wait.h>
13 #include <linux/tcp.h>
14 #include <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 '':
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 }
2255
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.