tools/testing/selftests/net/ip

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
recv_validate_udp
raw_checksum
udp_checksum
udp6_checksum
send_fragment
send_udp_frags
run_test
run_test_v4
run_test_v6
parse_opts
main
   1 // SPDX-License-Identifier: GPL-2.0
   2 
   3 #define _GNU_SOURCE
   4 
   5 #include <arpa/inet.h>
   6 #include <errno.h>
   7 #include <error.h>
   8 #include <linux/in.h>
   9 #include <netinet/ip.h>
  10 #include <netinet/ip6.h>
  11 #include <netinet/udp.h>
  12 #include <stdbool.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <time.h>
  17 #include <unistd.h>
  18 
  19 static bool             cfg_do_ipv4;
  20 static bool             cfg_do_ipv6;
  21 static bool             cfg_verbose;
  22 static bool             cfg_overlap;
  23 static bool             cfg_permissive;
  24 static unsigned short   cfg_port = 9000;
  25 
  26 const struct in_addr addr4 = { .s_addr = __constant_htonl(INADDR_LOOPBACK + 2) };
  27 const struct in6_addr addr6 = IN6ADDR_LOOPBACK_INIT;
  28 
  29 #define IP4_HLEN        (sizeof(struct iphdr))
  30 #define IP6_HLEN        (sizeof(struct ip6_hdr))
  31 #define UDP_HLEN        (sizeof(struct udphdr))
  32 
  33 /* IPv6 fragment header lenth. */
  34 #define FRAG_HLEN       8
  35 
  36 static int payload_len;
  37 static int max_frag_len;
  38 
  39 #define MSG_LEN_MAX     10000   /* Max UDP payload length. */
  40 
  41 #define IP4_MF          (1u << 13)  /* IPv4 MF flag. */
  42 #define IP6_MF          (1)  /* IPv6 MF flag. */
  43 
  44 #define CSUM_MANGLED_0 (0xffff)
  45 
  46 static uint8_t udp_payload[MSG_LEN_MAX];
  47 static uint8_t ip_frame[IP_MAXPACKET];
  48 static uint32_t ip_id = 0xabcd;
  49 static int msg_counter;
  50 static int frag_counter;
  51 static unsigned int seed;
  52 
  53 /* Receive a UDP packet. Validate it matches udp_payload. */
  54 static void recv_validate_udp(int fd_udp)
  55 {
  56         ssize_t ret;
  57         static uint8_t recv_buff[MSG_LEN_MAX];
  58 
  59         ret = recv(fd_udp, recv_buff, payload_len, 0);
  60         msg_counter++;
  61 
  62         if (cfg_overlap) {
  63                 if (ret == -1 && (errno == ETIMEDOUT || errno == EAGAIN))
  64                         return;  /* OK */
  65                 if (!cfg_permissive) {
  66                         if (ret != -1)
  67                                 error(1, 0, "recv: expected timeout; got %d",
  68                                         (int)ret);
  69                         error(1, errno, "recv: expected timeout: %d", errno);
  70                 }
  71         }
  72 
  73         if (ret == -1)
  74                 error(1, errno, "recv: payload_len = %d max_frag_len = %d",
  75                         payload_len, max_frag_len);
  76         if (ret != payload_len)
  77                 error(1, 0, "recv: wrong size: %d vs %d", (int)ret, payload_len);
  78         if (memcmp(udp_payload, recv_buff, payload_len))
  79                 error(1, 0, "recv: wrong data");
  80 }
  81 
  82 static uint32_t raw_checksum(uint8_t *buf, int len, uint32_t sum)
  83 {
  84         int i;
  85 
  86         for (i = 0; i < (len & ~1U); i += 2) {
  87                 sum += (u_int16_t)ntohs(*((u_int16_t *)(buf + i)));
  88                 if (sum > 0xffff)
  89                         sum -= 0xffff;
  90         }
  91 
  92         if (i < len) {
  93                 sum += buf[i] << 8;
  94                 if (sum > 0xffff)
  95                         sum -= 0xffff;
  96         }
  97 
  98         return sum;
  99 }
 100 
 101 static uint16_t udp_checksum(struct ip *iphdr, struct udphdr *udphdr)
 102 {
 103         uint32_t sum = 0;
 104         uint16_t res;
 105 
 106         sum = raw_checksum((uint8_t *)&iphdr->ip_src, 2 * sizeof(iphdr->ip_src),
 107                                 IPPROTO_UDP + (uint32_t)(UDP_HLEN + payload_len));
 108         sum = raw_checksum((uint8_t *)udphdr, UDP_HLEN, sum);
 109         sum = raw_checksum((uint8_t *)udp_payload, payload_len, sum);
 110         res = 0xffff & ~sum;
 111         if (res)
 112                 return htons(res);
 113         else
 114                 return CSUM_MANGLED_0;
 115 }
 116 
 117 static uint16_t udp6_checksum(struct ip6_hdr *iphdr, struct udphdr *udphdr)
 118 {
 119         uint32_t sum = 0;
 120         uint16_t res;
 121 
 122         sum = raw_checksum((uint8_t *)&iphdr->ip6_src, 2 * sizeof(iphdr->ip6_src),
 123                                 IPPROTO_UDP);
 124         sum = raw_checksum((uint8_t *)&udphdr->len, sizeof(udphdr->len), sum);
 125         sum = raw_checksum((uint8_t *)udphdr, UDP_HLEN, sum);
 126         sum = raw_checksum((uint8_t *)udp_payload, payload_len, sum);
 127         res = 0xffff & ~sum;
 128         if (res)
 129                 return htons(res);
 130         else
 131                 return CSUM_MANGLED_0;
 132 }
 133 
 134 static void send_fragment(int fd_raw, struct sockaddr *addr, socklen_t alen,
 135                                 int offset, bool ipv6)
 136 {
 137         int frag_len;
 138         int res;
 139         int payload_offset = offset > 0 ? offset - UDP_HLEN : 0;
 140         uint8_t *frag_start = ipv6 ? ip_frame + IP6_HLEN + FRAG_HLEN :
 141                                         ip_frame + IP4_HLEN;
 142 
 143         if (offset == 0) {
 144                 struct udphdr udphdr;
 145                 udphdr.source = htons(cfg_port + 1);
 146                 udphdr.dest = htons(cfg_port);
 147                 udphdr.len = htons(UDP_HLEN + payload_len);
 148                 udphdr.check = 0;
 149                 if (ipv6)
 150                         udphdr.check = udp6_checksum((struct ip6_hdr *)ip_frame, &udphdr);
 151                 else
 152                         udphdr.check = udp_checksum((struct ip *)ip_frame, &udphdr);
 153                 memcpy(frag_start, &udphdr, UDP_HLEN);
 154         }
 155 
 156         if (ipv6) {
 157                 struct ip6_hdr *ip6hdr = (struct ip6_hdr *)ip_frame;
 158                 struct ip6_frag *fraghdr = (struct ip6_frag *)(ip_frame + IP6_HLEN);
 159                 if (payload_len - payload_offset <= max_frag_len && offset > 0) {
 160                         /* This is the last fragment. */
 161                         frag_len = FRAG_HLEN + payload_len - payload_offset;
 162                         fraghdr->ip6f_offlg = htons(offset);
 163                 } else {
 164                         frag_len = FRAG_HLEN + max_frag_len;
 165                         fraghdr->ip6f_offlg = htons(offset | IP6_MF);
 166                 }
 167                 ip6hdr->ip6_plen = htons(frag_len);
 168                 if (offset == 0)
 169                         memcpy(frag_start + UDP_HLEN, udp_payload,
 170                                 frag_len - FRAG_HLEN - UDP_HLEN);
 171                 else
 172                         memcpy(frag_start, udp_payload + payload_offset,
 173                                 frag_len - FRAG_HLEN);
 174                 frag_len += IP6_HLEN;
 175         } else {
 176                 struct ip *iphdr = (struct ip *)ip_frame;
 177                 if (payload_len - payload_offset <= max_frag_len && offset > 0) {
 178                         /* This is the last fragment. */
 179                         frag_len = IP4_HLEN + payload_len - payload_offset;
 180                         iphdr->ip_off = htons(offset / 8);
 181                 } else {
 182                         frag_len = IP4_HLEN + max_frag_len;
 183                         iphdr->ip_off = htons(offset / 8 | IP4_MF);
 184                 }
 185                 iphdr->ip_len = htons(frag_len);
 186                 if (offset == 0)
 187                         memcpy(frag_start + UDP_HLEN, udp_payload,
 188                                 frag_len - IP4_HLEN - UDP_HLEN);
 189                 else
 190                         memcpy(frag_start, udp_payload + payload_offset,
 191                                 frag_len - IP4_HLEN);
 192         }
 193 
 194         res = sendto(fd_raw, ip_frame, frag_len, 0, addr, alen);
 195         if (res < 0)
 196                 error(1, errno, "send_fragment");
 197         if (res != frag_len)
 198                 error(1, 0, "send_fragment: %d vs %d", res, frag_len);
 199 
 200         frag_counter++;
 201 }
 202 
 203 static void send_udp_frags(int fd_raw, struct sockaddr *addr,
 204                                 socklen_t alen, bool ipv6)
 205 {
 206         struct ip *iphdr = (struct ip *)ip_frame;
 207         struct ip6_hdr *ip6hdr = (struct ip6_hdr *)ip_frame;
 208         int res;
 209         int offset;
 210         int frag_len;
 211 
 212         /* Send the UDP datagram using raw IP fragments: the 0th fragment
 213          * has the UDP header; other fragments are pieces of udp_payload
 214          * split in chunks of frag_len size.
 215          *
 216          * Odd fragments (1st, 3rd, 5th, etc.) are sent out first, then
 217          * even fragments (0th, 2nd, etc.) are sent out.
 218          */
 219         if (ipv6) {
 220                 struct ip6_frag *fraghdr = (struct ip6_frag *)(ip_frame + IP6_HLEN);
 221                 ((struct sockaddr_in6 *)addr)->sin6_port = 0;
 222                 memset(ip6hdr, 0, sizeof(*ip6hdr));
 223                 ip6hdr->ip6_flow = htonl(6<<28);  /* Version. */
 224                 ip6hdr->ip6_nxt = IPPROTO_FRAGMENT;
 225                 ip6hdr->ip6_hops = 255;
 226                 ip6hdr->ip6_src = addr6;
 227                 ip6hdr->ip6_dst = addr6;
 228                 fraghdr->ip6f_nxt = IPPROTO_UDP;
 229                 fraghdr->ip6f_reserved = 0;
 230                 fraghdr->ip6f_ident = htonl(ip_id++);
 231         } else {
 232                 memset(iphdr, 0, sizeof(*iphdr));
 233                 iphdr->ip_hl = 5;
 234                 iphdr->ip_v = 4;
 235                 iphdr->ip_tos = 0;
 236                 iphdr->ip_id = htons(ip_id++);
 237                 iphdr->ip_ttl = 0x40;
 238                 iphdr->ip_p = IPPROTO_UDP;
 239                 iphdr->ip_src.s_addr = htonl(INADDR_LOOPBACK);
 240                 iphdr->ip_dst = addr4;
 241                 iphdr->ip_sum = 0;
 242         }
 243 
 244         /* Occasionally test in-order fragments. */
 245         if (!cfg_overlap && (rand() % 100 < 15)) {
 246                 offset = 0;
 247                 while (offset < (UDP_HLEN + payload_len)) {
 248                         send_fragment(fd_raw, addr, alen, offset, ipv6);
 249                         offset += max_frag_len;
 250                 }
 251                 return;
 252         }
 253 
 254         /* Occasionally test IPv4 "runs" (see net/ipv4/ip_fragment.c) */
 255         if (!cfg_overlap && (rand() % 100 < 20) &&
 256                         (payload_len > 9 * max_frag_len)) {
 257                 offset = 6 * max_frag_len;
 258                 while (offset < (UDP_HLEN + payload_len)) {
 259                         send_fragment(fd_raw, addr, alen, offset, ipv6);
 260                         offset += max_frag_len;
 261                 }
 262                 offset = 3 * max_frag_len;
 263                 while (offset < 6 * max_frag_len) {
 264                         send_fragment(fd_raw, addr, alen, offset, ipv6);
 265                         offset += max_frag_len;
 266                 }
 267                 offset = 0;
 268                 while (offset < 3 * max_frag_len) {
 269                         send_fragment(fd_raw, addr, alen, offset, ipv6);
 270                         offset += max_frag_len;
 271                 }
 272                 return;
 273         }
 274 
 275         /* Odd fragments. */
 276         offset = max_frag_len;
 277         while (offset < (UDP_HLEN + payload_len)) {
 278                 send_fragment(fd_raw, addr, alen, offset, ipv6);
 279                 /* IPv4 ignores duplicates, so randomly send a duplicate. */
 280                 if (rand() % 100 == 1)
 281                         send_fragment(fd_raw, addr, alen, offset, ipv6);
 282                 offset += 2 * max_frag_len;
 283         }
 284 
 285         if (cfg_overlap) {
 286                 /* Send an extra random fragment.
 287                  *
 288                  * Duplicates and some fragments completely inside
 289                  * previously sent fragments are dropped/ignored. So
 290                  * random offset and frag_len can result in a dropped
 291                  * fragment instead of a dropped queue/packet. Thus we
 292                  * hard-code offset and frag_len.
 293                  */
 294                 if (max_frag_len * 4 < payload_len || max_frag_len < 16) {
 295                         /* not enough payload for random offset and frag_len. */
 296                         offset = 8;
 297                         frag_len = UDP_HLEN + max_frag_len;
 298                 } else {
 299                         offset = rand() % (payload_len / 2);
 300                         frag_len = 2 * max_frag_len + 1 + rand() % 256;
 301                 }
 302                 if (ipv6) {
 303                         struct ip6_frag *fraghdr = (struct ip6_frag *)(ip_frame + IP6_HLEN);
 304                         /* sendto() returns EINVAL if offset + frag_len is too small. */
 305                         /* In IPv6 if !!(frag_len % 8), the fragment is dropped. */
 306                         frag_len &= ~0x7;
 307                         fraghdr->ip6f_offlg = htons(offset / 8 | IP6_MF);
 308                         ip6hdr->ip6_plen = htons(frag_len);
 309                         frag_len += IP6_HLEN;
 310                 } else {
 311                         frag_len += IP4_HLEN;
 312                         iphdr->ip_off = htons(offset / 8 | IP4_MF);
 313                         iphdr->ip_len = htons(frag_len);
 314                 }
 315                 res = sendto(fd_raw, ip_frame, frag_len, 0, addr, alen);
 316                 if (res < 0)
 317                         error(1, errno, "sendto overlap: %d", frag_len);
 318                 if (res != frag_len)
 319                         error(1, 0, "sendto overlap: %d vs %d", (int)res, frag_len);
 320                 frag_counter++;
 321         }
 322 
 323         /* Event fragments. */
 324         offset = 0;
 325         while (offset < (UDP_HLEN + payload_len)) {
 326                 send_fragment(fd_raw, addr, alen, offset, ipv6);
 327                 /* IPv4 ignores duplicates, so randomly send a duplicate. */
 328                 if (rand() % 100 == 1)
 329                         send_fragment(fd_raw, addr, alen, offset, ipv6);
 330                 offset += 2 * max_frag_len;
 331         }
 332 }
 333 
 334 static void run_test(struct sockaddr *addr, socklen_t alen, bool ipv6)
 335 {
 336         int fd_tx_raw, fd_rx_udp;
 337         /* Frag queue timeout is set to one second in the calling script;
 338          * socket timeout should be just a bit longer to avoid tests interfering
 339          * with each other.
 340          */
 341         struct timeval tv = { .tv_sec = 1, .tv_usec = 10 };
 342         int idx;
 343         int min_frag_len = 8;
 344 
 345         /* Initialize the payload. */
 346         for (idx = 0; idx < MSG_LEN_MAX; ++idx)
 347                 udp_payload[idx] = idx % 256;
 348 
 349         /* Open sockets. */
 350         fd_tx_raw = socket(addr->sa_family, SOCK_RAW, IPPROTO_RAW);
 351         if (fd_tx_raw == -1)
 352                 error(1, errno, "socket tx_raw");
 353 
 354         fd_rx_udp = socket(addr->sa_family, SOCK_DGRAM, 0);
 355         if (fd_rx_udp == -1)
 356                 error(1, errno, "socket rx_udp");
 357         if (bind(fd_rx_udp, addr, alen))
 358                 error(1, errno, "bind");
 359         /* Fail fast. */
 360         if (setsockopt(fd_rx_udp, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)))
 361                 error(1, errno, "setsockopt rcv timeout");
 362 
 363         for (payload_len = min_frag_len; payload_len < MSG_LEN_MAX;
 364                         payload_len += (rand() % 4096)) {
 365                 if (cfg_verbose)
 366                         printf("payload_len: %d\n", payload_len);
 367 
 368                 if (cfg_overlap) {
 369                         /* With overlaps, one send/receive pair below takes
 370                          * at least one second (== timeout) to run, so there
 371                          * is not enough test time to run a nested loop:
 372                          * the full overlap test takes 20-30 seconds.
 373                          */
 374                         max_frag_len = min_frag_len +
 375                                 rand() % (1500 - FRAG_HLEN - min_frag_len);
 376                         send_udp_frags(fd_tx_raw, addr, alen, ipv6);
 377                         recv_validate_udp(fd_rx_udp);
 378                 } else {
 379                         /* Without overlaps, each packet reassembly (== one
 380                          * send/receive pair below) takes very little time to
 381                          * run, so we can easily afford more thourough testing
 382                          * with a nested loop: the full non-overlap test takes
 383                          * less than one second).
 384                          */
 385                         max_frag_len = min_frag_len;
 386                         do {
 387                                 send_udp_frags(fd_tx_raw, addr, alen, ipv6);
 388                                 recv_validate_udp(fd_rx_udp);
 389                                 max_frag_len += 8 * (rand() % 8);
 390                         } while (max_frag_len < (1500 - FRAG_HLEN) &&
 391                                  max_frag_len <= payload_len);
 392                 }
 393         }
 394 
 395         /* Cleanup. */
 396         if (close(fd_tx_raw))
 397                 error(1, errno, "close tx_raw");
 398         if (close(fd_rx_udp))
 399                 error(1, errno, "close rx_udp");
 400 
 401         if (cfg_verbose)
 402                 printf("processed %d messages, %d fragments\n",
 403                         msg_counter, frag_counter);
 404 
 405         fprintf(stderr, "PASS\n");
 406 }
 407 
 408 
 409 static void run_test_v4(void)
 410 {
 411         struct sockaddr_in addr = {0};
 412 
 413         addr.sin_family = AF_INET;
 414         addr.sin_port = htons(cfg_port);
 415         addr.sin_addr = addr4;
 416 
 417         run_test((void *)&addr, sizeof(addr), false /* !ipv6 */);
 418 }
 419 
 420 static void run_test_v6(void)
 421 {
 422         struct sockaddr_in6 addr = {0};
 423 
 424         addr.sin6_family = AF_INET6;
 425         addr.sin6_port = htons(cfg_port);
 426         addr.sin6_addr = addr6;
 427 
 428         run_test((void *)&addr, sizeof(addr), true /* ipv6 */);
 429 }
 430 
 431 static void parse_opts(int argc, char **argv)
 432 {
 433         int c;
 434 
 435         while ((c = getopt(argc, argv, "46opv")) != -1) {
 436                 switch (c) {
 437                 case '4':
 438                         cfg_do_ipv4 = true;
 439                         break;
 440                 case '6':
 441                         cfg_do_ipv6 = true;
 442                         break;
 443                 case 'o':
 444                         cfg_overlap = true;
 445                         break;
 446                 case 'p':
 447                         cfg_permissive = true;
 448                         break;
 449                 case 'v':
 450                         cfg_verbose = true;
 451                         break;
 452                 default:
 453                         error(1, 0, "%s: parse error", argv[0]);
 454                 }
 455         }
 456 }
 457 
 458 int main(int argc, char **argv)
 459 {
 460         parse_opts(argc, argv);
 461         seed = time(NULL);
 462         srand(seed);
 463         /* Print the seed to track/reproduce potential failures. */
 464         printf("seed = %d\n", seed);
 465 
 466         if (cfg_do_ipv4)
 467                 run_test_v4();
 468         if (cfg_do_ipv6)
 469                 run_test_v6();
 470 
 471         return 0;
 472 }
/* [<][>][^][v][top][bottom][index][help] */
root/tools/testing/selftests/net/ip_defrag.c

DEFINITIONS
