1 // SPDX-License-Identifier: GPL-2.0 2 3 #define _GNU_SOURCE 4 5 #include <errno.h> 6 #include <fcntl.h> 7 #include <stdio.h> 8 #include <stdlib.h> 9 #include <string.h> 10 #include <unistd.h> 11 #include <net/if.h> 12 #include <linux/if_tun.h> 13 #include <linux/netlink.h> 14 #include <linux/rtnetlink.h> 15 #include <sys/ioctl.h> 16 #include <sys/socket.h> 17 #include <linux/virtio_net.h> 18 #include <netinet/ip.h> 19 #include <netinet/udp.h> 20 #include "../kselftest_harness.h" 21 22 static const char param_dev_tap_name[] = "xmacvtap0"; 23 static const char param_dev_dummy_name[] = "xdummy0"; 24 static unsigned char param_hwaddr_src[] = { 0x00, 0xfe, 0x98, 0x14, 0x22, 0x42 }; 25 static unsigned char param_hwaddr_dest[] = { 26 0x00, 0xfe, 0x98, 0x94, 0xd2, 0x43 27 }; 28 29 #define MAX_RTNL_PAYLOAD (2048) 30 #define PKT_DATA 0xCB 31 #define TEST_PACKET_SZ (sizeof(struct virtio_net_hdr) + ETH_HLEN + ETH_MAX_MTU) 32 33 static struct rtattr *rtattr_add(struct nlmsghdr *nh, unsigned short type, 34 unsigned short len) 35 { 36 struct rtattr *rta = 37 (struct rtattr *)((uint8_t *)nh + RTA_ALIGN(nh->nlmsg_len)); 38 rta->rta_type = type; 39 rta->rta_len = RTA_LENGTH(len); 40 nh->nlmsg_len = RTA_ALIGN(nh->nlmsg_len) + RTA_ALIGN(rta->rta_len); 41 return rta; 42 } 43 44 static struct rtattr *rtattr_begin(struct nlmsghdr *nh, unsigned short type) 45 { 46 return rtattr_add(nh, type, 0); 47 } 48 49 static void rtattr_end(struct nlmsghdr *nh, struct rtattr *attr) 50 { 51 uint8_t *end = (uint8_t *)nh + nh->nlmsg_len; 52 53 attr->rta_len = end - (uint8_t *)attr; 54 } 55 56 static struct rtattr *rtattr_add_str(struct nlmsghdr *nh, unsigned short type, 57 const char *s) 58 { 59 struct rtattr *rta = rtattr_add(nh, type, strlen(s)); 60 61 memcpy(RTA_DATA(rta), s, strlen(s)); 62 return rta; 63 } 64 65 static struct rtattr *rtattr_add_strsz(struct nlmsghdr *nh, unsigned short type, 66 const char *s) 67 { 68 struct rtattr *rta = rtattr_add(nh, type, strlen(s) + 1); 69 70 strcpy(RTA_DATA(rta), s); 71 return rta; 72 } 73 74 static struct rtattr *rtattr_add_any(struct nlmsghdr *nh, unsigned short type, 75 const void *arr, size_t len) 76 { 77 struct rtattr *rta = rtattr_add(nh, type, len); 78 79 memcpy(RTA_DATA(rta), arr, len); 80 return rta; 81 } 82 83 static int dev_create(const char *dev, const char *link_type, 84 int (*fill_rtattr)(struct nlmsghdr *nh), 85 int (*fill_info_data)(struct nlmsghdr *nh)) 86 { 87 struct { 88 struct nlmsghdr nh; 89 struct ifinfomsg info; 90 unsigned char data[MAX_RTNL_PAYLOAD]; 91 } req; 92 struct rtattr *link_info, *info_data; 93 int ret, rtnl; 94 95 rtnl = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE); 96 if (rtnl < 0) { 97 fprintf(stderr, "%s: socket %s\n", __func__, strerror(errno)); 98 return 1; 99 } 100 101 memset(&req, 0, sizeof(req)); 102 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.info)); 103 req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE; 104 req.nh.nlmsg_type = RTM_NEWLINK; 105 106 req.info.ifi_family = AF_UNSPEC; 107 req.info.ifi_type = 1; 108 req.info.ifi_index = 0; 109 req.info.ifi_flags = IFF_BROADCAST | IFF_UP; 110 req.info.ifi_change = 0xffffffff; 111 112 rtattr_add_str(&req.nh, IFLA_IFNAME, dev); 113 114 if (fill_rtattr) { 115 ret = fill_rtattr(&req.nh); 116 if (ret) 117 return ret; 118 } 119 120 link_info = rtattr_begin(&req.nh, IFLA_LINKINFO); 121 122 rtattr_add_strsz(&req.nh, IFLA_INFO_KIND, link_type); 123 124 if (fill_info_data) { 125 info_data = rtattr_begin(&req.nh, IFLA_INFO_DATA); 126 ret = fill_info_data(&req.nh); 127 if (ret) 128 return ret; 129 rtattr_end(&req.nh, info_data); 130 } 131 132 rtattr_end(&req.nh, link_info); 133 134 ret = send(rtnl, &req, req.nh.nlmsg_len, 0); 135 if (ret < 0) 136 fprintf(stderr, "%s: send %s\n", __func__, strerror(errno)); 137 ret = (unsigned int)ret != req.nh.nlmsg_len; 138 139 close(rtnl); 140 return ret; 141 } 142 143 static int dev_delete(const char *dev) 144 { 145 struct { 146 struct nlmsghdr nh; 147 struct ifinfomsg info; 148 unsigned char data[MAX_RTNL_PAYLOAD]; 149 } req; 150 int ret, rtnl; 151 152 rtnl = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE); 153 if (rtnl < 0) { 154 fprintf(stderr, "%s: socket %s\n", __func__, strerror(errno)); 155 return 1; 156 } 157 158 memset(&req, 0, sizeof(req)); 159 req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.info)); 160 req.nh.nlmsg_flags = NLM_F_REQUEST; 161 req.nh.nlmsg_type = RTM_DELLINK; 162 163 req.info.ifi_family = AF_UNSPEC; 164 165 rtattr_add_str(&req.nh, IFLA_IFNAME, dev); 166 167 ret = send(rtnl, &req, req.nh.nlmsg_len, 0); 168 if (ret < 0) 169 fprintf(stderr, "%s: send %s\n", __func__, strerror(errno)); 170 171 ret = (unsigned int)ret != req.nh.nlmsg_len; 172 173 close(rtnl); 174 return ret; 175 } 176 177 static int macvtap_fill_rtattr(struct nlmsghdr *nh) 178 { 179 int ifindex; 180 181 ifindex = if_nametoindex(param_dev_dummy_name); 182 if (ifindex == 0) { 183 fprintf(stderr, "%s: ifindex %s\n", __func__, strerror(errno)); 184 return -errno; 185 } 186 187 rtattr_add_any(nh, IFLA_LINK, &ifindex, sizeof(ifindex)); 188 rtattr_add_any(nh, IFLA_ADDRESS, param_hwaddr_src, ETH_ALEN); 189 190 return 0; 191 } 192 193 static int opentap(const char *devname) 194 { 195 int ifindex; 196 char buf[256]; 197 int fd; 198 struct ifreq ifr; 199 200 ifindex = if_nametoindex(devname); 201 if (ifindex == 0) { 202 fprintf(stderr, "%s: ifindex %s\n", __func__, strerror(errno)); 203 return -errno; 204 } 205 206 sprintf(buf, "/dev/tap%d", ifindex); 207 fd = open(buf, O_RDWR | O_NONBLOCK); 208 if (fd < 0) { 209 fprintf(stderr, "%s: open %s\n", __func__, strerror(errno)); 210 return -errno; 211 } 212 213 memset(&ifr, 0, sizeof(ifr)); 214 strcpy(ifr.ifr_name, devname); 215 ifr.ifr_flags = IFF_TAP | IFF_NO_PI | IFF_VNET_HDR | IFF_MULTI_QUEUE; 216 if (ioctl(fd, TUNSETIFF, &ifr, sizeof(ifr)) < 0) 217 return -errno; 218 return fd; 219 } 220 221 size_t build_eth(uint8_t *buf, uint16_t proto) 222 { 223 struct ethhdr *eth = (struct ethhdr *)buf; 224 225 eth->h_proto = htons(proto); 226 memcpy(eth->h_source, param_hwaddr_src, ETH_ALEN); 227 memcpy(eth->h_dest, param_hwaddr_dest, ETH_ALEN); 228 229 return ETH_HLEN; 230 } 231 232 static uint32_t add_csum(const uint8_t *buf, int len) 233 { 234 uint32_t sum = 0; 235 uint16_t *sbuf = (uint16_t *)buf; 236 237 while (len > 1) { 238 sum += *sbuf++; 239 len -= 2; 240 } 241 242 if (len) 243 sum += *(uint8_t *)sbuf; 244 245 return sum; 246 } 247 248 static uint16_t finish_ip_csum(uint32_t sum) 249 { 250 uint16_t lo = sum & 0xffff; 251 uint16_t hi = sum >> 16; 252 253 return ~(lo + hi); 254 255 } 256 257 static uint16_t build_ip_csum(const uint8_t *buf, int len, 258 uint32_t sum) 259 { 260 sum += add_csum(buf, len); 261 return finish_ip_csum(sum); 262 } 263 264 static int build_ipv4_header(uint8_t *buf, int payload_len) 265 { 266 struct iphdr *iph = (struct iphdr *)buf; 267 268 iph->ihl = 5; 269 iph->version = 4; 270 iph->ttl = 8; 271 iph->tot_len = 272 htons(sizeof(*iph) + sizeof(struct udphdr) + payload_len); 273 iph->id = htons(1337); 274 iph->protocol = IPPROTO_UDP; 275 iph->saddr = htonl((172 << 24) | (17 << 16) | 2); 276 iph->daddr = htonl((172 << 24) | (17 << 16) | 1); 277 iph->check = build_ip_csum(buf, iph->ihl << 2, 0); 278 279 return iph->ihl << 2; 280 } 281 282 static int build_udp_packet(uint8_t *buf, int payload_len, bool csum_off) 283 { 284 const int ip4alen = sizeof(uint32_t); 285 struct udphdr *udph = (struct udphdr *)buf; 286 int len = sizeof(*udph) + payload_len; 287 uint32_t sum = 0; 288 289 udph->source = htons(22); 290 udph->dest = htons(58822); 291 udph->len = htons(len); 292 293 memset(buf + sizeof(struct udphdr), PKT_DATA, payload_len); 294 295 sum = add_csum(buf - 2 * ip4alen, 2 * ip4alen); 296 sum += htons(IPPROTO_UDP) + udph->len; 297 298 if (!csum_off) 299 sum += add_csum(buf, len); 300 301 udph->check = finish_ip_csum(sum); 302 303 return sizeof(*udph) + payload_len; 304 } 305 306 size_t build_test_packet_valid_udp_gso(uint8_t *buf, size_t payload_len) 307 { 308 uint8_t *cur = buf; 309 struct virtio_net_hdr *vh = (struct virtio_net_hdr *)buf; 310 311 vh->hdr_len = ETH_HLEN + sizeof(struct iphdr) + sizeof(struct udphdr); 312 vh->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM; 313 vh->csum_start = ETH_HLEN + sizeof(struct iphdr); 314 vh->csum_offset = __builtin_offsetof(struct udphdr, check); 315 vh->gso_type = VIRTIO_NET_HDR_GSO_UDP; 316 vh->gso_size = ETH_DATA_LEN - sizeof(struct iphdr); 317 cur += sizeof(*vh); 318 319 cur += build_eth(cur, ETH_P_IP); 320 cur += build_ipv4_header(cur, payload_len); 321 cur += build_udp_packet(cur, payload_len, true); 322 323 return cur - buf; 324 } 325 326 size_t build_test_packet_valid_udp_csum(uint8_t *buf, size_t payload_len) 327 { 328 uint8_t *cur = buf; 329 struct virtio_net_hdr *vh = (struct virtio_net_hdr *)buf; 330 331 vh->flags = VIRTIO_NET_HDR_F_DATA_VALID; 332 vh->gso_type = VIRTIO_NET_HDR_GSO_NONE; 333 cur += sizeof(*vh); 334 335 cur += build_eth(cur, ETH_P_IP); 336 cur += build_ipv4_header(cur, payload_len); 337 cur += build_udp_packet(cur, payload_len, false); 338 339 return cur - buf; 340 } 341 342 size_t build_test_packet_crash_tap_invalid_eth_proto(uint8_t *buf, 343 size_t payload_len) 344 { 345 uint8_t *cur = buf; 346 struct virtio_net_hdr *vh = (struct virtio_net_hdr *)buf; 347 348 vh->hdr_len = ETH_HLEN + sizeof(struct iphdr) + sizeof(struct udphdr); 349 vh->flags = 0; 350 vh->gso_type = VIRTIO_NET_HDR_GSO_UDP; 351 vh->gso_size = ETH_DATA_LEN - sizeof(struct iphdr); 352 cur += sizeof(*vh); 353 354 cur += build_eth(cur, 0); 355 cur += sizeof(struct iphdr) + sizeof(struct udphdr); 356 cur += build_ipv4_header(cur, payload_len); 357 cur += build_udp_packet(cur, payload_len, true); 358 cur += payload_len; 359 360 return cur - buf; 361 } 362 363 FIXTURE(tap) 364 { 365 int fd; 366 }; 367 368 FIXTURE_SETUP(tap) 369 { 370 int ret; 371 372 ret = dev_create(param_dev_dummy_name, "dummy", NULL, NULL); 373 EXPECT_EQ(ret, 0); 374 375 ret = dev_create(param_dev_tap_name, "macvtap", macvtap_fill_rtattr, 376 NULL); 377 EXPECT_EQ(ret, 0); 378 379 self->fd = opentap(param_dev_tap_name); 380 ASSERT_GE(self->fd, 0); 381 } 382 383 FIXTURE_TEARDOWN(tap) 384 { 385 int ret; 386 387 if (self->fd != -1) 388 close(self->fd); 389 390 ret = dev_delete(param_dev_tap_name); 391 EXPECT_EQ(ret, 0); 392 393 ret = dev_delete(param_dev_dummy_name); 394 EXPECT_EQ(ret, 0); 395 } 396 397 TEST_F(tap, test_packet_valid_udp_gso) 398 { 399 uint8_t pkt[TEST_PACKET_SZ]; 400 size_t off; 401 int ret; 402 403 memset(pkt, 0, sizeof(pkt)); 404 off = build_test_packet_valid_udp_gso(pkt, 1021); 405 ret = write(self->fd, pkt, off); 406 ASSERT_EQ(ret, off); 407 } 408 409 TEST_F(tap, test_packet_valid_udp_csum) 410 { 411 uint8_t pkt[TEST_PACKET_SZ]; 412 size_t off; 413 int ret; 414 415 memset(pkt, 0, sizeof(pkt)); 416 off = build_test_packet_valid_udp_csum(pkt, 1024); 417 ret = write(self->fd, pkt, off); 418 ASSERT_EQ(ret, off); 419 } 420 421 TEST_F(tap, test_packet_crash_tap_invalid_eth_proto) 422 { 423 uint8_t pkt[TEST_PACKET_SZ]; 424 size_t off; 425 int ret; 426 427 memset(pkt, 0, sizeof(pkt)); 428 off = build_test_packet_crash_tap_invalid_eth_proto(pkt, 1024); 429 ret = write(self->fd, pkt, off); 430 ASSERT_EQ(ret, -1); 431 ASSERT_EQ(errno, EINVAL); 432 } 433 434 TEST_HARNESS_MAIN 435