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 unsigned short cfg_port = 9000; 24 25 const struct in_addr addr4 = { .s_addr = __constant_htonl(INADDR_LOOPBACK + 2) }; 26 27 #define IP4_HLEN (sizeof(struct iphdr)) 28 #define IP6_HLEN (sizeof(struct ip6_hdr)) 29 #define UDP_HLEN (sizeof(struct udphdr)) 30 31 static int msg_len; 32 static int max_frag_len; 33 34 #define MSG_LEN_MAX 60000 /* Max UDP payload length. */ 35 36 #define IP4_MF (1u << 13) /* IPv4 MF flag. */ 37 38 static uint8_t udp_payload[MSG_LEN_MAX]; 39 static uint8_t ip_frame[IP_MAXPACKET]; 40 static uint16_t ip_id = 0xabcd; 41 static int msg_counter; 42 static int frag_counter; 43 static unsigned int seed; 44 45 /* Receive a UDP packet. Validate it matches udp_payload. */ 46 static void recv_validate_udp(int fd_udp) 47 { 48 ssize_t ret; 49 static uint8_t recv_buff[MSG_LEN_MAX]; 50 51 ret = recv(fd_udp, recv_buff, msg_len, 0); 52 msg_counter++; 53 54 if (cfg_overlap) { 55 if (ret != -1) 56 error(1, 0, "recv: expected timeout; got %d; seed = %u", 57 (int)ret, seed); 58 if (errno != ETIMEDOUT && errno != EAGAIN) 59 error(1, errno, "recv: expected timeout: %d; seed = %u", 60 errno, seed); 61 return; /* OK */ 62 } 63 64 if (ret == -1) 65 error(1, errno, "recv: msg_len = %d max_frag_len = %d", 66 msg_len, max_frag_len); 67 if (ret != msg_len) 68 error(1, 0, "recv: wrong size: %d vs %d", (int)ret, msg_len); 69 if (memcmp(udp_payload, recv_buff, msg_len)) 70 error(1, 0, "recv: wrong data"); 71 } 72 73 static uint32_t raw_checksum(uint8_t *buf, int len, uint32_t sum) 74 { 75 int i; 76 77 for (i = 0; i < (len & ~1U); i += 2) { 78 sum += (u_int16_t)ntohs(*((u_int16_t *)(buf + i))); 79 if (sum > 0xffff) 80 sum -= 0xffff; 81 } 82 83 if (i < len) { 84 sum += buf[i] << 8; 85 if (sum > 0xffff) 86 sum -= 0xffff; 87 } 88 89 return sum; 90 } 91 92 static uint16_t udp_checksum(struct ip *iphdr, struct udphdr *udphdr) 93 { 94 uint32_t sum = 0; 95 96 sum = raw_checksum((uint8_t *)&iphdr->ip_src, 2 * sizeof(iphdr->ip_src), 97 IPPROTO_UDP + (uint32_t)(UDP_HLEN + msg_len)); 98 sum = raw_checksum((uint8_t *)udp_payload, msg_len, sum); 99 sum = raw_checksum((uint8_t *)udphdr, UDP_HLEN, sum); 100 return htons(0xffff & ~sum); 101 } 102 103 static void send_fragment(int fd_raw, struct sockaddr *addr, socklen_t alen, 104 struct ip *iphdr, int offset) 105 { 106 int frag_len; 107 int res; 108 109 if (msg_len - offset <= max_frag_len) { 110 /* This is the last fragment. */ 111 frag_len = IP4_HLEN + msg_len - offset; 112 iphdr->ip_off = htons((offset + UDP_HLEN) / 8); 113 } else { 114 frag_len = IP4_HLEN + max_frag_len; 115 iphdr->ip_off = htons((offset + UDP_HLEN) / 8 | IP4_MF); 116 } 117 iphdr->ip_len = htons(frag_len); 118 memcpy(ip_frame + IP4_HLEN, udp_payload + offset, 119 frag_len - IP4_HLEN); 120 121 res = sendto(fd_raw, ip_frame, frag_len, 0, addr, alen); 122 if (res < 0) 123 error(1, errno, "send_fragment"); 124 if (res != frag_len) 125 error(1, 0, "send_fragment: %d vs %d", res, frag_len); 126 127 frag_counter++; 128 } 129 130 static void send_udp_frags_v4(int fd_raw, struct sockaddr *addr, socklen_t alen) 131 { 132 struct ip *iphdr = (struct ip *)ip_frame; 133 struct udphdr udphdr; 134 int res; 135 int offset; 136 int frag_len; 137 138 /* Send the UDP datagram using raw IP fragments: the 0th fragment 139 * has the UDP header; other fragments are pieces of udp_payload 140 * split in chunks of frag_len size. 141 * 142 * Odd fragments (1st, 3rd, 5th, etc.) are sent out first, then 143 * even fragments (0th, 2nd, etc.) are sent out. 144 */ 145 memset(iphdr, 0, sizeof(*iphdr)); 146 iphdr->ip_hl = 5; 147 iphdr->ip_v = 4; 148 iphdr->ip_tos = 0; 149 iphdr->ip_id = htons(ip_id++); 150 iphdr->ip_ttl = 0x40; 151 iphdr->ip_p = IPPROTO_UDP; 152 iphdr->ip_src.s_addr = htonl(INADDR_LOOPBACK); 153 iphdr->ip_dst = addr4; 154 iphdr->ip_sum = 0; 155 156 /* Odd fragments. */ 157 offset = 0; 158 while (offset < msg_len) { 159 send_fragment(fd_raw, addr, alen, iphdr, offset); 160 offset += 2 * max_frag_len; 161 } 162 163 if (cfg_overlap) { 164 /* Send an extra random fragment. */ 165 offset = rand() % (UDP_HLEN + msg_len - 1); 166 /* sendto() returns EINVAL if offset + frag_len is too small. */ 167 frag_len = IP4_HLEN + UDP_HLEN + rand() % 256; 168 iphdr->ip_off = htons(offset / 8 | IP4_MF); 169 iphdr->ip_len = htons(frag_len); 170 res = sendto(fd_raw, ip_frame, frag_len, 0, addr, alen); 171 if (res < 0) 172 error(1, errno, "sendto overlap"); 173 if (res != frag_len) 174 error(1, 0, "sendto overlap: %d vs %d", (int)res, frag_len); 175 frag_counter++; 176 } 177 178 /* Zeroth fragment (UDP header). */ 179 frag_len = IP4_HLEN + UDP_HLEN; 180 iphdr->ip_len = htons(frag_len); 181 iphdr->ip_off = htons(IP4_MF); 182 183 udphdr.source = htons(cfg_port + 1); 184 udphdr.dest = htons(cfg_port); 185 udphdr.len = htons(UDP_HLEN + msg_len); 186 udphdr.check = 0; 187 udphdr.check = udp_checksum(iphdr, &udphdr); 188 189 memcpy(ip_frame + IP4_HLEN, &udphdr, UDP_HLEN); 190 res = sendto(fd_raw, ip_frame, frag_len, 0, addr, alen); 191 if (res < 0) 192 error(1, errno, "sendto UDP header"); 193 if (res != frag_len) 194 error(1, 0, "sendto UDP header: %d vs %d", (int)res, frag_len); 195 frag_counter++; 196 197 /* Even fragments. */ 198 offset = max_frag_len; 199 while (offset < msg_len) { 200 send_fragment(fd_raw, addr, alen, iphdr, offset); 201 offset += 2 * max_frag_len; 202 } 203 } 204 205 static void run_test(struct sockaddr *addr, socklen_t alen) 206 { 207 int fd_tx_udp, fd_tx_raw, fd_rx_udp; 208 struct timeval tv = { .tv_sec = 0, .tv_usec = 10 * 1000 }; 209 int idx; 210 211 /* Initialize the payload. */ 212 for (idx = 0; idx < MSG_LEN_MAX; ++idx) 213 udp_payload[idx] = idx % 256; 214 215 /* Open sockets. */ 216 fd_tx_udp = socket(addr->sa_family, SOCK_DGRAM, 0); 217 if (fd_tx_udp == -1) 218 error(1, errno, "socket tx_udp"); 219 220 fd_tx_raw = socket(addr->sa_family, SOCK_RAW, IPPROTO_RAW); 221 if (fd_tx_raw == -1) 222 error(1, errno, "socket tx_raw"); 223 224 fd_rx_udp = socket(addr->sa_family, SOCK_DGRAM, 0); 225 if (fd_rx_udp == -1) 226 error(1, errno, "socket rx_udp"); 227 if (bind(fd_rx_udp, addr, alen)) 228 error(1, errno, "bind"); 229 /* Fail fast. */ 230 if (setsockopt(fd_rx_udp, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv))) 231 error(1, errno, "setsockopt rcv timeout"); 232 233 for (msg_len = 1; msg_len < MSG_LEN_MAX; msg_len += (rand() % 4096)) { 234 if (cfg_verbose) 235 printf("msg_len: %d\n", msg_len); 236 max_frag_len = addr->sa_family == AF_INET ? 8 : 1280; 237 for (; max_frag_len < 1500 && max_frag_len <= msg_len; 238 max_frag_len += 8) { 239 send_udp_frags_v4(fd_tx_raw, addr, alen); 240 recv_validate_udp(fd_rx_udp); 241 } 242 } 243 244 /* Cleanup. */ 245 if (close(fd_tx_raw)) 246 error(1, errno, "close tx_raw"); 247 if (close(fd_tx_udp)) 248 error(1, errno, "close tx_udp"); 249 if (close(fd_rx_udp)) 250 error(1, errno, "close rx_udp"); 251 252 if (cfg_verbose) 253 printf("processed %d messages, %d fragments\n", 254 msg_counter, frag_counter); 255 256 fprintf(stderr, "PASS\n"); 257 } 258 259 260 static void run_test_v4(void) 261 { 262 struct sockaddr_in addr = {0}; 263 264 addr.sin_family = AF_INET; 265 addr.sin_port = htons(cfg_port); 266 addr.sin_addr = addr4; 267 268 run_test((void *)&addr, sizeof(addr)); 269 } 270 271 static void run_test_v6(void) 272 { 273 fprintf(stderr, "NOT IMPL.\n"); 274 exit(1); 275 } 276 277 static void parse_opts(int argc, char **argv) 278 { 279 int c; 280 281 while ((c = getopt(argc, argv, "46ov")) != -1) { 282 switch (c) { 283 case '4': 284 cfg_do_ipv4 = true; 285 break; 286 case '6': 287 cfg_do_ipv6 = true; 288 break; 289 case 'o': 290 cfg_overlap = true; 291 break; 292 case 'v': 293 cfg_verbose = true; 294 break; 295 default: 296 error(1, 0, "%s: parse error", argv[0]); 297 } 298 } 299 } 300 301 int main(int argc, char **argv) 302 { 303 parse_opts(argc, argv); 304 seed = time(NULL); 305 srand(seed); 306 307 if (cfg_do_ipv4) 308 run_test_v4(); 309 if (cfg_do_ipv6) 310 run_test_v6(); 311 312 return 0; 313 } 314