tools/testing/selftests/net/psock_snd.c

   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 <fcntl.h>
   9 #include <limits.h>
  10 #include <linux/filter.h>
  11 #include <linux/bpf.h>
  12 #include <linux/if_packet.h>
  13 #include <linux/if_vlan.h>
  14 #include <linux/virtio_net.h>
  15 #include <net/if.h>
  16 #include <net/ethernet.h>
  17 #include <netinet/ip.h>
  18 #include <netinet/udp.h>
  19 #include <poll.h>
  20 #include <sched.h>
  21 #include <stdbool.h>
  22 #include <stdint.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <sys/mman.h>
  27 #include <sys/socket.h>
  28 #include <sys/stat.h>
  29 #include <sys/types.h>
  30 #include <unistd.h>
  31
  32 #include "psock_lib.h"
  33
  34 static bool     cfg_use_bind;
  35 static bool     cfg_use_csum_off;
  36 static bool     cfg_use_csum_off_bad;
  37 static bool     cfg_use_dgram;
  38 static bool     cfg_use_gso;
  39 static bool     cfg_use_qdisc_bypass;
  40 static bool     cfg_use_vlan;
  41 static bool     cfg_use_vnet;
  42
  43 static char     *cfg_ifname = "lo";
  44 static int      cfg_mtu = 1500;
  45 static int      cfg_payload_len = DATA_LEN;
  46 static int      cfg_truncate_len = INT_MAX;
  47 static uint16_t cfg_port = 8000;
  48
  49 /* test sending up to max mtu + 1 */
  50 #define TEST_SZ (sizeof(struct virtio_net_hdr) + ETH_HLEN + ETH_MAX_MTU + 1)
  51
  52 static char tbuf[TEST_SZ], rbuf[TEST_SZ];
  53
  54 static unsigned long add_csum_hword(const uint16_t *start, int num_u16)
  55 {
  56         unsigned long sum = 0;
  57         int i;
  58
  59         for (i = 0; i < num_u16; i++)
  60                 sum += start[i];
  61
  62         return sum;
  63 }
  64
  65 static uint16_t build_ip_csum(const uint16_t *start, int num_u16,
  66                               unsigned long sum)
  67 {
  68         sum += add_csum_hword(start, num_u16);
  69
  70         while (sum >> 16)
  71                 sum = (sum & 0xffff) + (sum >> 16);
  72
  73         return ~sum;
  74 }
  75
  76 static int build_vnet_header(void *header)
  77 {
  78         struct virtio_net_hdr *vh = header;
  79
  80         vh->hdr_len = ETH_HLEN + sizeof(struct iphdr) + sizeof(struct udphdr);
  81
  82         if (cfg_use_csum_off) {
  83                 vh->flags |= VIRTIO_NET_HDR_F_NEEDS_CSUM;
  84                 vh->csum_start = ETH_HLEN + sizeof(struct iphdr);
  85                 vh->csum_offset = __builtin_offsetof(struct udphdr, check);
  86
  87                 /* position check field exactly one byte beyond end of packet */
  88                 if (cfg_use_csum_off_bad)
  89                         vh->csum_start += sizeof(struct udphdr) + cfg_payload_len -
  90                                           vh->csum_offset - 1;
  91         }
  92
  93         if (cfg_use_gso) {
  94                 vh->gso_type = VIRTIO_NET_HDR_GSO_UDP;
  95                 vh->gso_size = cfg_mtu - sizeof(struct iphdr);
  96         }
  97
  98         return sizeof(*vh);
  99 }
 100
 101 static int build_eth_header(void *header)
 102 {
 103         struct ethhdr *eth = header;
 104
 105         if (cfg_use_vlan) {
 106                 uint16_t *tag = header + ETH_HLEN;
 107
 108                 eth->h_proto = htons(ETH_P_8021Q);
 109                 tag[1] = htons(ETH_P_IP);
 110                 return ETH_HLEN + 4;
 111         }
 112
 113         eth->h_proto = htons(ETH_P_IP);
 114         return ETH_HLEN;
 115 }
 116
 117 static int build_ipv4_header(void *header, int payload_len)
 118 {
 119         struct iphdr *iph = header;
 120
 121         iph->ihl = 5;
 122         iph->version = 4;
 123         iph->ttl = 8;
 124         iph->tot_len = htons(sizeof(*iph) + sizeof(struct udphdr) + payload_len);
 125         iph->id = htons(1337);
 126         iph->protocol = IPPROTO_UDP;
 127         iph->saddr = htonl((172 << 24) | (17 << 16) | 2);
 128         iph->daddr = htonl((172 << 24) | (17 << 16) | 1);
 129         iph->check = build_ip_csum((void *) iph, iph->ihl << 1, 0);
 130
 131         return iph->ihl << 2;
 132 }
 133
 134 static int build_udp_header(void *header, int payload_len)
 135 {
 136         const int alen = sizeof(uint32_t);
 137         struct udphdr *udph = header;
 138         int len = sizeof(*udph) + payload_len;
 139
 140         udph->source = htons(9);
 141         udph->dest = htons(cfg_port);
 142         udph->len = htons(len);
 143
 144         if (cfg_use_csum_off)
 145                 udph->check = build_ip_csum(header - (2 * alen), alen,
 146                                             htons(IPPROTO_UDP) + udph->len);
 147         else
 148                 udph->check = 0;
 149
 150         return sizeof(*udph);
 151 }
 152
 153 static int build_packet(int payload_len)
 154 {
 155         int off = 0;
 156
 157         off += build_vnet_header(tbuf);
 158         off += build_eth_header(tbuf + off);
 159         off += build_ipv4_header(tbuf + off, payload_len);
 160         off += build_udp_header(tbuf + off, payload_len);
 161
 162         if (off + payload_len > sizeof(tbuf))
 163                 error(1, 0, "payload length exceeds max");
 164
 165         memset(tbuf + off, DATA_CHAR, payload_len);
 166
 167         return off + payload_len;
 168 }
 169
 170 static void do_bind(int fd)
 171 {
 172         struct sockaddr_ll laddr = {0};
 173
 174         laddr.sll_family = AF_PACKET;
 175         laddr.sll_protocol = htons(ETH_P_IP);
 176         laddr.sll_ifindex = if_nametoindex(cfg_ifname);
 177         if (!laddr.sll_ifindex)
 178                 error(1, errno, "if_nametoindex");
 179
 180         if (bind(fd, (void *)&laddr, sizeof(laddr)))
 181                 error(1, errno, "bind");
 182 }
 183
 184 static void do_send(int fd, char *buf, int len)
 185 {
 186         int ret;
 187
 188         if (!cfg_use_vnet) {
 189                 buf += sizeof(struct virtio_net_hdr);
 190                 len -= sizeof(struct virtio_net_hdr);
 191         }
 192         if (cfg_use_dgram) {
 193                 buf += ETH_HLEN;
 194                 len -= ETH_HLEN;
 195         }
 196
 197         if (cfg_use_bind) {
 198                 ret = write(fd, buf, len);
 199         } else {
 200                 struct sockaddr_ll laddr = {0};
 201
 202                 laddr.sll_protocol = htons(ETH_P_IP);
 203                 laddr.sll_ifindex = if_nametoindex(cfg_ifname);
 204                 if (!laddr.sll_ifindex)
 205                         error(1, errno, "if_nametoindex");
 206
 207                 ret = sendto(fd, buf, len, 0, (void *)&laddr, sizeof(laddr));
 208         }
 209
 210         if (ret == -1)
 211                 error(1, errno, "write");
 212         if (ret != len)
 213                 error(1, 0, "write: %u %u", ret, len);
 214
 215         fprintf(stderr, "tx: %u\n", ret);
 216 }
 217
 218 static int do_tx(void)
 219 {
 220         const int one = 1;
 221         int fd, len;
 222
 223         fd = socket(PF_PACKET, cfg_use_dgram ? SOCK_DGRAM : SOCK_RAW, 0);
 224         if (fd == -1)
 225                 error(1, errno, "socket t");
 226
 227         if (cfg_use_bind)
 228                 do_bind(fd);
 229
 230         if (cfg_use_qdisc_bypass &&
 231             setsockopt(fd, SOL_PACKET, PACKET_QDISC_BYPASS, &one, sizeof(one)))
 232                 error(1, errno, "setsockopt qdisc bypass");
 233
 234         if (cfg_use_vnet &&
 235             setsockopt(fd, SOL_PACKET, PACKET_VNET_HDR, &one, sizeof(one)))
 236                 error(1, errno, "setsockopt vnet");
 237
 238         len = build_packet(cfg_payload_len);
 239
 240         if (cfg_truncate_len < len)
 241                 len = cfg_truncate_len;
 242
 243         do_send(fd, tbuf, len);
 244
 245         if (close(fd))
 246                 error(1, errno, "close t");
 247
 248         return len;
 249 }
 250
 251 static int setup_rx(void)
 252 {
 253         struct timeval tv = { .tv_usec = 100 * 1000 };
 254         struct sockaddr_in raddr = {0};
 255         int fd;
 256
 257         fd = socket(PF_INET, SOCK_DGRAM, 0);
 258         if (fd == -1)
 259                 error(1, errno, "socket r");
 260
 261         if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)))
 262                 error(1, errno, "setsockopt rcv timeout");
 263
 264         raddr.sin_family = AF_INET;
 265         raddr.sin_port = htons(cfg_port);
 266         raddr.sin_addr.s_addr = htonl(INADDR_ANY);
 267
 268         if (bind(fd, (void *)&raddr, sizeof(raddr)))
 269                 error(1, errno, "bind r");
 270
 271         return fd;
 272 }
 273
 274 static void do_rx(int fd, int expected_len, char *expected)
 275 {
 276         int ret;
 277
 278         ret = recv(fd, rbuf, sizeof(rbuf), 0);
 279         if (ret == -1)
 280                 error(1, errno, "recv");
 281         if (ret != expected_len)
 282                 error(1, 0, "recv: %u != %u", ret, expected_len);
 283
 284         if (memcmp(rbuf, expected, ret))
 285                 error(1, 0, "recv: data mismatch");
 286
 287         fprintf(stderr, "rx: %u\n", ret);
 288 }
 289
 290 static int setup_sniffer(void)
 291 {
 292         struct timeval tv = { .tv_usec = 100 * 1000 };
 293         int fd;
 294
 295         fd = socket(PF_PACKET, SOCK_RAW, 0);
 296         if (fd == -1)
 297                 error(1, errno, "socket p");
 298
 299         if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)))
 300                 error(1, errno, "setsockopt rcv timeout");
 301
 302         pair_udp_setfilter(fd);
 303         do_bind(fd);
 304
 305         return fd;
 306 }
 307
 308 static void parse_opts(int argc, char **argv)
 309 {
 310         int c;
 311
 312         while ((c = getopt(argc, argv, "bcCdgl:qt:vV")) != -1) {
 313                 switch (c) {
 314                 case 'b':
 315                         cfg_use_bind = true;
 316                         break;
 317                 case 'c':
 318                         cfg_use_csum_off = true;
 319                         break;
 320                 case 'C':
 321                         cfg_use_csum_off_bad = true;
 322                         break;
 323                 case 'd':
 324                         cfg_use_dgram = true;
 325                         break;
 326                 case 'g':
 327                         cfg_use_gso = true;
 328                         break;
 329                 case 'l':
 330                         cfg_payload_len = strtoul(optarg, NULL, 0);
 331                         break;
 332                 case 'q':
 333                         cfg_use_qdisc_bypass = true;
 334                         break;
 335                 case 't':
 336                         cfg_truncate_len = strtoul(optarg, NULL, 0);
 337                         break;
 338                 case 'v':
 339                         cfg_use_vnet = true;
 340                         break;
 341                 case 'V':
 342                         cfg_use_vlan = true;
 343                         break;
 344                 default:
 345                         error(1, 0, "%s: parse error", argv[0]);
 346                 }
 347         }
 348
 349         if (cfg_use_vlan && cfg_use_dgram)
 350                 error(1, 0, "option vlan (-V) conflicts with dgram (-d)");
 351
 352         if (cfg_use_csum_off && !cfg_use_vnet)
 353                 error(1, 0, "option csum offload (-c) requires vnet (-v)");
 354
 355         if (cfg_use_csum_off_bad && !cfg_use_csum_off)
 356                 error(1, 0, "option csum bad (-C) requires csum offload (-c)");
 357
 358         if (cfg_use_gso && !cfg_use_csum_off)
 359                 error(1, 0, "option gso (-g) requires csum offload (-c)");
 360 }
 361
 362 static void run_test(void)
 363 {
 364         int fdr, fds, total_len;
 365
 366         fdr = setup_rx();
 367         fds = setup_sniffer();
 368
 369         total_len = do_tx();
 370
 371         /* BPF filter accepts only this length, vlan changes MAC */
 372         if (cfg_payload_len == DATA_LEN && !cfg_use_vlan)
 373                 do_rx(fds, total_len - sizeof(struct virtio_net_hdr),
 374                       tbuf + sizeof(struct virtio_net_hdr));
 375
 376         do_rx(fdr, cfg_payload_len, tbuf + total_len - cfg_payload_len);
 377
 378         if (close(fds))
 379                 error(1, errno, "close s");
 380         if (close(fdr))
 381                 error(1, errno, "close r");
 382 }
 383
 384 int main(int argc, char **argv)
 385 {
 386         parse_opts(argc, argv);
 387
 388         if (system("ip link set dev lo mtu 1500"))
 389                 error(1, errno, "ip link set mtu");
 390         if (system("ip addr add dev lo 172.17.0.1/24"))
 391                 error(1, errno, "ip addr add");
 392
 393         run_test();
 394
 395         fprintf(stderr, "OK\n\n");
 396         return 0;
 397 }