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