1 // SPDX-License-Identifier: GPL-2.0
2 
3 #define _GNU_SOURCE
4 
5 #include <errno.h>
6 #include <limits.h>
7 #include <fcntl.h>
8 #include <string.h>
9 #include <stdbool.h>
10 #include <stdint.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <strings.h>
14 #include <signal.h>
15 #include <unistd.h>
16 
17 #include <sys/poll.h>
18 #include <sys/sendfile.h>
19 #include <sys/stat.h>
20 #include <sys/socket.h>
21 #include <sys/types.h>
22 #include <sys/mman.h>
23 
24 #include <netdb.h>
25 #include <netinet/in.h>
26 
27 #include <linux/tcp.h>
28 
29 extern int optind;
30 
31 #ifndef IPPROTO_MPTCP
32 #define IPPROTO_MPTCP 262
33 #endif
34 #ifndef TCP_ULP
35 #define TCP_ULP 31
36 #endif
37 
38 static int  poll_timeout = 10 * 1000;
39 static bool listen_mode;
40 static bool quit;
41 
42 enum cfg_mode {
43 	CFG_MODE_POLL,
44 	CFG_MODE_MMAP,
45 	CFG_MODE_SENDFILE,
46 };
47 
48 static enum cfg_mode cfg_mode = CFG_MODE_POLL;
49 static const char *cfg_host;
50 static const char *cfg_port	= "12000";
51 static int cfg_sock_proto	= IPPROTO_MPTCP;
52 static bool tcpulp_audit;
53 static int pf = AF_INET;
54 static int cfg_sndbuf;
55 static int cfg_rcvbuf;
56 static bool cfg_join;
57 static bool cfg_remove;
58 static int cfg_wait;
59 
60 static void die_usage(void)
61 {
62 	fprintf(stderr, "Usage: mptcp_connect [-6] [-u] [-s MPTCP|TCP] [-p port] [-m mode]"
63 		"[-l] [-w sec] connect_address\n");
64 	fprintf(stderr, "\t-6 use ipv6\n");
65 	fprintf(stderr, "\t-t num -- set poll timeout to num\n");
66 	fprintf(stderr, "\t-S num -- set SO_SNDBUF to num\n");
67 	fprintf(stderr, "\t-R num -- set SO_RCVBUF to num\n");
68 	fprintf(stderr, "\t-p num -- use port num\n");
69 	fprintf(stderr, "\t-s [MPTCP|TCP] -- use mptcp(default) or tcp sockets\n");
70 	fprintf(stderr, "\t-m [poll|mmap|sendfile] -- use poll(default)/mmap+write/sendfile\n");
71 	fprintf(stderr, "\t-u -- check mptcp ulp\n");
72 	fprintf(stderr, "\t-w num -- wait num sec before closing the socket\n");
73 	exit(1);
74 }
75 
76 static void handle_signal(int nr)
77 {
78 	quit = true;
79 }
80 
81 static const char *getxinfo_strerr(int err)
82 {
83 	if (err == EAI_SYSTEM)
84 		return strerror(errno);
85 
86 	return gai_strerror(err);
87 }
88 
89 static void xgetnameinfo(const struct sockaddr *addr, socklen_t addrlen,
90 			 char *host, socklen_t hostlen,
91 			 char *serv, socklen_t servlen)
92 {
93 	int flags = NI_NUMERICHOST | NI_NUMERICSERV;
94 	int err = getnameinfo(addr, addrlen, host, hostlen, serv, servlen,
95 			      flags);
96 
97 	if (err) {
98 		const char *errstr = getxinfo_strerr(err);
99 
100 		fprintf(stderr, "Fatal: getnameinfo: %s\n", errstr);
101 		exit(1);
102 	}
103 }
104 
105 static void xgetaddrinfo(const char *node, const char *service,
106 			 const struct addrinfo *hints,
107 			 struct addrinfo **res)
108 {
109 	int err = getaddrinfo(node, service, hints, res);
110 
111 	if (err) {
112 		const char *errstr = getxinfo_strerr(err);
113 
114 		fprintf(stderr, "Fatal: getaddrinfo(%s:%s): %s\n",
115 			node ? node : "", service ? service : "", errstr);
116 		exit(1);
117 	}
118 }
119 
120 static void set_rcvbuf(int fd, unsigned int size)
121 {
122 	int err;
123 
124 	err = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
125 	if (err) {
126 		perror("set SO_RCVBUF");
127 		exit(1);
128 	}
129 }
130 
131 static void set_sndbuf(int fd, unsigned int size)
132 {
133 	int err;
134 
135 	err = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
136 	if (err) {
137 		perror("set SO_SNDBUF");
138 		exit(1);
139 	}
140 }
141 
142 static int sock_listen_mptcp(const char * const listenaddr,
143 			     const char * const port)
144 {
145 	int sock;
146 	struct addrinfo hints = {
147 		.ai_protocol = IPPROTO_TCP,
148 		.ai_socktype = SOCK_STREAM,
149 		.ai_flags = AI_PASSIVE | AI_NUMERICHOST
150 	};
151 
152 	hints.ai_family = pf;
153 
154 	struct addrinfo *a, *addr;
155 	int one = 1;
156 
157 	xgetaddrinfo(listenaddr, port, &hints, &addr);
158 	hints.ai_family = pf;
159 
160 	for (a = addr; a; a = a->ai_next) {
161 		sock = socket(a->ai_family, a->ai_socktype, cfg_sock_proto);
162 		if (sock < 0)
163 			continue;
164 
165 		if (-1 == setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one,
166 				     sizeof(one)))
167 			perror("setsockopt");
168 
169 		if (bind(sock, a->ai_addr, a->ai_addrlen) == 0)
170 			break; /* success */
171 
172 		perror("bind");
173 		close(sock);
174 		sock = -1;
175 	}
176 
177 	freeaddrinfo(addr);
178 
179 	if (sock < 0) {
180 		fprintf(stderr, "Could not create listen socket\n");
181 		return sock;
182 	}
183 
184 	if (listen(sock, 20)) {
185 		perror("listen");
186 		close(sock);
187 		return -1;
188 	}
189 
190 	return sock;
191 }
192 
193 static bool sock_test_tcpulp(const char * const remoteaddr,
194 			     const char * const port)
195 {
196 	struct addrinfo hints = {
197 		.ai_protocol = IPPROTO_TCP,
198 		.ai_socktype = SOCK_STREAM,
199 	};
200 	struct addrinfo *a, *addr;
201 	int sock = -1, ret = 0;
202 	bool test_pass = false;
203 
204 	hints.ai_family = AF_INET;
205 
206 	xgetaddrinfo(remoteaddr, port, &hints, &addr);
207 	for (a = addr; a; a = a->ai_next) {
208 		sock = socket(a->ai_family, a->ai_socktype, IPPROTO_TCP);
209 		if (sock < 0) {
210 			perror("socket");
211 			continue;
212 		}
213 		ret = setsockopt(sock, IPPROTO_TCP, TCP_ULP, "mptcp",
214 				 sizeof("mptcp"));
215 		if (ret == -1 && errno == EOPNOTSUPP)
216 			test_pass = true;
217 		close(sock);
218 
219 		if (test_pass)
220 			break;
221 		if (!ret)
222 			fprintf(stderr,
223 				"setsockopt(TCP_ULP) returned 0\n");
224 		else
225 			perror("setsockopt(TCP_ULP)");
226 	}
227 	return test_pass;
228 }
229 
230 static int sock_connect_mptcp(const char * const remoteaddr,
231 			      const char * const port, int proto)
232 {
233 	struct addrinfo hints = {
234 		.ai_protocol = IPPROTO_TCP,
235 		.ai_socktype = SOCK_STREAM,
236 	};
237 	struct addrinfo *a, *addr;
238 	int sock = -1;
239 
240 	hints.ai_family = pf;
241 
242 	xgetaddrinfo(remoteaddr, port, &hints, &addr);
243 	for (a = addr; a; a = a->ai_next) {
244 		sock = socket(a->ai_family, a->ai_socktype, proto);
245 		if (sock < 0) {
246 			perror("socket");
247 			continue;
248 		}
249 
250 		if (connect(sock, a->ai_addr, a->ai_addrlen) == 0)
251 			break; /* success */
252 
253 		perror("connect()");
254 		close(sock);
255 		sock = -1;
256 	}
257 
258 	freeaddrinfo(addr);
259 	return sock;
260 }
261 
262 static size_t do_rnd_write(const int fd, char *buf, const size_t len)
263 {
264 	static bool first = true;
265 	unsigned int do_w;
266 	ssize_t bw;
267 
268 	do_w = rand() & 0xffff;
269 	if (do_w == 0 || do_w > len)
270 		do_w = len;
271 
272 	if (cfg_join && first && do_w > 100)
273 		do_w = 100;
274 
275 	if (cfg_remove && do_w > 50)
276 		do_w = 50;
277 
278 	bw = write(fd, buf, do_w);
279 	if (bw < 0)
280 		perror("write");
281 
282 	/* let the join handshake complete, before going on */
283 	if (cfg_join && first) {
284 		usleep(200000);
285 		first = false;
286 	}
287 
288 	if (cfg_remove)
289 		usleep(200000);
290 
291 	return bw;
292 }
293 
294 static size_t do_write(const int fd, char *buf, const size_t len)
295 {
296 	size_t offset = 0;
297 
298 	while (offset < len) {
299 		size_t written;
300 		ssize_t bw;
301 
302 		bw = write(fd, buf + offset, len - offset);
303 		if (bw < 0) {
304 			perror("write");
305 			return 0;
306 		}
307 
308 		written = (size_t)bw;
309 		offset += written;
310 	}
311 
312 	return offset;
313 }
314 
315 static ssize_t do_rnd_read(const int fd, char *buf, const size_t len)
316 {
317 	size_t cap = rand();
318 
319 	cap &= 0xffff;
320 
321 	if (cap == 0)
322 		cap = 1;
323 	else if (cap > len)
324 		cap = len;
325 
326 	return read(fd, buf, cap);
327 }
328 
329 static void set_nonblock(int fd)
330 {
331 	int flags = fcntl(fd, F_GETFL);
332 
333 	if (flags == -1)
334 		return;
335 
336 	fcntl(fd, F_SETFL, flags | O_NONBLOCK);
337 }
338 
339 static int copyfd_io_poll(int infd, int peerfd, int outfd)
340 {
341 	struct pollfd fds = {
342 		.fd = peerfd,
343 		.events = POLLIN | POLLOUT,
344 	};
345 	unsigned int woff = 0, wlen = 0;
346 	char wbuf[8192];
347 
348 	set_nonblock(peerfd);
349 
350 	for (;;) {
351 		char rbuf[8192];
352 		ssize_t len;
353 
354 		if (fds.events == 0)
355 			break;
356 
357 		switch (poll(&fds, 1, poll_timeout)) {
358 		case -1:
359 			if (errno == EINTR)
360 				continue;
361 			perror("poll");
362 			return 1;
363 		case 0:
364 			fprintf(stderr, "%s: poll timed out (events: "
365 				"POLLIN %u, POLLOUT %u)\n", __func__,
366 				fds.events & POLLIN, fds.events & POLLOUT);
367 			return 2;
368 		}
369 
370 		if (fds.revents & POLLIN) {
371 			len = do_rnd_read(peerfd, rbuf, sizeof(rbuf));
372 			if (len == 0) {
373 				/* no more data to receive:
374 				 * peer has closed its write side
375 				 */
376 				fds.events &= ~POLLIN;
377 
378 				if ((fds.events & POLLOUT) == 0)
379 					/* and nothing more to send */
380 					break;
381 
382 			/* Else, still have data to transmit */
383 			} else if (len < 0) {
384 				perror("read");
385 				return 3;
386 			}
387 
388 			do_write(outfd, rbuf, len);
389 		}
390 
391 		if (fds.revents & POLLOUT) {
392 			if (wlen == 0) {
393 				woff = 0;
394 				wlen = read(infd, wbuf, sizeof(wbuf));
395 			}
396 
397 			if (wlen > 0) {
398 				ssize_t bw;
399 
400 				bw = do_rnd_write(peerfd, wbuf + woff, wlen);
401 				if (bw < 0)
402 					return 111;
403 
404 				woff += bw;
405 				wlen -= bw;
406 			} else if (wlen == 0) {
407 				/* We have no more data to send. */
408 				fds.events &= ~POLLOUT;
409 
410 				if ((fds.events & POLLIN) == 0)
411 					/* ... and peer also closed already */
412 					break;
413 
414 				/* ... but we still receive.
415 				 * Close our write side, ev. give some time
416 				 * for address notification and/or checking
417 				 * the current status
418 				 */
419 				if (cfg_wait)
420 					usleep(cfg_wait);
421 				shutdown(peerfd, SHUT_WR);
422 			} else {
423 				if (errno == EINTR)
424 					continue;
425 				perror("read");
426 				return 4;
427 			}
428 		}
429 
430 		if (fds.revents & (POLLERR | POLLNVAL)) {
431 			fprintf(stderr, "Unexpected revents: "
432 				"POLLERR/POLLNVAL(%x)\n", fds.revents);
433 			return 5;
434 		}
435 	}
436 
437 	/* leave some time for late join/announce */
438 	if (cfg_join || cfg_remove)
439 		usleep(cfg_wait);
440 
441 	close(peerfd);
442 	return 0;
443 }
444 
445 static int do_recvfile(int infd, int outfd)
446 {
447 	ssize_t r;
448 
449 	do {
450 		char buf[16384];
451 
452 		r = do_rnd_read(infd, buf, sizeof(buf));
453 		if (r > 0) {
454 			if (write(outfd, buf, r) != r)
455 				break;
456 		} else if (r < 0) {
457 			perror("read");
458 		}
459 	} while (r > 0);
460 
461 	return (int)r;
462 }
463 
464 static int do_mmap(int infd, int outfd, unsigned int size)
465 {
466 	char *inbuf = mmap(NULL, size, PROT_READ, MAP_SHARED, infd, 0);
467 	ssize_t ret = 0, off = 0;
468 	size_t rem;
469 
470 	if (inbuf == MAP_FAILED) {
471 		perror("mmap");
472 		return 1;
473 	}
474 
475 	rem = size;
476 
477 	while (rem > 0) {
478 		ret = write(outfd, inbuf + off, rem);
479 
480 		if (ret < 0) {
481 			perror("write");
482 			break;
483 		}
484 
485 		off += ret;
486 		rem -= ret;
487 	}
488 
489 	munmap(inbuf, size);
490 	return rem;
491 }
492 
493 static int get_infd_size(int fd)
494 {
495 	struct stat sb;
496 	ssize_t count;
497 	int err;
498 
499 	err = fstat(fd, &sb);
500 	if (err < 0) {
501 		perror("fstat");
502 		return -1;
503 	}
504 
505 	if ((sb.st_mode & S_IFMT) != S_IFREG) {
506 		fprintf(stderr, "%s: stdin is not a regular file\n", __func__);
507 		return -2;
508 	}
509 
510 	count = sb.st_size;
511 	if (count > INT_MAX) {
512 		fprintf(stderr, "File too large: %zu\n", count);
513 		return -3;
514 	}
515 
516 	return (int)count;
517 }
518 
519 static int do_sendfile(int infd, int outfd, unsigned int count)
520 {
521 	while (count > 0) {
522 		ssize_t r;
523 
524 		r = sendfile(outfd, infd, NULL, count);
525 		if (r < 0) {
526 			perror("sendfile");
527 			return 3;
528 		}
529 
530 		count -= r;
531 	}
532 
533 	return 0;
534 }
535 
536 static int copyfd_io_mmap(int infd, int peerfd, int outfd,
537 			  unsigned int size)
538 {
539 	int err;
540 
541 	if (listen_mode) {
542 		err = do_recvfile(peerfd, outfd);
543 		if (err)
544 			return err;
545 
546 		err = do_mmap(infd, peerfd, size);
547 	} else {
548 		err = do_mmap(infd, peerfd, size);
549 		if (err)
550 			return err;
551 
552 		shutdown(peerfd, SHUT_WR);
553 
554 		err = do_recvfile(peerfd, outfd);
555 	}
556 
557 	return err;
558 }
559 
560 static int copyfd_io_sendfile(int infd, int peerfd, int outfd,
561 			      unsigned int size)
562 {
563 	int err;
564 
565 	if (listen_mode) {
566 		err = do_recvfile(peerfd, outfd);
567 		if (err)
568 			return err;
569 
570 		err = do_sendfile(infd, peerfd, size);
571 	} else {
572 		err = do_sendfile(infd, peerfd, size);
573 		if (err)
574 			return err;
575 		err = do_recvfile(peerfd, outfd);
576 	}
577 
578 	return err;
579 }
580 
581 static int copyfd_io(int infd, int peerfd, int outfd)
582 {
583 	int file_size;
584 
585 	switch (cfg_mode) {
586 	case CFG_MODE_POLL:
587 		return copyfd_io_poll(infd, peerfd, outfd);
588 	case CFG_MODE_MMAP:
589 		file_size = get_infd_size(infd);
590 		if (file_size < 0)
591 			return file_size;
592 		return copyfd_io_mmap(infd, peerfd, outfd, file_size);
593 	case CFG_MODE_SENDFILE:
594 		file_size = get_infd_size(infd);
595 		if (file_size < 0)
596 			return file_size;
597 		return copyfd_io_sendfile(infd, peerfd, outfd, file_size);
598 	}
599 
600 	fprintf(stderr, "Invalid mode %d\n", cfg_mode);
601 
602 	die_usage();
603 	return 1;
604 }
605 
606 static void check_sockaddr(int pf, struct sockaddr_storage *ss,
607 			   socklen_t salen)
608 {
609 	struct sockaddr_in6 *sin6;
610 	struct sockaddr_in *sin;
611 	socklen_t wanted_size = 0;
612 
613 	switch (pf) {
614 	case AF_INET:
615 		wanted_size = sizeof(*sin);
616 		sin = (void *)ss;
617 		if (!sin->sin_port)
618 			fprintf(stderr, "accept: something wrong: ip connection from port 0");
619 		break;
620 	case AF_INET6:
621 		wanted_size = sizeof(*sin6);
622 		sin6 = (void *)ss;
623 		if (!sin6->sin6_port)
624 			fprintf(stderr, "accept: something wrong: ipv6 connection from port 0");
625 		break;
626 	default:
627 		fprintf(stderr, "accept: Unknown pf %d, salen %u\n", pf, salen);
628 		return;
629 	}
630 
631 	if (salen != wanted_size)
632 		fprintf(stderr, "accept: size mismatch, got %d expected %d\n",
633 			(int)salen, wanted_size);
634 
635 	if (ss->ss_family != pf)
636 		fprintf(stderr, "accept: pf mismatch, expect %d, ss_family is %d\n",
637 			(int)ss->ss_family, pf);
638 }
639 
640 static void check_getpeername(int fd, struct sockaddr_storage *ss, socklen_t salen)
641 {
642 	struct sockaddr_storage peerss;
643 	socklen_t peersalen = sizeof(peerss);
644 
645 	if (getpeername(fd, (struct sockaddr *)&peerss, &peersalen) < 0) {
646 		perror("getpeername");
647 		return;
648 	}
649 
650 	if (peersalen != salen) {
651 		fprintf(stderr, "%s: %d vs %d\n", __func__, peersalen, salen);
652 		return;
653 	}
654 
655 	if (memcmp(ss, &peerss, peersalen)) {
656 		char a[INET6_ADDRSTRLEN];
657 		char b[INET6_ADDRSTRLEN];
658 		char c[INET6_ADDRSTRLEN];
659 		char d[INET6_ADDRSTRLEN];
660 
661 		xgetnameinfo((struct sockaddr *)ss, salen,
662 			     a, sizeof(a), b, sizeof(b));
663 
664 		xgetnameinfo((struct sockaddr *)&peerss, peersalen,
665 			     c, sizeof(c), d, sizeof(d));
666 
667 		fprintf(stderr, "%s: memcmp failure: accept %s vs peername %s, %s vs %s salen %d vs %d\n",
668 			__func__, a, c, b, d, peersalen, salen);
669 	}
670 }
671 
672 static void check_getpeername_connect(int fd)
673 {
674 	struct sockaddr_storage ss;
675 	socklen_t salen = sizeof(ss);
676 	char a[INET6_ADDRSTRLEN];
677 	char b[INET6_ADDRSTRLEN];
678 
679 	if (getpeername(fd, (struct sockaddr *)&ss, &salen) < 0) {
680 		perror("getpeername");
681 		return;
682 	}
683 
684 	xgetnameinfo((struct sockaddr *)&ss, salen,
685 		     a, sizeof(a), b, sizeof(b));
686 
687 	if (strcmp(cfg_host, a) || strcmp(cfg_port, b))
688 		fprintf(stderr, "%s: %s vs %s, %s vs %s\n", __func__,
689 			cfg_host, a, cfg_port, b);
690 }
691 
692 static void maybe_close(int fd)
693 {
694 	unsigned int r = rand();
695 
696 	if (!(cfg_join || cfg_remove) && (r & 1))
697 		close(fd);
698 }
699 
700 int main_loop_s(int listensock)
701 {
702 	struct sockaddr_storage ss;
703 	struct pollfd polls;
704 	socklen_t salen;
705 	int remotesock;
706 
707 	polls.fd = listensock;
708 	polls.events = POLLIN;
709 
710 	switch (poll(&polls, 1, poll_timeout)) {
711 	case -1:
712 		perror("poll");
713 		return 1;
714 	case 0:
715 		fprintf(stderr, "%s: timed out\n", __func__);
716 		close(listensock);
717 		return 2;
718 	}
719 
720 	salen = sizeof(ss);
721 	remotesock = accept(listensock, (struct sockaddr *)&ss, &salen);
722 	if (remotesock >= 0) {
723 		maybe_close(listensock);
724 		check_sockaddr(pf, &ss, salen);
725 		check_getpeername(remotesock, &ss, salen);
726 
727 		return copyfd_io(0, remotesock, 1);
728 	}
729 
730 	perror("accept");
731 
732 	return 1;
733 }
734 
735 static void init_rng(void)
736 {
737 	int fd = open("/dev/urandom", O_RDONLY);
738 	unsigned int foo;
739 
740 	if (fd > 0) {
741 		int ret = read(fd, &foo, sizeof(foo));
742 
743 		if (ret < 0)
744 			srand(fd + foo);
745 		close(fd);
746 	}
747 
748 	srand(foo);
749 }
750 
751 int main_loop(void)
752 {
753 	int fd;
754 
755 	/* listener is ready. */
756 	fd = sock_connect_mptcp(cfg_host, cfg_port, cfg_sock_proto);
757 	if (fd < 0)
758 		return 2;
759 
760 	check_getpeername_connect(fd);
761 
762 	if (cfg_rcvbuf)
763 		set_rcvbuf(fd, cfg_rcvbuf);
764 	if (cfg_sndbuf)
765 		set_sndbuf(fd, cfg_sndbuf);
766 
767 	return copyfd_io(0, fd, 1);
768 }
769 
770 int parse_proto(const char *proto)
771 {
772 	if (!strcasecmp(proto, "MPTCP"))
773 		return IPPROTO_MPTCP;
774 	if (!strcasecmp(proto, "TCP"))
775 		return IPPROTO_TCP;
776 
777 	fprintf(stderr, "Unknown protocol: %s\n.", proto);
778 	die_usage();
779 
780 	/* silence compiler warning */
781 	return 0;
782 }
783 
784 int parse_mode(const char *mode)
785 {
786 	if (!strcasecmp(mode, "poll"))
787 		return CFG_MODE_POLL;
788 	if (!strcasecmp(mode, "mmap"))
789 		return CFG_MODE_MMAP;
790 	if (!strcasecmp(mode, "sendfile"))
791 		return CFG_MODE_SENDFILE;
792 
793 	fprintf(stderr, "Unknown test mode: %s\n", mode);
794 	fprintf(stderr, "Supported modes are:\n");
795 	fprintf(stderr, "\t\t\"poll\" - interleaved read/write using poll()\n");
796 	fprintf(stderr, "\t\t\"mmap\" - send entire input file (mmap+write), then read response (-l will read input first)\n");
797 	fprintf(stderr, "\t\t\"sendfile\" - send entire input file (sendfile), then read response (-l will read input first)\n");
798 
799 	die_usage();
800 
801 	/* silence compiler warning */
802 	return 0;
803 }
804 
805 static int parse_int(const char *size)
806 {
807 	unsigned long s;
808 
809 	errno = 0;
810 
811 	s = strtoul(size, NULL, 0);
812 
813 	if (errno) {
814 		fprintf(stderr, "Invalid sndbuf size %s (%s)\n",
815 			size, strerror(errno));
816 		die_usage();
817 	}
818 
819 	if (s > INT_MAX) {
820 		fprintf(stderr, "Invalid sndbuf size %s (%s)\n",
821 			size, strerror(ERANGE));
822 		die_usage();
823 	}
824 
825 	return (int)s;
826 }
827 
828 static void parse_opts(int argc, char **argv)
829 {
830 	int c;
831 
832 	while ((c = getopt(argc, argv, "6jrlp:s:hut:m:S:R:w:")) != -1) {
833 		switch (c) {
834 		case 'j':
835 			cfg_join = true;
836 			cfg_mode = CFG_MODE_POLL;
837 			cfg_wait = 400000;
838 			break;
839 		case 'r':
840 			cfg_remove = true;
841 			cfg_mode = CFG_MODE_POLL;
842 			cfg_wait = 400000;
843 			break;
844 		case 'l':
845 			listen_mode = true;
846 			break;
847 		case 'p':
848 			cfg_port = optarg;
849 			break;
850 		case 's':
851 			cfg_sock_proto = parse_proto(optarg);
852 			break;
853 		case 'h':
854 			die_usage();
855 			break;
856 		case 'u':
857 			tcpulp_audit = true;
858 			break;
859 		case '6':
860 			pf = AF_INET6;
861 			break;
862 		case 't':
863 			poll_timeout = atoi(optarg) * 1000;
864 			if (poll_timeout <= 0)
865 				poll_timeout = -1;
866 			break;
867 		case 'm':
868 			cfg_mode = parse_mode(optarg);
869 			break;
870 		case 'S':
871 			cfg_sndbuf = parse_int(optarg);
872 			break;
873 		case 'R':
874 			cfg_rcvbuf = parse_int(optarg);
875 			break;
876 		case 'w':
877 			cfg_wait = atoi(optarg)*1000000;
878 			break;
879 		}
880 	}
881 
882 	if (optind + 1 != argc)
883 		die_usage();
884 	cfg_host = argv[optind];
885 
886 	if (strchr(cfg_host, ':'))
887 		pf = AF_INET6;
888 }
889 
890 int main(int argc, char *argv[])
891 {
892 	init_rng();
893 
894 	signal(SIGUSR1, handle_signal);
895 	parse_opts(argc, argv);
896 
897 	if (tcpulp_audit)
898 		return sock_test_tcpulp(cfg_host, cfg_port) ? 0 : 1;
899 
900 	if (listen_mode) {
901 		int fd = sock_listen_mptcp(cfg_host, cfg_port);
902 
903 		if (fd < 0)
904 			return 1;
905 
906 		if (cfg_rcvbuf)
907 			set_rcvbuf(fd, cfg_rcvbuf);
908 		if (cfg_sndbuf)
909 			set_sndbuf(fd, cfg_sndbuf);
910 
911 		return main_loop_s(fd);
912 	}
913 
914 	return main_loop();
915 }
916