selftests/net/ip_defrag.c

0001 // SPDX-License-Identifier: GPL-2.0
0002
0003 #define _GNU_SOURCE
0004
0005 #include <arpa/inet.h>
0006 #include <errno.h>
0007 #include <error.h>
0008 #include <linux/in.h>
0009 #include <netinet/ip.h>
0010 #include <netinet/ip6.h>
0011 #include <netinet/udp.h>
0012 #include <stdbool.h>
0013 #include <stdio.h>
0014 #include <stdlib.h>
0015 #include <string.h>
0016 #include <time.h>
0017 #include <unistd.h>
0018
0019 static bool     cfg_do_ipv4;
0020 static bool     cfg_do_ipv6;
0021 static bool     cfg_verbose;
0022 static bool     cfg_overlap;
0023 static bool     cfg_permissive;
0024 static unsigned short   cfg_port = 9000;
0025
0026 const struct in_addr addr4 = { .s_addr = __constant_htonl(INADDR_LOOPBACK + 2) };
0027 const struct in6_addr addr6 = IN6ADDR_LOOPBACK_INIT;
0028
0029 #define IP4_HLEN    (sizeof(struct iphdr))
0030 #define IP6_HLEN    (sizeof(struct ip6_hdr))
0031 #define UDP_HLEN    (sizeof(struct udphdr))
0032
0033 /* IPv6 fragment header lenth. */
0034 #define FRAG_HLEN   8
0035
0036 static int payload_len;
0037 static int max_frag_len;
0038
0039 #define MSG_LEN_MAX 10000   /* Max UDP payload length. */
0040
0041 #define IP4_MF      (1u << 13)  /* IPv4 MF flag. */
0042 #define IP6_MF      (1)  /* IPv6 MF flag. */
0043
0044 #define CSUM_MANGLED_0 (0xffff)
0045
0046 static uint8_t udp_payload[MSG_LEN_MAX];
0047 static uint8_t ip_frame[IP_MAXPACKET];
0048 static uint32_t ip_id = 0xabcd;
0049 static int msg_counter;
0050 static int frag_counter;
0051 static unsigned int seed;
0052
0053 /* Receive a UDP packet. Validate it matches udp_payload. */
0054 static void recv_validate_udp(int fd_udp)
0055 {
0056     ssize_t ret;
0057     static uint8_t recv_buff[MSG_LEN_MAX];
0058
0059     ret = recv(fd_udp, recv_buff, payload_len, 0);
0060     msg_counter++;
0061
0062     if (cfg_overlap) {
0063         if (ret == -1 && (errno == ETIMEDOUT || errno == EAGAIN))
0064             return;  /* OK */
0065         if (!cfg_permissive) {
0066             if (ret != -1)
0067                 error(1, 0, "recv: expected timeout; got %d",
0068                     (int)ret);
0069             error(1, errno, "recv: expected timeout: %d", errno);
0070         }
0071     }
0072
0073     if (ret == -1)
0074         error(1, errno, "recv: payload_len = %d max_frag_len = %d",
0075             payload_len, max_frag_len);
0076     if (ret != payload_len)
0077         error(1, 0, "recv: wrong size: %d vs %d", (int)ret, payload_len);
0078     if (memcmp(udp_payload, recv_buff, payload_len))
0079         error(1, 0, "recv: wrong data");
0080 }
0081
0082 static uint32_t raw_checksum(uint8_t *buf, int len, uint32_t sum)
0083 {
0084     int i;
0085
0086     for (i = 0; i < (len & ~1U); i += 2) {
0087         sum += (u_int16_t)ntohs(*((u_int16_t *)(buf + i)));
0088         if (sum > 0xffff)
0089             sum -= 0xffff;
0090     }
0091
0092     if (i < len) {
0093         sum += buf[i] << 8;
0094         if (sum > 0xffff)
0095             sum -= 0xffff;
0096     }
0097
0098     return sum;
0099 }
0100
0101 static uint16_t udp_checksum(struct ip *iphdr, struct udphdr *udphdr)
0102 {
0103     uint32_t sum = 0;
0104     uint16_t res;
0105
0106     sum = raw_checksum((uint8_t *)&iphdr->ip_src, 2 * sizeof(iphdr->ip_src),
0107                 IPPROTO_UDP + (uint32_t)(UDP_HLEN + payload_len));
0108     sum = raw_checksum((uint8_t *)udphdr, UDP_HLEN, sum);
0109     sum = raw_checksum((uint8_t *)udp_payload, payload_len, sum);
0110     res = 0xffff & ~sum;
0111     if (res)
0112         return htons(res);
0113     else
0114         return CSUM_MANGLED_0;
0115 }
0116
0117 static uint16_t udp6_checksum(struct ip6_hdr *iphdr, struct udphdr *udphdr)
0118 {
0119     uint32_t sum = 0;
0120     uint16_t res;
0121
0122     sum = raw_checksum((uint8_t *)&iphdr->ip6_src, 2 * sizeof(iphdr->ip6_src),
0123                 IPPROTO_UDP);
0124     sum = raw_checksum((uint8_t *)&udphdr->len, sizeof(udphdr->len), sum);
0125     sum = raw_checksum((uint8_t *)udphdr, UDP_HLEN, sum);
0126     sum = raw_checksum((uint8_t *)udp_payload, payload_len, sum);
0127     res = 0xffff & ~sum;
0128     if (res)
0129         return htons(res);
0130     else
0131         return CSUM_MANGLED_0;
0132 }
0133
0134 static void send_fragment(int fd_raw, struct sockaddr *addr, socklen_t alen,
0135                 int offset, bool ipv6)
0136 {
0137     int frag_len;
0138     int res;
0139     int payload_offset = offset > 0 ? offset - UDP_HLEN : 0;
0140     uint8_t *frag_start = ipv6 ? ip_frame + IP6_HLEN + FRAG_HLEN :
0141                     ip_frame + IP4_HLEN;
0142
0143     if (offset == 0) {
0144         struct udphdr udphdr;
0145         udphdr.source = htons(cfg_port + 1);
0146         udphdr.dest = htons(cfg_port);
0147         udphdr.len = htons(UDP_HLEN + payload_len);
0148         udphdr.check = 0;
0149         if (ipv6)
0150             udphdr.check = udp6_checksum((struct ip6_hdr *)ip_frame, &udphdr);
0151         else
0152             udphdr.check = udp_checksum((struct ip *)ip_frame, &udphdr);
0153         memcpy(frag_start, &udphdr, UDP_HLEN);
0154     }
0155
0156     if (ipv6) {
0157         struct ip6_hdr *ip6hdr = (struct ip6_hdr *)ip_frame;
0158         struct ip6_frag *fraghdr = (struct ip6_frag *)(ip_frame + IP6_HLEN);
0159         if (payload_len - payload_offset <= max_frag_len && offset > 0) {
0160             /* This is the last fragment. */
0161             frag_len = FRAG_HLEN + payload_len - payload_offset;
0162             fraghdr->ip6f_offlg = htons(offset);
0163         } else {
0164             frag_len = FRAG_HLEN + max_frag_len;
0165             fraghdr->ip6f_offlg = htons(offset | IP6_MF);
0166         }
0167         ip6hdr->ip6_plen = htons(frag_len);
0168         if (offset == 0)
0169             memcpy(frag_start + UDP_HLEN, udp_payload,
0170                 frag_len - FRAG_HLEN - UDP_HLEN);
0171         else
0172             memcpy(frag_start, udp_payload + payload_offset,
0173                 frag_len - FRAG_HLEN);
0174         frag_len += IP6_HLEN;
0175     } else {
0176         struct ip *iphdr = (struct ip *)ip_frame;
0177         if (payload_len - payload_offset <= max_frag_len && offset > 0) {
0178             /* This is the last fragment. */
0179             frag_len = IP4_HLEN + payload_len - payload_offset;
0180             iphdr->ip_off = htons(offset / 8);
0181         } else {
0182             frag_len = IP4_HLEN + max_frag_len;
0183             iphdr->ip_off = htons(offset / 8 | IP4_MF);
0184         }
0185         iphdr->ip_len = htons(frag_len);
0186         if (offset == 0)
0187             memcpy(frag_start + UDP_HLEN, udp_payload,
0188                 frag_len - IP4_HLEN - UDP_HLEN);
0189         else
0190             memcpy(frag_start, udp_payload + payload_offset,
0191                 frag_len - IP4_HLEN);
0192     }
0193
0194     res = sendto(fd_raw, ip_frame, frag_len, 0, addr, alen);
0195     if (res < 0 && errno != EPERM)
0196         error(1, errno, "send_fragment");
0197     if (res >= 0 && res != frag_len)
0198         error(1, 0, "send_fragment: %d vs %d", res, frag_len);
0199
0200     frag_counter++;
0201 }
0202
0203 static void send_udp_frags(int fd_raw, struct sockaddr *addr,
0204                 socklen_t alen, bool ipv6)
0205 {
0206     struct ip *iphdr = (struct ip *)ip_frame;
0207     struct ip6_hdr *ip6hdr = (struct ip6_hdr *)ip_frame;
0208     int res;
0209     int offset;
0210     int frag_len;
0211
0212     /* Send the UDP datagram using raw IP fragments: the 0th fragment
0213      * has the UDP header; other fragments are pieces of udp_payload
0214      * split in chunks of frag_len size.
0215      *
0216      * Odd fragments (1st, 3rd, 5th, etc.) are sent out first, then
0217      * even fragments (0th, 2nd, etc.) are sent out.
0218      */
0219     if (ipv6) {
0220         struct ip6_frag *fraghdr = (struct ip6_frag *)(ip_frame + IP6_HLEN);
0221         ((struct sockaddr_in6 *)addr)->sin6_port = 0;
0222         memset(ip6hdr, 0, sizeof(*ip6hdr));
0223         ip6hdr->ip6_flow = htonl(6<<28);  /* Version. */
0224         ip6hdr->ip6_nxt = IPPROTO_FRAGMENT;
0225         ip6hdr->ip6_hops = 255;
0226         ip6hdr->ip6_src = addr6;
0227         ip6hdr->ip6_dst = addr6;
0228         fraghdr->ip6f_nxt = IPPROTO_UDP;
0229         fraghdr->ip6f_reserved = 0;
0230         fraghdr->ip6f_ident = htonl(ip_id++);
0231     } else {
0232         memset(iphdr, 0, sizeof(*iphdr));
0233         iphdr->ip_hl = 5;
0234         iphdr->ip_v = 4;
0235         iphdr->ip_tos = 0;
0236         iphdr->ip_id = htons(ip_id++);
0237         iphdr->ip_ttl = 0x40;
0238         iphdr->ip_p = IPPROTO_UDP;
0239         iphdr->ip_src.s_addr = htonl(INADDR_LOOPBACK);
0240         iphdr->ip_dst = addr4;
0241         iphdr->ip_sum = 0;
0242     }
0243
0244     /* Occasionally test in-order fragments. */
0245     if (!cfg_overlap && (rand() % 100 < 15)) {
0246         offset = 0;
0247         while (offset < (UDP_HLEN + payload_len)) {
0248             send_fragment(fd_raw, addr, alen, offset, ipv6);
0249             offset += max_frag_len;
0250         }
0251         return;
0252     }
0253
0254     /* Occasionally test IPv4 "runs" (see net/ipv4/ip_fragment.c) */
0255     if (!cfg_overlap && (rand() % 100 < 20) &&
0256             (payload_len > 9 * max_frag_len)) {
0257         offset = 6 * max_frag_len;
0258         while (offset < (UDP_HLEN + payload_len)) {
0259             send_fragment(fd_raw, addr, alen, offset, ipv6);
0260             offset += max_frag_len;
0261         }
0262         offset = 3 * max_frag_len;
0263         while (offset < 6 * max_frag_len) {
0264             send_fragment(fd_raw, addr, alen, offset, ipv6);
0265             offset += max_frag_len;
0266         }
0267         offset = 0;
0268         while (offset < 3 * max_frag_len) {
0269             send_fragment(fd_raw, addr, alen, offset, ipv6);
0270             offset += max_frag_len;
0271         }
0272         return;
0273     }
0274
0275     /* Odd fragments. */
0276     offset = max_frag_len;
0277     while (offset < (UDP_HLEN + payload_len)) {
0278         send_fragment(fd_raw, addr, alen, offset, ipv6);
0279         /* IPv4 ignores duplicates, so randomly send a duplicate. */
0280         if (rand() % 100 == 1)
0281             send_fragment(fd_raw, addr, alen, offset, ipv6);
0282         offset += 2 * max_frag_len;
0283     }
0284
0285     if (cfg_overlap) {
0286         /* Send an extra random fragment.
0287          *
0288          * Duplicates and some fragments completely inside
0289          * previously sent fragments are dropped/ignored. So
0290          * random offset and frag_len can result in a dropped
0291          * fragment instead of a dropped queue/packet. Thus we
0292          * hard-code offset and frag_len.
0293          */
0294         if (max_frag_len * 4 < payload_len || max_frag_len < 16) {
0295             /* not enough payload for random offset and frag_len. */
0296             offset = 8;
0297             frag_len = UDP_HLEN + max_frag_len;
0298         } else {
0299             offset = rand() % (payload_len / 2);
0300             frag_len = 2 * max_frag_len + 1 + rand() % 256;
0301         }
0302         if (ipv6) {
0303             struct ip6_frag *fraghdr = (struct ip6_frag *)(ip_frame + IP6_HLEN);
0304             /* sendto() returns EINVAL if offset + frag_len is too small. */
0305             /* In IPv6 if !!(frag_len % 8), the fragment is dropped. */
0306             frag_len &= ~0x7;
0307             fraghdr->ip6f_offlg = htons(offset / 8 | IP6_MF);
0308             ip6hdr->ip6_plen = htons(frag_len);
0309             frag_len += IP6_HLEN;
0310         } else {
0311             frag_len += IP4_HLEN;
0312             iphdr->ip_off = htons(offset / 8 | IP4_MF);
0313             iphdr->ip_len = htons(frag_len);
0314         }
0315         res = sendto(fd_raw, ip_frame, frag_len, 0, addr, alen);
0316         if (res < 0 && errno != EPERM)
0317             error(1, errno, "sendto overlap: %d", frag_len);
0318         if (res >= 0 && res != frag_len)
0319             error(1, 0, "sendto overlap: %d vs %d", (int)res, frag_len);
0320         frag_counter++;
0321     }
0322
0323     /* Event fragments. */
0324     offset = 0;
0325     while (offset < (UDP_HLEN + payload_len)) {
0326         send_fragment(fd_raw, addr, alen, offset, ipv6);
0327         /* IPv4 ignores duplicates, so randomly send a duplicate. */
0328         if (rand() % 100 == 1)
0329             send_fragment(fd_raw, addr, alen, offset, ipv6);
0330         offset += 2 * max_frag_len;
0331     }
0332 }
0333
0334 static void run_test(struct sockaddr *addr, socklen_t alen, bool ipv6)
0335 {
0336     int fd_tx_raw, fd_rx_udp;
0337     /* Frag queue timeout is set to one second in the calling script;
0338      * socket timeout should be just a bit longer to avoid tests interfering
0339      * with each other.
0340      */
0341     struct timeval tv = { .tv_sec = 1, .tv_usec = 10 };
0342     int idx;
0343     int min_frag_len = 8;
0344
0345     /* Initialize the payload. */
0346     for (idx = 0; idx < MSG_LEN_MAX; ++idx)
0347         udp_payload[idx] = idx % 256;
0348
0349     /* Open sockets. */
0350     fd_tx_raw = socket(addr->sa_family, SOCK_RAW, IPPROTO_RAW);
0351     if (fd_tx_raw == -1)
0352         error(1, errno, "socket tx_raw");
0353
0354     fd_rx_udp = socket(addr->sa_family, SOCK_DGRAM, 0);
0355     if (fd_rx_udp == -1)
0356         error(1, errno, "socket rx_udp");
0357     if (bind(fd_rx_udp, addr, alen))
0358         error(1, errno, "bind");
0359     /* Fail fast. */
0360     if (setsockopt(fd_rx_udp, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)))
0361         error(1, errno, "setsockopt rcv timeout");
0362
0363     for (payload_len = min_frag_len; payload_len < MSG_LEN_MAX;
0364             payload_len += (rand() % 4096)) {
0365         if (cfg_verbose)
0366             printf("payload_len: %d\n", payload_len);
0367
0368         if (cfg_overlap) {
0369             /* With overlaps, one send/receive pair below takes
0370              * at least one second (== timeout) to run, so there
0371              * is not enough test time to run a nested loop:
0372              * the full overlap test takes 20-30 seconds.
0373              */
0374             max_frag_len = min_frag_len +
0375                 rand() % (1500 - FRAG_HLEN - min_frag_len);
0376             send_udp_frags(fd_tx_raw, addr, alen, ipv6);
0377             recv_validate_udp(fd_rx_udp);
0378         } else {
0379             /* Without overlaps, each packet reassembly (== one
0380              * send/receive pair below) takes very little time to
0381              * run, so we can easily afford more thourough testing
0382              * with a nested loop: the full non-overlap test takes
0383              * less than one second).
0384              */
0385             max_frag_len = min_frag_len;
0386             do {
0387                 send_udp_frags(fd_tx_raw, addr, alen, ipv6);
0388                 recv_validate_udp(fd_rx_udp);
0389                 max_frag_len += 8 * (rand() % 8);
0390             } while (max_frag_len < (1500 - FRAG_HLEN) &&
0391                  max_frag_len <= payload_len);
0392         }
0393     }
0394
0395     /* Cleanup. */
0396     if (close(fd_tx_raw))
0397         error(1, errno, "close tx_raw");
0398     if (close(fd_rx_udp))
0399         error(1, errno, "close rx_udp");
0400
0401     if (cfg_verbose)
0402         printf("processed %d messages, %d fragments\n",
0403             msg_counter, frag_counter);
0404
0405     fprintf(stderr, "PASS\n");
0406 }
0407
0408
0409 static void run_test_v4(void)
0410 {
0411     struct sockaddr_in addr = {0};
0412
0413     addr.sin_family = AF_INET;
0414     addr.sin_port = htons(cfg_port);
0415     addr.sin_addr = addr4;
0416
0417     run_test((void *)&addr, sizeof(addr), false /* !ipv6 */);
0418 }
0419
0420 static void run_test_v6(void)
0421 {
0422     struct sockaddr_in6 addr = {0};
0423
0424     addr.sin6_family = AF_INET6;
0425     addr.sin6_port = htons(cfg_port);
0426     addr.sin6_addr = addr6;
0427
0428     run_test((void *)&addr, sizeof(addr), true /* ipv6 */);
0429 }
0430
0431 static void parse_opts(int argc, char **argv)
0432 {
0433     int c;
0434
0435     while ((c = getopt(argc, argv, "46opv")) != -1) {
0436         switch (c) {
0437         case '4':
0438             cfg_do_ipv4 = true;
0439             break;
0440         case '6':
0441             cfg_do_ipv6 = true;
0442             break;
0443         case 'o':
0444             cfg_overlap = true;
0445             break;
0446         case 'p':
0447             cfg_permissive = true;
0448             break;
0449         case 'v':
0450             cfg_verbose = true;
0451             break;
0452         default:
0453             error(1, 0, "%s: parse error", argv[0]);
0454         }
0455     }
0456 }
0457
0458 int main(int argc, char **argv)
0459 {
0460     parse_opts(argc, argv);
0461     seed = time(NULL);
0462     srand(seed);
0463     /* Print the seed to track/reproduce potential failures. */
0464     printf("seed = %d\n", seed);
0465
0466     if (cfg_do_ipv4)
0467         run_test_v4();
0468     if (cfg_do_ipv6)
0469         run_test_v6();
0470
0471     return 0;
0472 }