1
2
3#define _GNU_SOURCE
4
5#include <stddef.h>
6#include <arpa/inet.h>
7#include <error.h>
8#include <errno.h>
9#include <net/if.h>
10#include <linux/in.h>
11#include <linux/netlink.h>
12#include <linux/rtnetlink.h>
13#include <netinet/if_ether.h>
14#include <netinet/ip.h>
15#include <netinet/ip6.h>
16#include <netinet/udp.h>
17#include <stdbool.h>
18#include <stdlib.h>
19#include <stdio.h>
20#include <stdlib.h>
21#include <string.h>
22#include <sys/ioctl.h>
23#include <sys/socket.h>
24#include <sys/stat.h>
25#include <sys/time.h>
26#include <sys/types.h>
27#include <unistd.h>
28
29#ifndef ETH_MAX_MTU
30#define ETH_MAX_MTU 0xFFFFU
31#endif
32
33#ifndef UDP_SEGMENT
34#define UDP_SEGMENT 103
35#endif
36
37#ifndef UDP_MAX_SEGMENTS
38#define UDP_MAX_SEGMENTS (1 << 6UL)
39#endif
40
41#define CONST_MTU_TEST 1500
42
43#define CONST_HDRLEN_V4 (sizeof(struct iphdr) + sizeof(struct udphdr))
44#define CONST_HDRLEN_V6 (sizeof(struct ip6_hdr) + sizeof(struct udphdr))
45
46#define CONST_MSS_V4 (CONST_MTU_TEST - CONST_HDRLEN_V4)
47#define CONST_MSS_V6 (CONST_MTU_TEST - CONST_HDRLEN_V6)
48
49#define CONST_MAX_SEGS_V4 (ETH_MAX_MTU / CONST_MSS_V4)
50#define CONST_MAX_SEGS_V6 (ETH_MAX_MTU / CONST_MSS_V6)
51
52static bool cfg_do_ipv4;
53static bool cfg_do_ipv6;
54static bool cfg_do_connected;
55static bool cfg_do_connectionless;
56static bool cfg_do_msgmore;
57static bool cfg_do_setsockopt;
58static int cfg_specific_test_id = -1;
59
60static const char cfg_ifname[] = "lo";
61static unsigned short cfg_port = 9000;
62
63static char buf[ETH_MAX_MTU];
64
65struct testcase {
66 int tlen;
67 bool tfail;
68 int gso_len;
69 int r_num_mss;
70 int r_len_last;
71};
72
73const struct in6_addr addr6 = IN6ADDR_LOOPBACK_INIT;
74const struct in_addr addr4 = { .s_addr = __constant_htonl(INADDR_LOOPBACK + 2) };
75
76struct testcase testcases_v4[] = {
77 {
78
79 .tlen = 1,
80 .r_len_last = 1,
81 },
82 {
83
84 .tlen = CONST_MSS_V4,
85 .r_num_mss = 1,
86 },
87 {
88
89 .tlen = CONST_MSS_V4 + 1,
90 .tfail = true,
91 },
92 {
93
94
95
96 .tlen = CONST_MSS_V4,
97 .gso_len = CONST_MSS_V4,
98 .tfail = true,
99 .r_num_mss = 1,
100 },
101 {
102
103 .tlen = CONST_MSS_V4 + 1,
104 .gso_len = CONST_MSS_V4,
105 .r_num_mss = 1,
106 .r_len_last = 1,
107 },
108 {
109
110 .tlen = CONST_MSS_V4 * 2,
111 .gso_len = CONST_MSS_V4,
112 .r_num_mss = 2,
113 },
114 {
115
116 .tlen = (CONST_MSS_V4 * 2) + 1,
117 .gso_len = CONST_MSS_V4,
118 .r_num_mss = 2,
119 .r_len_last = 1,
120 },
121 {
122
123 .tlen = (ETH_MAX_MTU / CONST_MSS_V4) * CONST_MSS_V4,
124 .gso_len = CONST_MSS_V4,
125 .r_num_mss = (ETH_MAX_MTU / CONST_MSS_V4),
126 },
127
128 {
129
130 .tlen = ETH_MAX_MTU - CONST_HDRLEN_V4,
131 .gso_len = CONST_MSS_V4,
132 .r_num_mss = CONST_MAX_SEGS_V4,
133 .r_len_last = ETH_MAX_MTU - CONST_HDRLEN_V4 -
134 (CONST_MAX_SEGS_V4 * CONST_MSS_V4),
135 },
136 {
137
138 .tlen = ETH_MAX_MTU - CONST_HDRLEN_V4 + 1,
139 .gso_len = CONST_MSS_V4,
140 .tfail = true,
141 },
142 {
143
144 .tlen = 1,
145 .gso_len = 1,
146 .tfail = true,
147 .r_num_mss = 1,
148 },
149 {
150
151 .tlen = 2,
152 .gso_len = 1,
153 .r_num_mss = 2,
154 },
155 {
156
157 .tlen = 5,
158 .gso_len = 2,
159 .r_num_mss = 2,
160 .r_len_last = 1,
161 },
162 {
163
164 .tlen = UDP_MAX_SEGMENTS - CONST_HDRLEN_V4,
165 .gso_len = 1,
166 .r_num_mss = UDP_MAX_SEGMENTS - CONST_HDRLEN_V4,
167 },
168 {
169
170 .tlen = UDP_MAX_SEGMENTS - CONST_HDRLEN_V4 + 1,
171 .gso_len = 1,
172 .tfail = true,
173 },
174 {
175
176 }
177};
178
179#ifndef IP6_MAX_MTU
180#define IP6_MAX_MTU (ETH_MAX_MTU + sizeof(struct ip6_hdr))
181#endif
182
183struct testcase testcases_v6[] = {
184 {
185
186 .tlen = 1,
187 .r_len_last = 1,
188 },
189 {
190
191 .tlen = CONST_MSS_V6,
192 .r_num_mss = 1,
193 },
194 {
195
196 .tlen = CONST_MSS_V6 + 1,
197 .tfail = true,
198 },
199 {
200
201
202
203 .tlen = CONST_MSS_V6,
204 .gso_len = CONST_MSS_V6,
205 .tfail = true,
206 .r_num_mss = 1,
207 },
208 {
209
210 .tlen = CONST_MSS_V6 + 1,
211 .gso_len = CONST_MSS_V6,
212 .r_num_mss = 1,
213 .r_len_last = 1,
214 },
215 {
216
217 .tlen = CONST_MSS_V6 * 2,
218 .gso_len = CONST_MSS_V6,
219 .r_num_mss = 2,
220 },
221 {
222
223 .tlen = (CONST_MSS_V6 * 2) + 1,
224 .gso_len = CONST_MSS_V6,
225 .r_num_mss = 2,
226 .r_len_last = 1,
227 },
228 {
229
230 .tlen = (IP6_MAX_MTU / CONST_MSS_V6) * CONST_MSS_V6,
231 .gso_len = CONST_MSS_V6,
232 .r_num_mss = (IP6_MAX_MTU / CONST_MSS_V6),
233 },
234
235 {
236
237 .tlen = IP6_MAX_MTU - CONST_HDRLEN_V6,
238 .gso_len = CONST_MSS_V6,
239 .r_num_mss = CONST_MAX_SEGS_V6,
240 .r_len_last = IP6_MAX_MTU - CONST_HDRLEN_V6 -
241 (CONST_MAX_SEGS_V6 * CONST_MSS_V6),
242 },
243 {
244
245 .tlen = IP6_MAX_MTU - CONST_HDRLEN_V6 + 1,
246 .gso_len = CONST_MSS_V6,
247 .tfail = true,
248 },
249 {
250
251 .tlen = 1,
252 .gso_len = 1,
253 .tfail = true,
254 .r_num_mss = 1,
255 },
256 {
257
258 .tlen = 2,
259 .gso_len = 1,
260 .r_num_mss = 2,
261 },
262 {
263
264 .tlen = 5,
265 .gso_len = 2,
266 .r_num_mss = 2,
267 .r_len_last = 1,
268 },
269 {
270
271 .tlen = UDP_MAX_SEGMENTS - CONST_HDRLEN_V6,
272 .gso_len = 1,
273 .r_num_mss = UDP_MAX_SEGMENTS - CONST_HDRLEN_V6,
274 },
275 {
276
277 .tlen = UDP_MAX_SEGMENTS - CONST_HDRLEN_V6 + 1,
278 .gso_len = 1,
279 .tfail = true,
280 },
281 {
282
283 }
284};
285
286static unsigned int get_device_mtu(int fd, const char *ifname)
287{
288 struct ifreq ifr;
289
290 memset(&ifr, 0, sizeof(ifr));
291
292 strcpy(ifr.ifr_name, ifname);
293
294 if (ioctl(fd, SIOCGIFMTU, &ifr))
295 error(1, errno, "ioctl get mtu");
296
297 return ifr.ifr_mtu;
298}
299
300static void __set_device_mtu(int fd, const char *ifname, unsigned int mtu)
301{
302 struct ifreq ifr;
303
304 memset(&ifr, 0, sizeof(ifr));
305
306 ifr.ifr_mtu = mtu;
307 strcpy(ifr.ifr_name, ifname);
308
309 if (ioctl(fd, SIOCSIFMTU, &ifr))
310 error(1, errno, "ioctl set mtu");
311}
312
313static void set_device_mtu(int fd, int mtu)
314{
315 int val;
316
317 val = get_device_mtu(fd, cfg_ifname);
318 fprintf(stderr, "device mtu (orig): %u\n", val);
319
320 __set_device_mtu(fd, cfg_ifname, mtu);
321 val = get_device_mtu(fd, cfg_ifname);
322 if (val != mtu)
323 error(1, 0, "unable to set device mtu to %u\n", val);
324
325 fprintf(stderr, "device mtu (test): %u\n", val);
326}
327
328static void set_pmtu_discover(int fd, bool is_ipv4)
329{
330 int level, name, val;
331
332 if (is_ipv4) {
333 level = SOL_IP;
334 name = IP_MTU_DISCOVER;
335 val = IP_PMTUDISC_DO;
336 } else {
337 level = SOL_IPV6;
338 name = IPV6_MTU_DISCOVER;
339 val = IPV6_PMTUDISC_DO;
340 }
341
342 if (setsockopt(fd, level, name, &val, sizeof(val)))
343 error(1, errno, "setsockopt path mtu");
344}
345
346static unsigned int get_path_mtu(int fd, bool is_ipv4)
347{
348 socklen_t vallen;
349 unsigned int mtu;
350 int ret;
351
352 vallen = sizeof(mtu);
353 if (is_ipv4)
354 ret = getsockopt(fd, SOL_IP, IP_MTU, &mtu, &vallen);
355 else
356 ret = getsockopt(fd, SOL_IPV6, IPV6_MTU, &mtu, &vallen);
357
358 if (ret)
359 error(1, errno, "getsockopt mtu");
360
361
362 fprintf(stderr, "path mtu (read): %u\n", mtu);
363 return mtu;
364}
365
366
367static void set_route_mtu(int mtu, bool is_ipv4)
368{
369 struct sockaddr_nl nladdr = { .nl_family = AF_NETLINK };
370 struct nlmsghdr *nh;
371 struct rtattr *rta;
372 struct rtmsg *rt;
373 char data[NLMSG_ALIGN(sizeof(*nh)) +
374 NLMSG_ALIGN(sizeof(*rt)) +
375 NLMSG_ALIGN(RTA_LENGTH(sizeof(addr6))) +
376 NLMSG_ALIGN(RTA_LENGTH(sizeof(int))) +
377 NLMSG_ALIGN(RTA_LENGTH(0) + RTA_LENGTH(sizeof(int)))];
378 int fd, ret, alen, off = 0;
379
380 alen = is_ipv4 ? sizeof(addr4) : sizeof(addr6);
381
382 fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
383 if (fd == -1)
384 error(1, errno, "socket netlink");
385
386 memset(data, 0, sizeof(data));
387
388 nh = (void *)data;
389 nh->nlmsg_type = RTM_NEWROUTE;
390 nh->nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE;
391 off += NLMSG_ALIGN(sizeof(*nh));
392
393 rt = (void *)(data + off);
394 rt->rtm_family = is_ipv4 ? AF_INET : AF_INET6;
395 rt->rtm_table = RT_TABLE_MAIN;
396 rt->rtm_dst_len = alen << 3;
397 rt->rtm_protocol = RTPROT_BOOT;
398 rt->rtm_scope = RT_SCOPE_UNIVERSE;
399 rt->rtm_type = RTN_UNICAST;
400 off += NLMSG_ALIGN(sizeof(*rt));
401
402 rta = (void *)(data + off);
403 rta->rta_type = RTA_DST;
404 rta->rta_len = RTA_LENGTH(alen);
405 if (is_ipv4)
406 memcpy(RTA_DATA(rta), &addr4, alen);
407 else
408 memcpy(RTA_DATA(rta), &addr6, alen);
409 off += NLMSG_ALIGN(rta->rta_len);
410
411 rta = (void *)(data + off);
412 rta->rta_type = RTA_OIF;
413 rta->rta_len = RTA_LENGTH(sizeof(int));
414 *((int *)(RTA_DATA(rta))) = 1;
415 off += NLMSG_ALIGN(rta->rta_len);
416
417
418 rta = (void *)(data + off);
419 rta->rta_type = RTA_METRICS;
420 rta->rta_len = RTA_LENGTH(0) + RTA_LENGTH(sizeof(int));
421 off += NLMSG_ALIGN(rta->rta_len);
422
423
424 rta = (void *)(((char *) rta) + RTA_LENGTH(0));
425 rta->rta_type = RTAX_MTU;
426 rta->rta_len = RTA_LENGTH(sizeof(int));
427 *((int *)(RTA_DATA(rta))) = mtu;
428
429 nh->nlmsg_len = off;
430
431 ret = sendto(fd, data, off, 0, (void *)&nladdr, sizeof(nladdr));
432 if (ret != off)
433 error(1, errno, "send netlink: %uB != %uB\n", ret, off);
434
435 if (close(fd))
436 error(1, errno, "close netlink");
437
438 fprintf(stderr, "route mtu (test): %u\n", mtu);
439}
440
441static bool __send_one(int fd, struct msghdr *msg, int flags)
442{
443 int ret;
444
445 ret = sendmsg(fd, msg, flags);
446 if (ret == -1 &&
447 (errno == EMSGSIZE || errno == ENOMEM || errno == EINVAL))
448 return false;
449 if (ret == -1)
450 error(1, errno, "sendmsg");
451 if (ret != msg->msg_iov->iov_len)
452 error(1, 0, "sendto: %d != %lu", ret, msg->msg_iov->iov_len);
453 if (msg->msg_flags)
454 error(1, 0, "sendmsg: return flags 0x%x\n", msg->msg_flags);
455
456 return true;
457}
458
459static bool send_one(int fd, int len, int gso_len,
460 struct sockaddr *addr, socklen_t alen)
461{
462 char control[CMSG_SPACE(sizeof(uint16_t))] = {0};
463 struct msghdr msg = {0};
464 struct iovec iov = {0};
465 struct cmsghdr *cm;
466
467 iov.iov_base = buf;
468 iov.iov_len = len;
469
470 msg.msg_iov = &iov;
471 msg.msg_iovlen = 1;
472
473 msg.msg_name = addr;
474 msg.msg_namelen = alen;
475
476 if (gso_len && !cfg_do_setsockopt) {
477 msg.msg_control = control;
478 msg.msg_controllen = sizeof(control);
479
480 cm = CMSG_FIRSTHDR(&msg);
481 cm->cmsg_level = SOL_UDP;
482 cm->cmsg_type = UDP_SEGMENT;
483 cm->cmsg_len = CMSG_LEN(sizeof(uint16_t));
484 *((uint16_t *) CMSG_DATA(cm)) = gso_len;
485 }
486
487
488 if (cfg_do_msgmore && len > 1) {
489 iov.iov_len = 1;
490 if (!__send_one(fd, &msg, MSG_MORE))
491 error(1, 0, "send 1B failed");
492
493 iov.iov_base++;
494 iov.iov_len = len - 1;
495 }
496
497 return __send_one(fd, &msg, 0);
498}
499
500static int recv_one(int fd, int flags)
501{
502 int ret;
503
504 ret = recv(fd, buf, sizeof(buf), flags);
505 if (ret == -1 && errno == EAGAIN && (flags & MSG_DONTWAIT))
506 return 0;
507 if (ret == -1)
508 error(1, errno, "recv");
509
510 return ret;
511}
512
513static void run_one(struct testcase *test, int fdt, int fdr,
514 struct sockaddr *addr, socklen_t alen)
515{
516 int i, ret, val, mss;
517 bool sent;
518
519 fprintf(stderr, "ipv%d tx:%d gso:%d %s\n",
520 addr->sa_family == AF_INET ? 4 : 6,
521 test->tlen, test->gso_len,
522 test->tfail ? "(fail)" : "");
523
524 val = test->gso_len;
525 if (cfg_do_setsockopt) {
526 if (setsockopt(fdt, SOL_UDP, UDP_SEGMENT, &val, sizeof(val)))
527 error(1, errno, "setsockopt udp segment");
528 }
529
530 sent = send_one(fdt, test->tlen, test->gso_len, addr, alen);
531 if (sent && test->tfail)
532 error(1, 0, "send succeeded while expecting failure");
533 if (!sent && !test->tfail)
534 error(1, 0, "send failed while expecting success");
535 if (!sent)
536 return;
537
538 if (test->gso_len)
539 mss = test->gso_len;
540 else
541 mss = addr->sa_family == AF_INET ? CONST_MSS_V4 : CONST_MSS_V6;
542
543
544
545 for (i = 0; i < test->r_num_mss; i++) {
546 ret = recv_one(fdr, 0);
547 if (ret != mss)
548 error(1, 0, "recv.%d: %d != %d", i, ret, mss);
549 }
550
551
552 if (test->r_len_last) {
553 ret = recv_one(fdr, 0);
554 if (ret != test->r_len_last)
555 error(1, 0, "recv.%d: %d != %d (last)",
556 i, ret, test->r_len_last);
557 }
558
559
560 ret = recv_one(fdr, MSG_DONTWAIT);
561 if (ret)
562 error(1, 0, "recv: unexpected datagram");
563}
564
565static void run_all(int fdt, int fdr, struct sockaddr *addr, socklen_t alen)
566{
567 struct testcase *tests, *test;
568
569 tests = addr->sa_family == AF_INET ? testcases_v4 : testcases_v6;
570
571 for (test = tests; test->tlen; test++) {
572
573 if (cfg_specific_test_id == -1 ||
574 cfg_specific_test_id == test - tests)
575 run_one(test, fdt, fdr, addr, alen);
576 }
577}
578
579static void run_test(struct sockaddr *addr, socklen_t alen)
580{
581 struct timeval tv = { .tv_usec = 100 * 1000 };
582 int fdr, fdt, val;
583
584 fdr = socket(addr->sa_family, SOCK_DGRAM, 0);
585 if (fdr == -1)
586 error(1, errno, "socket r");
587
588 if (bind(fdr, addr, alen))
589 error(1, errno, "bind");
590
591
592 if (setsockopt(fdr, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)))
593 error(1, errno, "setsockopt rcv timeout");
594
595 fdt = socket(addr->sa_family, SOCK_DGRAM, 0);
596 if (fdt == -1)
597 error(1, errno, "socket t");
598
599
600 set_pmtu_discover(fdt, addr->sa_family == AF_INET);
601
602 if (cfg_do_connectionless) {
603 set_device_mtu(fdt, CONST_MTU_TEST);
604 run_all(fdt, fdr, addr, alen);
605 }
606
607 if (cfg_do_connected) {
608 set_device_mtu(fdt, CONST_MTU_TEST + 100);
609 set_route_mtu(CONST_MTU_TEST, addr->sa_family == AF_INET);
610
611 if (connect(fdt, addr, alen))
612 error(1, errno, "connect");
613
614 val = get_path_mtu(fdt, addr->sa_family == AF_INET);
615 if (val != CONST_MTU_TEST)
616 error(1, 0, "bad path mtu %u\n", val);
617
618 run_all(fdt, fdr, addr, 0 );
619 }
620
621 if (close(fdt))
622 error(1, errno, "close t");
623 if (close(fdr))
624 error(1, errno, "close r");
625}
626
627static void run_test_v4(void)
628{
629 struct sockaddr_in addr = {0};
630
631 addr.sin_family = AF_INET;
632 addr.sin_port = htons(cfg_port);
633 addr.sin_addr = addr4;
634
635 run_test((void *)&addr, sizeof(addr));
636}
637
638static void run_test_v6(void)
639{
640 struct sockaddr_in6 addr = {0};
641
642 addr.sin6_family = AF_INET6;
643 addr.sin6_port = htons(cfg_port);
644 addr.sin6_addr = addr6;
645
646 run_test((void *)&addr, sizeof(addr));
647}
648
649static void parse_opts(int argc, char **argv)
650{
651 int c;
652
653 while ((c = getopt(argc, argv, "46cCmst:")) != -1) {
654 switch (c) {
655 case '4':
656 cfg_do_ipv4 = true;
657 break;
658 case '6':
659 cfg_do_ipv6 = true;
660 break;
661 case 'c':
662 cfg_do_connected = true;
663 break;
664 case 'C':
665 cfg_do_connectionless = true;
666 break;
667 case 'm':
668 cfg_do_msgmore = true;
669 break;
670 case 's':
671 cfg_do_setsockopt = true;
672 break;
673 case 't':
674 cfg_specific_test_id = strtoul(optarg, NULL, 0);
675 break;
676 default:
677 error(1, 0, "%s: parse error", argv[0]);
678 }
679 }
680}
681
682int main(int argc, char **argv)
683{
684 parse_opts(argc, argv);
685
686 if (cfg_do_ipv4)
687 run_test_v4();
688 if (cfg_do_ipv6)
689 run_test_v6();
690
691 fprintf(stderr, "OK\n");
692 return 0;
693}
694