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 <stdarg.h>
10 #include <stdbool.h>
11 #include <stdint.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <strings.h>
15 #include <signal.h>
16 #include <unistd.h>
17 #include <time.h>
18
19 #include <sys/ioctl.h>
20 #include <sys/poll.h>
21 #include <sys/random.h>
22 #include <sys/sendfile.h>
23 #include <sys/stat.h>
24 #include <sys/socket.h>
25 #include <sys/types.h>
26 #include <sys/mman.h>
27
28 #include <arpa/inet.h>
29
30 #include <netdb.h>
31 #include <netinet/in.h>
32
33 #include <linux/tcp.h>
34 #include <linux/time_types.h>
35 #include <linux/sockios.h>
36
37 extern int optind;
38
39 #ifndef IPPROTO_MPTCP
40 #define IPPROTO_MPTCP 262
41 #endif
42 #ifndef TCP_ULP
43 #define TCP_ULP 31
44 #endif
45
46 static int poll_timeout = 10 * 1000;
47 static bool listen_mode;
48 static bool quit;
49
50 enum cfg_mode {
51 CFG_MODE_POLL,
52 CFG_MODE_MMAP,
53 CFG_MODE_SENDFILE,
54 };
55
56 enum cfg_peek {
57 CFG_NONE_PEEK,
58 CFG_WITH_PEEK,
59 CFG_AFTER_PEEK,
60 };
61
62 static enum cfg_mode cfg_mode = CFG_MODE_POLL;
63 static enum cfg_peek cfg_peek = CFG_NONE_PEEK;
64 static const char *cfg_host;
65 static const char *cfg_port = "12000";
66 static int cfg_sock_proto = IPPROTO_MPTCP;
67 static int pf = AF_INET;
68 static int cfg_sndbuf;
69 static int cfg_rcvbuf;
70 static bool cfg_join;
71 static bool cfg_remove;
72 static unsigned int cfg_time;
73 static unsigned int cfg_do_w;
74 static int cfg_wait;
75 static uint32_t cfg_mark;
76 static char *cfg_input;
77 static int cfg_repeat = 1;
78 static int cfg_truncate;
79 static int cfg_rcv_trunc;
80
81 struct cfg_cmsg_types {
82 unsigned int cmsg_enabled:1;
83 unsigned int timestampns:1;
84 unsigned int tcp_inq:1;
85 };
86
87 struct cfg_sockopt_types {
88 unsigned int transparent:1;
89 unsigned int mptfo:1;
90 };
91
92 struct tcp_inq_state {
93 unsigned int last;
94 bool expect_eof;
95 };
96
97 struct wstate {
98 char buf[8192];
99 unsigned int len;
100 unsigned int off;
101 unsigned int total_len;
102 };
103
104 static struct tcp_inq_state tcp_inq;
105
106 static struct cfg_cmsg_types cfg_cmsg_types;
107 static struct cfg_sockopt_types cfg_sockopt_types;
108
die_usage(void)109 static void die_usage(void)
110 {
111 fprintf(stderr, "Usage: mptcp_connect [-6] [-c cmsg] [-f offset] [-i file] [-I num] [-j] [-l] "
112 "[-m mode] [-M mark] [-o option] [-p port] [-P mode] [-r num] [-R num] "
113 "[-s MPTCP|TCP] [-S num] [-t num] [-T num] [-w sec] connect_address\n");
114 fprintf(stderr, "\t-6 use ipv6\n");
115 fprintf(stderr, "\t-c cmsg -- test cmsg type <cmsg>\n");
116 fprintf(stderr, "\t-f offset -- stop the I/O after receiving and sending the specified amount "
117 "of bytes. If there are unread bytes in the receive queue, that will cause a MPTCP "
118 "fastclose at close/shutdown. If offset is negative, expect the peer to close before "
119 "all the local data as been sent, thus toleration errors on write and EPIPE signals\n");
120 fprintf(stderr, "\t-i file -- read the data to send from the given file instead of stdin");
121 fprintf(stderr, "\t-I num -- repeat the transfer 'num' times. In listen mode accepts num "
122 "incoming connections, in client mode, disconnect and reconnect to the server\n");
123 fprintf(stderr, "\t-j -- add additional sleep at connection start and tear down "
124 "-- for MPJ tests\n");
125 fprintf(stderr, "\t-l -- listens mode, accepts incoming connection\n");
126 fprintf(stderr, "\t-m [poll|mmap|sendfile] -- use poll(default)/mmap+write/sendfile\n");
127 fprintf(stderr, "\t-M mark -- set socket packet mark\n");
128 fprintf(stderr, "\t-o option -- test sockopt <option>\n");
129 fprintf(stderr, "\t-p num -- use port num\n");
130 fprintf(stderr,
131 "\t-P [saveWithPeek|saveAfterPeek] -- save data with/after MSG_PEEK form tcp socket\n");
132 fprintf(stderr, "\t-r num -- enable slow mode, limiting each write to num bytes "
133 "-- for remove addr tests\n");
134 fprintf(stderr, "\t-R num -- set SO_RCVBUF to num\n");
135 fprintf(stderr, "\t-s [MPTCP|TCP] -- use mptcp(default) or tcp sockets\n");
136 fprintf(stderr, "\t-S num -- set SO_SNDBUF to num\n");
137 fprintf(stderr, "\t-t num -- set poll timeout to num\n");
138 fprintf(stderr, "\t-T num -- set expected runtime to num ms\n");
139 fprintf(stderr, "\t-w num -- wait num sec before closing the socket\n");
140 exit(1);
141 }
142
xerror(const char * fmt,...)143 static void xerror(const char *fmt, ...)
144 {
145 va_list ap;
146
147 va_start(ap, fmt);
148 vfprintf(stderr, fmt, ap);
149 va_end(ap);
150 exit(1);
151 }
152
handle_signal(int nr)153 static void handle_signal(int nr)
154 {
155 quit = true;
156 }
157
getxinfo_strerr(int err)158 static const char *getxinfo_strerr(int err)
159 {
160 if (err == EAI_SYSTEM)
161 return strerror(errno);
162
163 return gai_strerror(err);
164 }
165
xgetnameinfo(const struct sockaddr * addr,socklen_t addrlen,char * host,socklen_t hostlen,char * serv,socklen_t servlen)166 static void xgetnameinfo(const struct sockaddr *addr, socklen_t addrlen,
167 char *host, socklen_t hostlen,
168 char *serv, socklen_t servlen)
169 {
170 int flags = NI_NUMERICHOST | NI_NUMERICSERV;
171 int err = getnameinfo(addr, addrlen, host, hostlen, serv, servlen,
172 flags);
173
174 if (err) {
175 const char *errstr = getxinfo_strerr(err);
176
177 fprintf(stderr, "Fatal: getnameinfo: %s\n", errstr);
178 exit(1);
179 }
180 }
181
xgetaddrinfo(const char * node,const char * service,const struct addrinfo * hints,struct addrinfo ** res)182 static void xgetaddrinfo(const char *node, const char *service,
183 const struct addrinfo *hints,
184 struct addrinfo **res)
185 {
186 int err = getaddrinfo(node, service, hints, res);
187
188 if (err) {
189 const char *errstr = getxinfo_strerr(err);
190
191 fprintf(stderr, "Fatal: getaddrinfo(%s:%s): %s\n",
192 node ? node : "", service ? service : "", errstr);
193 exit(1);
194 }
195 }
196
set_rcvbuf(int fd,unsigned int size)197 static void set_rcvbuf(int fd, unsigned int size)
198 {
199 int err;
200
201 err = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
202 if (err) {
203 perror("set SO_RCVBUF");
204 exit(1);
205 }
206 }
207
set_sndbuf(int fd,unsigned int size)208 static void set_sndbuf(int fd, unsigned int size)
209 {
210 int err;
211
212 err = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
213 if (err) {
214 perror("set SO_SNDBUF");
215 exit(1);
216 }
217 }
218
set_mark(int fd,uint32_t mark)219 static void set_mark(int fd, uint32_t mark)
220 {
221 int err;
222
223 err = setsockopt(fd, SOL_SOCKET, SO_MARK, &mark, sizeof(mark));
224 if (err) {
225 perror("set SO_MARK");
226 exit(1);
227 }
228 }
229
set_transparent(int fd,int pf)230 static void set_transparent(int fd, int pf)
231 {
232 int one = 1;
233
234 switch (pf) {
235 case AF_INET:
236 if (-1 == setsockopt(fd, SOL_IP, IP_TRANSPARENT, &one, sizeof(one)))
237 perror("IP_TRANSPARENT");
238 break;
239 case AF_INET6:
240 if (-1 == setsockopt(fd, IPPROTO_IPV6, IPV6_TRANSPARENT, &one, sizeof(one)))
241 perror("IPV6_TRANSPARENT");
242 break;
243 }
244 }
245
set_mptfo(int fd,int pf)246 static void set_mptfo(int fd, int pf)
247 {
248 int qlen = 25;
249
250 if (setsockopt(fd, IPPROTO_TCP, TCP_FASTOPEN, &qlen, sizeof(qlen)) == -1)
251 perror("TCP_FASTOPEN");
252 }
253
do_ulp_so(int sock,const char * name)254 static int do_ulp_so(int sock, const char *name)
255 {
256 return setsockopt(sock, IPPROTO_TCP, TCP_ULP, name, strlen(name));
257 }
258
259 #define X(m) xerror("%s:%u: %s: failed for proto %d at line %u", __FILE__, __LINE__, (m), proto, line)
sock_test_tcpulp(int sock,int proto,unsigned int line)260 static void sock_test_tcpulp(int sock, int proto, unsigned int line)
261 {
262 socklen_t buflen = 8;
263 char buf[8] = "";
264 int ret = getsockopt(sock, IPPROTO_TCP, TCP_ULP, buf, &buflen);
265
266 if (ret != 0)
267 X("getsockopt");
268
269 if (buflen > 0) {
270 if (strcmp(buf, "mptcp") != 0)
271 xerror("unexpected ULP '%s' for proto %d at line %u", buf, proto, line);
272 ret = do_ulp_so(sock, "tls");
273 if (ret == 0)
274 X("setsockopt");
275 } else if (proto == IPPROTO_MPTCP) {
276 ret = do_ulp_so(sock, "tls");
277 if (ret != -1)
278 X("setsockopt");
279 }
280
281 ret = do_ulp_so(sock, "mptcp");
282 if (ret != -1)
283 X("setsockopt");
284
285 #undef X
286 }
287
288 #define SOCK_TEST_TCPULP(s, p) sock_test_tcpulp((s), (p), __LINE__)
289
sock_listen_mptcp(const char * const listenaddr,const char * const port)290 static int sock_listen_mptcp(const char * const listenaddr,
291 const char * const port)
292 {
293 int sock = -1;
294 struct addrinfo hints = {
295 .ai_protocol = IPPROTO_TCP,
296 .ai_socktype = SOCK_STREAM,
297 .ai_flags = AI_PASSIVE | AI_NUMERICHOST
298 };
299
300 hints.ai_family = pf;
301
302 struct addrinfo *a, *addr;
303 int one = 1;
304
305 xgetaddrinfo(listenaddr, port, &hints, &addr);
306 hints.ai_family = pf;
307
308 for (a = addr; a; a = a->ai_next) {
309 sock = socket(a->ai_family, a->ai_socktype, cfg_sock_proto);
310 if (sock < 0)
311 continue;
312
313 SOCK_TEST_TCPULP(sock, cfg_sock_proto);
314
315 if (-1 == setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one,
316 sizeof(one)))
317 perror("setsockopt");
318
319 if (cfg_sockopt_types.transparent)
320 set_transparent(sock, pf);
321
322 if (cfg_sockopt_types.mptfo)
323 set_mptfo(sock, pf);
324
325 if (bind(sock, a->ai_addr, a->ai_addrlen) == 0)
326 break; /* success */
327
328 perror("bind");
329 close(sock);
330 sock = -1;
331 }
332
333 freeaddrinfo(addr);
334
335 if (sock < 0) {
336 fprintf(stderr, "Could not create listen socket\n");
337 return sock;
338 }
339
340 SOCK_TEST_TCPULP(sock, cfg_sock_proto);
341
342 if (listen(sock, 20)) {
343 perror("listen");
344 close(sock);
345 return -1;
346 }
347
348 SOCK_TEST_TCPULP(sock, cfg_sock_proto);
349
350 return sock;
351 }
352
sock_connect_mptcp(const char * const remoteaddr,const char * const port,int proto,struct addrinfo ** peer,int infd,struct wstate * winfo)353 static int sock_connect_mptcp(const char * const remoteaddr,
354 const char * const port, int proto,
355 struct addrinfo **peer,
356 int infd, struct wstate *winfo)
357 {
358 struct addrinfo hints = {
359 .ai_protocol = IPPROTO_TCP,
360 .ai_socktype = SOCK_STREAM,
361 };
362 struct addrinfo *a, *addr;
363 int syn_copied = 0;
364 int sock = -1;
365
366 hints.ai_family = pf;
367
368 xgetaddrinfo(remoteaddr, port, &hints, &addr);
369 for (a = addr; a; a = a->ai_next) {
370 sock = socket(a->ai_family, a->ai_socktype, proto);
371 if (sock < 0) {
372 perror("socket");
373 continue;
374 }
375
376 SOCK_TEST_TCPULP(sock, proto);
377
378 if (cfg_mark)
379 set_mark(sock, cfg_mark);
380
381 if (cfg_sockopt_types.mptfo) {
382 if (!winfo->total_len)
383 winfo->total_len = winfo->len = read(infd, winfo->buf,
384 sizeof(winfo->buf));
385
386 syn_copied = sendto(sock, winfo->buf, winfo->len, MSG_FASTOPEN,
387 a->ai_addr, a->ai_addrlen);
388 if (syn_copied >= 0) {
389 winfo->off = syn_copied;
390 winfo->len -= syn_copied;
391 *peer = a;
392 break; /* success */
393 }
394 } else {
395 if (connect(sock, a->ai_addr, a->ai_addrlen) == 0) {
396 *peer = a;
397 break; /* success */
398 }
399 }
400 if (cfg_sockopt_types.mptfo) {
401 perror("sendto()");
402 close(sock);
403 sock = -1;
404 } else {
405 perror("connect()");
406 close(sock);
407 sock = -1;
408 }
409 }
410
411 freeaddrinfo(addr);
412 if (sock != -1)
413 SOCK_TEST_TCPULP(sock, proto);
414 return sock;
415 }
416
do_rnd_write(const int fd,char * buf,const size_t len)417 static size_t do_rnd_write(const int fd, char *buf, const size_t len)
418 {
419 static bool first = true;
420 unsigned int do_w;
421 ssize_t bw;
422
423 do_w = rand() & 0xffff;
424 if (do_w == 0 || do_w > len)
425 do_w = len;
426
427 if (cfg_join && first && do_w > 100)
428 do_w = 100;
429
430 if (cfg_remove && do_w > cfg_do_w)
431 do_w = cfg_do_w;
432
433 bw = write(fd, buf, do_w);
434 if (bw < 0)
435 return bw;
436
437 /* let the join handshake complete, before going on */
438 if (cfg_join && first) {
439 usleep(200000);
440 first = false;
441 }
442
443 if (cfg_remove)
444 usleep(200000);
445
446 return bw;
447 }
448
do_write(const int fd,char * buf,const size_t len)449 static size_t do_write(const int fd, char *buf, const size_t len)
450 {
451 size_t offset = 0;
452
453 while (offset < len) {
454 size_t written;
455 ssize_t bw;
456
457 bw = write(fd, buf + offset, len - offset);
458 if (bw < 0) {
459 perror("write");
460 return 0;
461 }
462
463 written = (size_t)bw;
464 offset += written;
465 }
466
467 return offset;
468 }
469
process_cmsg(struct msghdr * msgh)470 static void process_cmsg(struct msghdr *msgh)
471 {
472 struct __kernel_timespec ts;
473 bool inq_found = false;
474 bool ts_found = false;
475 unsigned int inq = 0;
476 struct cmsghdr *cmsg;
477
478 for (cmsg = CMSG_FIRSTHDR(msgh); cmsg ; cmsg = CMSG_NXTHDR(msgh, cmsg)) {
479 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SO_TIMESTAMPNS_NEW) {
480 memcpy(&ts, CMSG_DATA(cmsg), sizeof(ts));
481 ts_found = true;
482 continue;
483 }
484 if (cmsg->cmsg_level == IPPROTO_TCP && cmsg->cmsg_type == TCP_CM_INQ) {
485 memcpy(&inq, CMSG_DATA(cmsg), sizeof(inq));
486 inq_found = true;
487 continue;
488 }
489
490 }
491
492 if (cfg_cmsg_types.timestampns) {
493 if (!ts_found)
494 xerror("TIMESTAMPNS not present\n");
495 }
496
497 if (cfg_cmsg_types.tcp_inq) {
498 if (!inq_found)
499 xerror("TCP_INQ not present\n");
500
501 if (inq > 1024)
502 xerror("tcp_inq %u is larger than one kbyte\n", inq);
503 tcp_inq.last = inq;
504 }
505 }
506
do_recvmsg_cmsg(const int fd,char * buf,const size_t len)507 static ssize_t do_recvmsg_cmsg(const int fd, char *buf, const size_t len)
508 {
509 char msg_buf[8192];
510 struct iovec iov = {
511 .iov_base = buf,
512 .iov_len = len,
513 };
514 struct msghdr msg = {
515 .msg_iov = &iov,
516 .msg_iovlen = 1,
517 .msg_control = msg_buf,
518 .msg_controllen = sizeof(msg_buf),
519 };
520 int flags = 0;
521 unsigned int last_hint = tcp_inq.last;
522 int ret = recvmsg(fd, &msg, flags);
523
524 if (ret <= 0) {
525 if (ret == 0 && tcp_inq.expect_eof)
526 return ret;
527
528 if (ret == 0 && cfg_cmsg_types.tcp_inq)
529 if (last_hint != 1 && last_hint != 0)
530 xerror("EOF but last tcp_inq hint was %u\n", last_hint);
531
532 return ret;
533 }
534
535 if (tcp_inq.expect_eof)
536 xerror("expected EOF, last_hint %u, now %u\n",
537 last_hint, tcp_inq.last);
538
539 if (msg.msg_controllen && !cfg_cmsg_types.cmsg_enabled)
540 xerror("got %lu bytes of cmsg data, expected 0\n",
541 (unsigned long)msg.msg_controllen);
542
543 if (msg.msg_controllen == 0 && cfg_cmsg_types.cmsg_enabled)
544 xerror("%s\n", "got no cmsg data");
545
546 if (msg.msg_controllen)
547 process_cmsg(&msg);
548
549 if (cfg_cmsg_types.tcp_inq) {
550 if ((size_t)ret < len && last_hint > (unsigned int)ret) {
551 if (ret + 1 != (int)last_hint) {
552 int next = read(fd, msg_buf, sizeof(msg_buf));
553
554 xerror("read %u of %u, last_hint was %u tcp_inq hint now %u next_read returned %d/%m\n",
555 ret, (unsigned int)len, last_hint, tcp_inq.last, next);
556 } else {
557 tcp_inq.expect_eof = true;
558 }
559 }
560 }
561
562 return ret;
563 }
564
do_rnd_read(const int fd,char * buf,const size_t len)565 static ssize_t do_rnd_read(const int fd, char *buf, const size_t len)
566 {
567 int ret = 0;
568 char tmp[16384];
569 size_t cap = rand();
570
571 cap &= 0xffff;
572
573 if (cap == 0)
574 cap = 1;
575 else if (cap > len)
576 cap = len;
577
578 if (cfg_peek == CFG_WITH_PEEK) {
579 ret = recv(fd, buf, cap, MSG_PEEK);
580 ret = (ret < 0) ? ret : read(fd, tmp, ret);
581 } else if (cfg_peek == CFG_AFTER_PEEK) {
582 ret = recv(fd, buf, cap, MSG_PEEK);
583 ret = (ret < 0) ? ret : read(fd, buf, cap);
584 } else if (cfg_cmsg_types.cmsg_enabled) {
585 ret = do_recvmsg_cmsg(fd, buf, cap);
586 } else {
587 ret = read(fd, buf, cap);
588 }
589
590 return ret;
591 }
592
set_nonblock(int fd,bool nonblock)593 static void set_nonblock(int fd, bool nonblock)
594 {
595 int flags = fcntl(fd, F_GETFL);
596
597 if (flags == -1)
598 return;
599
600 if (nonblock)
601 fcntl(fd, F_SETFL, flags | O_NONBLOCK);
602 else
603 fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
604 }
605
shut_wr(int fd)606 static void shut_wr(int fd)
607 {
608 /* Close our write side, ev. give some time
609 * for address notification and/or checking
610 * the current status
611 */
612 if (cfg_wait)
613 usleep(cfg_wait);
614
615 shutdown(fd, SHUT_WR);
616 }
617
copyfd_io_poll(int infd,int peerfd,int outfd,bool * in_closed_after_out,struct wstate * winfo)618 static int copyfd_io_poll(int infd, int peerfd, int outfd,
619 bool *in_closed_after_out, struct wstate *winfo)
620 {
621 struct pollfd fds = {
622 .fd = peerfd,
623 .events = POLLIN | POLLOUT,
624 };
625 unsigned int total_wlen = 0, total_rlen = 0;
626
627 set_nonblock(peerfd, true);
628
629 for (;;) {
630 char rbuf[8192];
631 ssize_t len;
632
633 if (fds.events == 0 || quit)
634 break;
635
636 switch (poll(&fds, 1, poll_timeout)) {
637 case -1:
638 if (errno == EINTR)
639 continue;
640 perror("poll");
641 return 1;
642 case 0:
643 fprintf(stderr, "%s: poll timed out (events: "
644 "POLLIN %u, POLLOUT %u)\n", __func__,
645 fds.events & POLLIN, fds.events & POLLOUT);
646 return 2;
647 }
648
649 if (fds.revents & POLLIN) {
650 ssize_t rb = sizeof(rbuf);
651
652 /* limit the total amount of read data to the trunc value*/
653 if (cfg_truncate > 0) {
654 if (rb + total_rlen > cfg_truncate)
655 rb = cfg_truncate - total_rlen;
656 len = read(peerfd, rbuf, rb);
657 } else {
658 len = do_rnd_read(peerfd, rbuf, sizeof(rbuf));
659 }
660 if (len == 0) {
661 /* no more data to receive:
662 * peer has closed its write side
663 */
664 fds.events &= ~POLLIN;
665
666 if ((fds.events & POLLOUT) == 0) {
667 *in_closed_after_out = true;
668 /* and nothing more to send */
669 break;
670 }
671
672 /* Else, still have data to transmit */
673 } else if (len < 0) {
674 if (cfg_rcv_trunc)
675 return 0;
676 perror("read");
677 return 3;
678 }
679
680 total_rlen += len;
681 do_write(outfd, rbuf, len);
682 }
683
684 if (fds.revents & POLLOUT) {
685 if (winfo->len == 0) {
686 winfo->off = 0;
687 winfo->len = read(infd, winfo->buf, sizeof(winfo->buf));
688 }
689
690 if (winfo->len > 0) {
691 ssize_t bw;
692
693 /* limit the total amount of written data to the trunc value */
694 if (cfg_truncate > 0 && winfo->len + total_wlen > cfg_truncate)
695 winfo->len = cfg_truncate - total_wlen;
696
697 bw = do_rnd_write(peerfd, winfo->buf + winfo->off, winfo->len);
698 if (bw < 0) {
699 if (cfg_rcv_trunc)
700 return 0;
701 perror("write");
702 return 111;
703 }
704
705 winfo->off += bw;
706 winfo->len -= bw;
707 total_wlen += bw;
708 } else if (winfo->len == 0) {
709 /* We have no more data to send. */
710 fds.events &= ~POLLOUT;
711
712 if ((fds.events & POLLIN) == 0)
713 /* ... and peer also closed already */
714 break;
715
716 shut_wr(peerfd);
717 } else {
718 if (errno == EINTR)
719 continue;
720 perror("read");
721 return 4;
722 }
723 }
724
725 if (fds.revents & (POLLERR | POLLNVAL)) {
726 if (cfg_rcv_trunc)
727 return 0;
728 fprintf(stderr, "Unexpected revents: "
729 "POLLERR/POLLNVAL(%x)\n", fds.revents);
730 return 5;
731 }
732
733 if (cfg_truncate > 0 && total_wlen >= cfg_truncate &&
734 total_rlen >= cfg_truncate)
735 break;
736 }
737
738 /* leave some time for late join/announce */
739 if (cfg_remove && !quit)
740 usleep(cfg_wait);
741
742 return 0;
743 }
744
do_recvfile(int infd,int outfd)745 static int do_recvfile(int infd, int outfd)
746 {
747 ssize_t r;
748
749 do {
750 char buf[16384];
751
752 r = do_rnd_read(infd, buf, sizeof(buf));
753 if (r > 0) {
754 if (write(outfd, buf, r) != r)
755 break;
756 } else if (r < 0) {
757 perror("read");
758 }
759 } while (r > 0);
760
761 return (int)r;
762 }
763
spool_buf(int fd,struct wstate * winfo)764 static int spool_buf(int fd, struct wstate *winfo)
765 {
766 while (winfo->len) {
767 int ret = write(fd, winfo->buf + winfo->off, winfo->len);
768
769 if (ret < 0) {
770 perror("write");
771 return 4;
772 }
773 winfo->off += ret;
774 winfo->len -= ret;
775 }
776 return 0;
777 }
778
do_mmap(int infd,int outfd,unsigned int size,struct wstate * winfo)779 static int do_mmap(int infd, int outfd, unsigned int size,
780 struct wstate *winfo)
781 {
782 char *inbuf = mmap(NULL, size, PROT_READ, MAP_SHARED, infd, 0);
783 ssize_t ret = 0, off = winfo->total_len;
784 size_t rem;
785
786 if (inbuf == MAP_FAILED) {
787 perror("mmap");
788 return 1;
789 }
790
791 ret = spool_buf(outfd, winfo);
792 if (ret < 0)
793 return ret;
794
795 rem = size - winfo->total_len;
796
797 while (rem > 0) {
798 ret = write(outfd, inbuf + off, rem);
799
800 if (ret < 0) {
801 perror("write");
802 break;
803 }
804
805 off += ret;
806 rem -= ret;
807 }
808
809 munmap(inbuf, size);
810 return rem;
811 }
812
get_infd_size(int fd)813 static int get_infd_size(int fd)
814 {
815 struct stat sb;
816 ssize_t count;
817 int err;
818
819 err = fstat(fd, &sb);
820 if (err < 0) {
821 perror("fstat");
822 return -1;
823 }
824
825 if ((sb.st_mode & S_IFMT) != S_IFREG) {
826 fprintf(stderr, "%s: stdin is not a regular file\n", __func__);
827 return -2;
828 }
829
830 count = sb.st_size;
831 if (count > INT_MAX) {
832 fprintf(stderr, "File too large: %zu\n", count);
833 return -3;
834 }
835
836 return (int)count;
837 }
838
do_sendfile(int infd,int outfd,unsigned int count,struct wstate * winfo)839 static int do_sendfile(int infd, int outfd, unsigned int count,
840 struct wstate *winfo)
841 {
842 int ret = spool_buf(outfd, winfo);
843
844 if (ret < 0)
845 return ret;
846
847 count -= winfo->total_len;
848
849 while (count > 0) {
850 ssize_t r;
851
852 r = sendfile(outfd, infd, NULL, count);
853 if (r < 0) {
854 perror("sendfile");
855 return 3;
856 }
857
858 count -= r;
859 }
860
861 return 0;
862 }
863
copyfd_io_mmap(int infd,int peerfd,int outfd,unsigned int size,bool * in_closed_after_out,struct wstate * winfo)864 static int copyfd_io_mmap(int infd, int peerfd, int outfd,
865 unsigned int size, bool *in_closed_after_out,
866 struct wstate *winfo)
867 {
868 int err;
869
870 if (listen_mode) {
871 err = do_recvfile(peerfd, outfd);
872 if (err)
873 return err;
874
875 err = do_mmap(infd, peerfd, size, winfo);
876 } else {
877 err = do_mmap(infd, peerfd, size, winfo);
878 if (err)
879 return err;
880
881 shut_wr(peerfd);
882
883 err = do_recvfile(peerfd, outfd);
884 *in_closed_after_out = true;
885 }
886
887 return err;
888 }
889
copyfd_io_sendfile(int infd,int peerfd,int outfd,unsigned int size,bool * in_closed_after_out,struct wstate * winfo)890 static int copyfd_io_sendfile(int infd, int peerfd, int outfd,
891 unsigned int size, bool *in_closed_after_out, struct wstate *winfo)
892 {
893 int err;
894
895 if (listen_mode) {
896 err = do_recvfile(peerfd, outfd);
897 if (err)
898 return err;
899
900 err = do_sendfile(infd, peerfd, size, winfo);
901 } else {
902 err = do_sendfile(infd, peerfd, size, winfo);
903 if (err)
904 return err;
905
906 shut_wr(peerfd);
907
908 err = do_recvfile(peerfd, outfd);
909 *in_closed_after_out = true;
910 }
911
912 return err;
913 }
914
copyfd_io(int infd,int peerfd,int outfd,bool close_peerfd,struct wstate * winfo)915 static int copyfd_io(int infd, int peerfd, int outfd, bool close_peerfd, struct wstate *winfo)
916 {
917 bool in_closed_after_out = false;
918 struct timespec start, end;
919 int file_size;
920 int ret;
921
922 if (cfg_time && (clock_gettime(CLOCK_MONOTONIC, &start) < 0))
923 xerror("can not fetch start time %d", errno);
924
925 switch (cfg_mode) {
926 case CFG_MODE_POLL:
927 ret = copyfd_io_poll(infd, peerfd, outfd, &in_closed_after_out,
928 winfo);
929 break;
930
931 case CFG_MODE_MMAP:
932 file_size = get_infd_size(infd);
933 if (file_size < 0)
934 return file_size;
935 ret = copyfd_io_mmap(infd, peerfd, outfd, file_size,
936 &in_closed_after_out, winfo);
937 break;
938
939 case CFG_MODE_SENDFILE:
940 file_size = get_infd_size(infd);
941 if (file_size < 0)
942 return file_size;
943 ret = copyfd_io_sendfile(infd, peerfd, outfd, file_size,
944 &in_closed_after_out, winfo);
945 break;
946
947 default:
948 fprintf(stderr, "Invalid mode %d\n", cfg_mode);
949
950 die_usage();
951 return 1;
952 }
953
954 if (ret)
955 return ret;
956
957 if (close_peerfd)
958 close(peerfd);
959
960 if (cfg_time) {
961 unsigned int delta_ms;
962
963 if (clock_gettime(CLOCK_MONOTONIC, &end) < 0)
964 xerror("can not fetch end time %d", errno);
965 delta_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000;
966 if (delta_ms > cfg_time) {
967 xerror("transfer slower than expected! runtime %d ms, expected %d ms",
968 delta_ms, cfg_time);
969 }
970
971 /* show the runtime only if this end shutdown(wr) before receiving the EOF,
972 * (that is, if this end got the longer runtime)
973 */
974 if (in_closed_after_out)
975 fprintf(stderr, "%d", delta_ms);
976 }
977
978 return 0;
979 }
980
check_sockaddr(int pf,struct sockaddr_storage * ss,socklen_t salen)981 static void check_sockaddr(int pf, struct sockaddr_storage *ss,
982 socklen_t salen)
983 {
984 struct sockaddr_in6 *sin6;
985 struct sockaddr_in *sin;
986 socklen_t wanted_size = 0;
987
988 switch (pf) {
989 case AF_INET:
990 wanted_size = sizeof(*sin);
991 sin = (void *)ss;
992 if (!sin->sin_port)
993 fprintf(stderr, "accept: something wrong: ip connection from port 0");
994 break;
995 case AF_INET6:
996 wanted_size = sizeof(*sin6);
997 sin6 = (void *)ss;
998 if (!sin6->sin6_port)
999 fprintf(stderr, "accept: something wrong: ipv6 connection from port 0");
1000 break;
1001 default:
1002 fprintf(stderr, "accept: Unknown pf %d, salen %u\n", pf, salen);
1003 return;
1004 }
1005
1006 if (salen != wanted_size)
1007 fprintf(stderr, "accept: size mismatch, got %d expected %d\n",
1008 (int)salen, wanted_size);
1009
1010 if (ss->ss_family != pf)
1011 fprintf(stderr, "accept: pf mismatch, expect %d, ss_family is %d\n",
1012 (int)ss->ss_family, pf);
1013 }
1014
check_getpeername(int fd,struct sockaddr_storage * ss,socklen_t salen)1015 static void check_getpeername(int fd, struct sockaddr_storage *ss, socklen_t salen)
1016 {
1017 struct sockaddr_storage peerss;
1018 socklen_t peersalen = sizeof(peerss);
1019
1020 if (getpeername(fd, (struct sockaddr *)&peerss, &peersalen) < 0) {
1021 perror("getpeername");
1022 return;
1023 }
1024
1025 if (peersalen != salen) {
1026 fprintf(stderr, "%s: %d vs %d\n", __func__, peersalen, salen);
1027 return;
1028 }
1029
1030 if (memcmp(ss, &peerss, peersalen)) {
1031 char a[INET6_ADDRSTRLEN];
1032 char b[INET6_ADDRSTRLEN];
1033 char c[INET6_ADDRSTRLEN];
1034 char d[INET6_ADDRSTRLEN];
1035
1036 xgetnameinfo((struct sockaddr *)ss, salen,
1037 a, sizeof(a), b, sizeof(b));
1038
1039 xgetnameinfo((struct sockaddr *)&peerss, peersalen,
1040 c, sizeof(c), d, sizeof(d));
1041
1042 fprintf(stderr, "%s: memcmp failure: accept %s vs peername %s, %s vs %s salen %d vs %d\n",
1043 __func__, a, c, b, d, peersalen, salen);
1044 }
1045 }
1046
check_getpeername_connect(int fd)1047 static void check_getpeername_connect(int fd)
1048 {
1049 struct sockaddr_storage ss;
1050 socklen_t salen = sizeof(ss);
1051 char a[INET6_ADDRSTRLEN];
1052 char b[INET6_ADDRSTRLEN];
1053
1054 if (getpeername(fd, (struct sockaddr *)&ss, &salen) < 0) {
1055 perror("getpeername");
1056 return;
1057 }
1058
1059 xgetnameinfo((struct sockaddr *)&ss, salen,
1060 a, sizeof(a), b, sizeof(b));
1061
1062 if (strcmp(cfg_host, a) || strcmp(cfg_port, b))
1063 fprintf(stderr, "%s: %s vs %s, %s vs %s\n", __func__,
1064 cfg_host, a, cfg_port, b);
1065 }
1066
maybe_close(int fd)1067 static void maybe_close(int fd)
1068 {
1069 unsigned int r = rand();
1070
1071 if (!(cfg_join || cfg_remove || cfg_repeat > 1) && (r & 1))
1072 close(fd);
1073 }
1074
main_loop_s(int listensock)1075 int main_loop_s(int listensock)
1076 {
1077 struct sockaddr_storage ss;
1078 struct wstate winfo;
1079 struct pollfd polls;
1080 socklen_t salen;
1081 int remotesock;
1082 int fd = 0;
1083
1084 again:
1085 polls.fd = listensock;
1086 polls.events = POLLIN;
1087
1088 switch (poll(&polls, 1, poll_timeout)) {
1089 case -1:
1090 perror("poll");
1091 return 1;
1092 case 0:
1093 fprintf(stderr, "%s: timed out\n", __func__);
1094 close(listensock);
1095 return 2;
1096 }
1097
1098 salen = sizeof(ss);
1099 remotesock = accept(listensock, (struct sockaddr *)&ss, &salen);
1100 if (remotesock >= 0) {
1101 maybe_close(listensock);
1102 check_sockaddr(pf, &ss, salen);
1103 check_getpeername(remotesock, &ss, salen);
1104
1105 if (cfg_input) {
1106 fd = open(cfg_input, O_RDONLY);
1107 if (fd < 0)
1108 xerror("can't open %s: %d", cfg_input, errno);
1109 }
1110
1111 SOCK_TEST_TCPULP(remotesock, 0);
1112
1113 memset(&winfo, 0, sizeof(winfo));
1114 copyfd_io(fd, remotesock, 1, true, &winfo);
1115 } else {
1116 perror("accept");
1117 return 1;
1118 }
1119
1120 if (cfg_input)
1121 close(fd);
1122
1123 if (--cfg_repeat > 0)
1124 goto again;
1125
1126 return 0;
1127 }
1128
init_rng(void)1129 static void init_rng(void)
1130 {
1131 unsigned int foo;
1132
1133 if (getrandom(&foo, sizeof(foo), 0) == -1) {
1134 perror("getrandom");
1135 exit(1);
1136 }
1137
1138 srand(foo);
1139 }
1140
xsetsockopt(int fd,int level,int optname,const void * optval,socklen_t optlen)1141 static void xsetsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
1142 {
1143 int err;
1144
1145 err = setsockopt(fd, level, optname, optval, optlen);
1146 if (err) {
1147 perror("setsockopt");
1148 exit(1);
1149 }
1150 }
1151
apply_cmsg_types(int fd,const struct cfg_cmsg_types * cmsg)1152 static void apply_cmsg_types(int fd, const struct cfg_cmsg_types *cmsg)
1153 {
1154 static const unsigned int on = 1;
1155
1156 if (cmsg->timestampns)
1157 xsetsockopt(fd, SOL_SOCKET, SO_TIMESTAMPNS_NEW, &on, sizeof(on));
1158 if (cmsg->tcp_inq)
1159 xsetsockopt(fd, IPPROTO_TCP, TCP_INQ, &on, sizeof(on));
1160 }
1161
parse_cmsg_types(const char * type)1162 static void parse_cmsg_types(const char *type)
1163 {
1164 char *next = strchr(type, ',');
1165 unsigned int len = 0;
1166
1167 cfg_cmsg_types.cmsg_enabled = 1;
1168
1169 if (next) {
1170 parse_cmsg_types(next + 1);
1171 len = next - type;
1172 } else {
1173 len = strlen(type);
1174 }
1175
1176 if (strncmp(type, "TIMESTAMPNS", len) == 0) {
1177 cfg_cmsg_types.timestampns = 1;
1178 return;
1179 }
1180
1181 if (strncmp(type, "TCPINQ", len) == 0) {
1182 cfg_cmsg_types.tcp_inq = 1;
1183 return;
1184 }
1185
1186 fprintf(stderr, "Unrecognized cmsg option %s\n", type);
1187 exit(1);
1188 }
1189
parse_setsock_options(const char * name)1190 static void parse_setsock_options(const char *name)
1191 {
1192 char *next = strchr(name, ',');
1193 unsigned int len = 0;
1194
1195 if (next) {
1196 parse_setsock_options(next + 1);
1197 len = next - name;
1198 } else {
1199 len = strlen(name);
1200 }
1201
1202 if (strncmp(name, "TRANSPARENT", len) == 0) {
1203 cfg_sockopt_types.transparent = 1;
1204 return;
1205 }
1206
1207 if (strncmp(name, "MPTFO", len) == 0) {
1208 cfg_sockopt_types.mptfo = 1;
1209 return;
1210 }
1211
1212 fprintf(stderr, "Unrecognized setsockopt option %s\n", name);
1213 exit(1);
1214 }
1215
xdisconnect(int fd)1216 void xdisconnect(int fd)
1217 {
1218 socklen_t addrlen = sizeof(struct sockaddr_storage);
1219 struct sockaddr_storage addr, empty;
1220 int msec_sleep = 10;
1221 void *raw_addr;
1222 int i, cmdlen;
1223 char cmd[128];
1224
1225 /* get the local address and convert it to string */
1226 if (getsockname(fd, (struct sockaddr *)&addr, &addrlen) < 0)
1227 xerror("getsockname");
1228
1229 if (addr.ss_family == AF_INET)
1230 raw_addr = &(((struct sockaddr_in *)&addr)->sin_addr);
1231 else if (addr.ss_family == AF_INET6)
1232 raw_addr = &(((struct sockaddr_in6 *)&addr)->sin6_addr);
1233 else
1234 xerror("bad family");
1235
1236 strcpy(cmd, "ss -M | grep -q ");
1237 cmdlen = strlen(cmd);
1238 if (!inet_ntop(addr.ss_family, raw_addr, &cmd[cmdlen],
1239 sizeof(cmd) - cmdlen))
1240 xerror("inet_ntop");
1241
1242 shutdown(fd, SHUT_WR);
1243
1244 /*
1245 * wait until the pending data is completely flushed and all
1246 * the MPTCP sockets reached the closed status.
1247 * disconnect will bypass/ignore/drop any pending data.
1248 */
1249 for (i = 0; ; i += msec_sleep) {
1250 /* closed socket are not listed by 'ss' */
1251 if (system(cmd) != 0)
1252 break;
1253
1254 if (i > poll_timeout)
1255 xerror("timeout while waiting for spool to complete");
1256 usleep(msec_sleep * 1000);
1257 }
1258
1259 memset(&empty, 0, sizeof(empty));
1260 empty.ss_family = AF_UNSPEC;
1261 if (connect(fd, (struct sockaddr *)&empty, addrlen) < 0)
1262 xerror("can't disconnect: %d", errno);
1263 }
1264
main_loop(void)1265 int main_loop(void)
1266 {
1267 int fd = 0, ret, fd_in = 0;
1268 struct addrinfo *peer;
1269 struct wstate winfo;
1270
1271 if (cfg_input && cfg_sockopt_types.mptfo) {
1272 fd_in = open(cfg_input, O_RDONLY);
1273 if (fd < 0)
1274 xerror("can't open %s:%d", cfg_input, errno);
1275 }
1276
1277 memset(&winfo, 0, sizeof(winfo));
1278 fd = sock_connect_mptcp(cfg_host, cfg_port, cfg_sock_proto, &peer, fd_in, &winfo);
1279 if (fd < 0)
1280 return 2;
1281
1282 again:
1283 check_getpeername_connect(fd);
1284
1285 SOCK_TEST_TCPULP(fd, cfg_sock_proto);
1286
1287 if (cfg_rcvbuf)
1288 set_rcvbuf(fd, cfg_rcvbuf);
1289 if (cfg_sndbuf)
1290 set_sndbuf(fd, cfg_sndbuf);
1291 if (cfg_cmsg_types.cmsg_enabled)
1292 apply_cmsg_types(fd, &cfg_cmsg_types);
1293
1294 if (cfg_input && !cfg_sockopt_types.mptfo) {
1295 fd_in = open(cfg_input, O_RDONLY);
1296 if (fd < 0)
1297 xerror("can't open %s:%d", cfg_input, errno);
1298 }
1299
1300 ret = copyfd_io(fd_in, fd, 1, 0, &winfo);
1301 if (ret)
1302 return ret;
1303
1304 if (cfg_truncate > 0) {
1305 xdisconnect(fd);
1306 } else if (--cfg_repeat > 0) {
1307 xdisconnect(fd);
1308
1309 /* the socket could be unblocking at this point, we need the
1310 * connect to be blocking
1311 */
1312 set_nonblock(fd, false);
1313 if (connect(fd, peer->ai_addr, peer->ai_addrlen))
1314 xerror("can't reconnect: %d", errno);
1315 if (cfg_input)
1316 close(fd_in);
1317 memset(&winfo, 0, sizeof(winfo));
1318 goto again;
1319 } else {
1320 close(fd);
1321 }
1322
1323 return 0;
1324 }
1325
parse_proto(const char * proto)1326 int parse_proto(const char *proto)
1327 {
1328 if (!strcasecmp(proto, "MPTCP"))
1329 return IPPROTO_MPTCP;
1330 if (!strcasecmp(proto, "TCP"))
1331 return IPPROTO_TCP;
1332
1333 fprintf(stderr, "Unknown protocol: %s\n.", proto);
1334 die_usage();
1335
1336 /* silence compiler warning */
1337 return 0;
1338 }
1339
parse_mode(const char * mode)1340 int parse_mode(const char *mode)
1341 {
1342 if (!strcasecmp(mode, "poll"))
1343 return CFG_MODE_POLL;
1344 if (!strcasecmp(mode, "mmap"))
1345 return CFG_MODE_MMAP;
1346 if (!strcasecmp(mode, "sendfile"))
1347 return CFG_MODE_SENDFILE;
1348
1349 fprintf(stderr, "Unknown test mode: %s\n", mode);
1350 fprintf(stderr, "Supported modes are:\n");
1351 fprintf(stderr, "\t\t\"poll\" - interleaved read/write using poll()\n");
1352 fprintf(stderr, "\t\t\"mmap\" - send entire input file (mmap+write), then read response (-l will read input first)\n");
1353 fprintf(stderr, "\t\t\"sendfile\" - send entire input file (sendfile), then read response (-l will read input first)\n");
1354
1355 die_usage();
1356
1357 /* silence compiler warning */
1358 return 0;
1359 }
1360
parse_peek(const char * mode)1361 int parse_peek(const char *mode)
1362 {
1363 if (!strcasecmp(mode, "saveWithPeek"))
1364 return CFG_WITH_PEEK;
1365 if (!strcasecmp(mode, "saveAfterPeek"))
1366 return CFG_AFTER_PEEK;
1367
1368 fprintf(stderr, "Unknown: %s\n", mode);
1369 fprintf(stderr, "Supported MSG_PEEK mode are:\n");
1370 fprintf(stderr,
1371 "\t\t\"saveWithPeek\" - recv data with flags 'MSG_PEEK' and save the peek data into file\n");
1372 fprintf(stderr,
1373 "\t\t\"saveAfterPeek\" - read and save data into file after recv with flags 'MSG_PEEK'\n");
1374
1375 die_usage();
1376
1377 /* silence compiler warning */
1378 return 0;
1379 }
1380
parse_int(const char * size)1381 static int parse_int(const char *size)
1382 {
1383 unsigned long s;
1384
1385 errno = 0;
1386
1387 s = strtoul(size, NULL, 0);
1388
1389 if (errno) {
1390 fprintf(stderr, "Invalid sndbuf size %s (%s)\n",
1391 size, strerror(errno));
1392 die_usage();
1393 }
1394
1395 if (s > INT_MAX) {
1396 fprintf(stderr, "Invalid sndbuf size %s (%s)\n",
1397 size, strerror(ERANGE));
1398 die_usage();
1399 }
1400
1401 return (int)s;
1402 }
1403
parse_opts(int argc,char ** argv)1404 static void parse_opts(int argc, char **argv)
1405 {
1406 int c;
1407
1408 while ((c = getopt(argc, argv, "6c:f:hi:I:jlm:M:o:p:P:r:R:s:S:t:T:w:")) != -1) {
1409 switch (c) {
1410 case 'f':
1411 cfg_truncate = atoi(optarg);
1412
1413 /* when receiving a fastclose, ignore PIPE signals and
1414 * all the I/O errors later in the code
1415 */
1416 if (cfg_truncate < 0) {
1417 cfg_rcv_trunc = true;
1418 signal(SIGPIPE, handle_signal);
1419 }
1420 break;
1421 case 'j':
1422 cfg_join = true;
1423 cfg_mode = CFG_MODE_POLL;
1424 break;
1425 case 'r':
1426 cfg_remove = true;
1427 cfg_mode = CFG_MODE_POLL;
1428 cfg_wait = 400000;
1429 cfg_do_w = atoi(optarg);
1430 if (cfg_do_w <= 0)
1431 cfg_do_w = 50;
1432 break;
1433 case 'i':
1434 cfg_input = optarg;
1435 break;
1436 case 'I':
1437 cfg_repeat = atoi(optarg);
1438 break;
1439 case 'l':
1440 listen_mode = true;
1441 break;
1442 case 'p':
1443 cfg_port = optarg;
1444 break;
1445 case 's':
1446 cfg_sock_proto = parse_proto(optarg);
1447 break;
1448 case 'h':
1449 die_usage();
1450 break;
1451 case '6':
1452 pf = AF_INET6;
1453 break;
1454 case 't':
1455 poll_timeout = atoi(optarg) * 1000;
1456 if (poll_timeout <= 0)
1457 poll_timeout = -1;
1458 break;
1459 case 'T':
1460 cfg_time = atoi(optarg);
1461 break;
1462 case 'm':
1463 cfg_mode = parse_mode(optarg);
1464 break;
1465 case 'S':
1466 cfg_sndbuf = parse_int(optarg);
1467 break;
1468 case 'R':
1469 cfg_rcvbuf = parse_int(optarg);
1470 break;
1471 case 'w':
1472 cfg_wait = atoi(optarg)*1000000;
1473 break;
1474 case 'M':
1475 cfg_mark = strtol(optarg, NULL, 0);
1476 break;
1477 case 'P':
1478 cfg_peek = parse_peek(optarg);
1479 break;
1480 case 'c':
1481 parse_cmsg_types(optarg);
1482 break;
1483 case 'o':
1484 parse_setsock_options(optarg);
1485 break;
1486 }
1487 }
1488
1489 if (optind + 1 != argc)
1490 die_usage();
1491 cfg_host = argv[optind];
1492
1493 if (strchr(cfg_host, ':'))
1494 pf = AF_INET6;
1495 }
1496
main(int argc,char * argv[])1497 int main(int argc, char *argv[])
1498 {
1499 init_rng();
1500
1501 signal(SIGUSR1, handle_signal);
1502 parse_opts(argc, argv);
1503
1504 if (listen_mode) {
1505 int fd = sock_listen_mptcp(cfg_host, cfg_port);
1506
1507 if (fd < 0)
1508 return 1;
1509
1510 if (cfg_rcvbuf)
1511 set_rcvbuf(fd, cfg_rcvbuf);
1512 if (cfg_sndbuf)
1513 set_sndbuf(fd, cfg_sndbuf);
1514 if (cfg_mark)
1515 set_mark(fd, cfg_mark);
1516 if (cfg_cmsg_types.cmsg_enabled)
1517 apply_cmsg_types(fd, &cfg_cmsg_types);
1518
1519 return main_loop_s(fd);
1520 }
1521
1522 return main_loop();
1523 }
1524