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