~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/testing/selftests/net/udpgso.c

Version: ~ [ linux-5.16 ] ~ [ linux-5.15.13 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.90 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.170 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.224 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.261 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.296 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.298 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  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 
 52 static bool             cfg_do_ipv4;
 53 static bool             cfg_do_ipv6;
 54 static bool             cfg_do_connected;
 55 static bool             cfg_do_connectionless;
 56 static bool             cfg_do_msgmore;
 57 static bool             cfg_do_setsockopt;
 58 static int              cfg_specific_test_id = -1;
 59 
 60 static const char       cfg_ifname[] = "lo";
 61 static unsigned short   cfg_port = 9000;
 62 
 63 static char buf[ETH_MAX_MTU];
 64 
 65 struct testcase {
 66         int tlen;               /* send() buffer size, may exceed mss */
 67         bool tfail;             /* send() call is expected to fail */
 68         int gso_len;            /* mss after applying gso */
 69         int r_num_mss;          /* recv(): number of calls of full mss */
 70         int r_len_last;         /* recv(): size of last non-mss dgram, if any */
 71 };
 72 
 73 const struct in6_addr addr6 = IN6ADDR_LOOPBACK_INIT;
 74 const struct in_addr addr4 = { .s_addr = __constant_htonl(INADDR_LOOPBACK + 2) };
 75 
 76 struct testcase testcases_v4[] = {
 77         {
 78                 /* no GSO: send a single byte */
 79                 .tlen = 1,
 80                 .r_len_last = 1,
 81         },
 82         {
 83                 /* no GSO: send a single MSS */
 84                 .tlen = CONST_MSS_V4,
 85                 .r_num_mss = 1,
 86         },
 87         {
 88                 /* no GSO: send a single MSS + 1B: fail */
 89                 .tlen = CONST_MSS_V4 + 1,
 90                 .tfail = true,
 91         },
 92         {
 93                 /* send a single MSS: will fail with GSO, because the segment
 94                  * logic in udp4_ufo_fragment demands a gso skb to be > MTU
 95                  */
 96                 .tlen = CONST_MSS_V4,
 97                 .gso_len = CONST_MSS_V4,
 98                 .tfail = true,
 99                 .r_num_mss = 1,
100         },
101         {
102                 /* send a single MSS + 1B */
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                 /* send exactly 2 MSS */
110                 .tlen = CONST_MSS_V4 * 2,
111                 .gso_len = CONST_MSS_V4,
112                 .r_num_mss = 2,
113         },
114         {
115                 /* send 2 MSS + 1B */
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                 /* send MAX segs */
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                 /* send MAX bytes */
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                 /* send MAX + 1: fail */
138                 .tlen = ETH_MAX_MTU - CONST_HDRLEN_V4 + 1,
139                 .gso_len = CONST_MSS_V4,
140                 .tfail = true,
141         },
142         {
143                 /* send a single 1B MSS: will fail, see single MSS above */
144                 .tlen = 1,
145                 .gso_len = 1,
146                 .tfail = true,
147                 .r_num_mss = 1,
148         },
149         {
150                 /* send 2 1B segments */
151                 .tlen = 2,
152                 .gso_len = 1,
153                 .r_num_mss = 2,
154         },
155         {
156                 /* send 2B + 2B + 1B segments */
157                 .tlen = 5,
158                 .gso_len = 2,
159                 .r_num_mss = 2,
160                 .r_len_last = 1,
161         },
162         {
163                 /* send max number of min sized segments */
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                 /* send max number + 1 of min sized segments: fail */
170                 .tlen = UDP_MAX_SEGMENTS - CONST_HDRLEN_V4 + 1,
171                 .gso_len = 1,
172                 .tfail = true,
173         },
174         {
175                 /* EOL */
176         }
177 };
178 
179 #ifndef IP6_MAX_MTU
180 #define IP6_MAX_MTU     (ETH_MAX_MTU + sizeof(struct ip6_hdr))
181 #endif
182 
183 struct testcase testcases_v6[] = {
184         {
185                 /* no GSO: send a single byte */
186                 .tlen = 1,
187                 .r_len_last = 1,
188         },
189         {
190                 /* no GSO: send a single MSS */
191                 .tlen = CONST_MSS_V6,
192                 .r_num_mss = 1,
193         },
194         {
195                 /* no GSO: send a single MSS + 1B: fail */
196                 .tlen = CONST_MSS_V6 + 1,
197                 .tfail = true,
198         },
199         {
200                 /* send a single MSS: will fail with GSO, because the segment
201                  * logic in udp4_ufo_fragment demands a gso skb to be > MTU
202                  */
203                 .tlen = CONST_MSS_V6,
204                 .gso_len = CONST_MSS_V6,
205                 .tfail = true,
206                 .r_num_mss = 1,
207         },
208         {
209                 /* send a single MSS + 1B */
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                 /* send exactly 2 MSS */
217                 .tlen = CONST_MSS_V6 * 2,
218                 .gso_len = CONST_MSS_V6,
219                 .r_num_mss = 2,
220         },
221         {
222                 /* send 2 MSS + 1B */
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                 /* send MAX segs */
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                 /* send MAX bytes */
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                 /* send MAX + 1: fail */
245                 .tlen = IP6_MAX_MTU - CONST_HDRLEN_V6 + 1,
246                 .gso_len = CONST_MSS_V6,
247                 .tfail = true,
248         },
249         {
250                 /* send a single 1B MSS: will fail, see single MSS above */
251                 .tlen = 1,
252                 .gso_len = 1,
253                 .tfail = true,
254                 .r_num_mss = 1,
255         },
256         {
257                 /* send 2 1B segments */
258                 .tlen = 2,
259                 .gso_len = 1,
260                 .r_num_mss = 2,
261         },
262         {
263                 /* send 2B + 2B + 1B segments */
264                 .tlen = 5,
265                 .gso_len = 2,
266                 .r_num_mss = 2,
267                 .r_len_last = 1,
268         },
269         {
270                 /* send max number of min sized segments */
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                 /* send max number + 1 of min sized segments: fail */
277                 .tlen = UDP_MAX_SEGMENTS - CONST_HDRLEN_V6 + 1,
278                 .gso_len = 1,
279                 .tfail = true,
280         },
281         {
282                 /* EOL */
283         }
284 };
285 
286 static 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 
300 static 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 
313 static 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 
328 static 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 
346 static 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 /* very wordy version of system("ip route add dev lo mtu 1500 127.0.0.3/32") */
367 static 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; //if_nametoindex("lo");
415         off += NLMSG_ALIGN(rta->rta_len);
416 
417         /* MTU is a subtype in a metrics type */
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         /* now fill MTU subtype. Note that it fits within above rta_len */
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 
441 static 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 
459 static 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         /* If MSG_MORE, send 1 byte followed by remainder */
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 
500 static 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 
513 static 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         /* Recv all full MSS datagrams */
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         /* Recv the non-full last datagram, if tlen was not a multiple of mss */
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         /* Verify received all data */
560         ret = recv_one(fdr, MSG_DONTWAIT);
561         if (ret)
562                 error(1, 0, "recv: unexpected datagram");
563 }
564 
565 static 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                 /* if a specific test is given, then skip all others */
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 
579 static 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         /* Have tests fail quickly instead of hang */
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         /* Do not fragment these datagrams: only succeed if GSO works */
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 /* use connected addr */);
619         }
620 
621         if (close(fdt))
622                 error(1, errno, "close t");
623         if (close(fdr))
624                 error(1, errno, "close r");
625 }
626 
627 static 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 
638 static 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 
649 static 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 
682 int 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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp