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