1// SPDX-License-Identifier: GPL-2.0
  2
  3/* Test hardware checksum offload: Rx + Tx, IPv4 + IPv6, TCP + UDP.
  4 *
  5 * The test runs on two machines to exercise the NIC. For this reason it
  6 * is not integrated in kselftests.
  7 *
  8 *     CMD=$((./csum -[46] -[tu] -S $SADDR -D $DADDR -[RT] -r 1 $EXTRA_ARGS))
  9 *
 10 * Rx:
 11 *
 12 * The sender sends packets with a known checksum field using PF_INET(6)
 13 * SOCK_RAW sockets.
 14 *
 15 * good packet: $CMD [-t]
 16 * bad packet:  $CMD [-t] -E
 17 *
 18 * The receiver reads UDP packets with a UDP socket. This is not an
 19 * option for TCP packets ('-t'). Optionally insert an iptables filter
 20 * to avoid these entering the real protocol stack.
 21 *
 22 * The receiver also reads all packets with a PF_PACKET socket, to
 23 * observe whether both good and bad packets arrive on the host. And to
 24 * read the optional TP_STATUS_CSUM_VALID bit. This requires setting
 25 * option PACKET_AUXDATA, and works only for CHECKSUM_UNNECESSARY.
 26 *
 27 * Tx:
 28 *
 29 * The sender needs to build CHECKSUM_PARTIAL packets to exercise tx
 30 * checksum offload.
 31 *
 32 * The sender can sends packets with a UDP socket.
 33 *
 34 * Optionally crafts a packet that sums up to zero to verify that the
 35 * device writes negative zero 0xFFFF in this case to distinguish from
 36 * 0x0000 (checksum disabled), as required by RFC 768. Hit this case
 37 * by choosing a specific source port.
 38 *
 39 * good packet: $CMD -U
 40 * zero csum:   $CMD -U -Z
 41 *
 42 * The sender can also build packets with PF_PACKET with PACKET_VNET_HDR,
 43 * to cover more protocols. PF_PACKET requires passing src and dst mac
 44 * addresses.
 45 *
 46 * good packet: $CMD -s $smac -d $dmac -p [-t]
 47 *
 48 * Argument '-z' sends UDP packets with a 0x000 checksum disabled field,
 49 * to verify that the NIC passes these packets unmodified.
 50 *
 51 * Argument '-e' adds a transport mode encapsulation header between
 52 * network and transport header. This will fail for devices that parse
 53 *  headers. Should work on devices that implement protocol agnostic tx
 54 * checksum offload (NETIF_F_HW_CSUM).
 55 *
 56 * Argument '-r $SEED' optionally randomizes header, payload and length
 57 * to increase coverage between packets sent. SEED 1 further chooses a
 58 * different seed for each run (and logs this for reproducibility). It
 59 * is advised to enable this for extra coverage in continuous testing.
 60 */
 61
 62#define _GNU_SOURCE
 63
 64#include <arpa/inet.h>
 65#include <asm/byteorder.h>
 66#include <errno.h>
 67#include <error.h>
 68#include <linux/filter.h>
 69#include <linux/if_packet.h>
 70#include <linux/ipv6.h>
 71#include <linux/virtio_net.h>
 72#include <net/ethernet.h>
 73#include <net/if.h>
 74#include <netinet/if_ether.h>
 75#include <netinet/in.h>
 76#include <netinet/ip.h>
 77#include <netinet/ip6.h>
 78#include <netinet/tcp.h>
 79#include <netinet/udp.h>
 80#include <poll.h>
 81#include <sched.h>
 82#include <stdbool.h>
 83#include <stddef.h>
 84#include <stdint.h>
 85#include <stdio.h>
 86#include <stdlib.h>
 87#include <string.h>
 88#include <sys/socket.h>
 89#include <sys/stat.h>
 90#include <sys/time.h>
 91#include <sys/types.h>
 92#include <unistd.h>
 93
 94static bool cfg_bad_csum;
 95static int cfg_family = PF_INET6;
 96static int cfg_num_pkt = 4;
 97static bool cfg_do_rx = true;
 98static bool cfg_do_tx = true;
 99static bool cfg_encap;
100static char *cfg_ifname = "eth0";
101static char *cfg_mac_dst;
102static char *cfg_mac_src;
103static int cfg_proto = IPPROTO_UDP;
104static int cfg_payload_char = 'a';
105static int cfg_payload_len = 100;
106static uint16_t cfg_port_dst = 34000;
107static uint16_t cfg_port_src = 33000;
108static uint16_t cfg_port_src_encap = 33001;
109static unsigned int cfg_random_seed;
110static int cfg_rcvbuf = 1 << 22;	/* be able to queue large cfg_num_pkt */
111static bool cfg_send_pfpacket;
112static bool cfg_send_udp;
113static int cfg_timeout_ms = 2000;
114static bool cfg_zero_disable; /* skip checksum: set to zero (udp only) */
115static bool cfg_zero_sum;     /* create packet that adds up to zero */
116
117static struct sockaddr_in cfg_daddr4 = {.sin_family = AF_INET};
118static struct sockaddr_in cfg_saddr4 = {.sin_family = AF_INET};
119static struct sockaddr_in6 cfg_daddr6 = {.sin6_family = AF_INET6};
120static struct sockaddr_in6 cfg_saddr6 = {.sin6_family = AF_INET6};
121
122#define ENC_HEADER_LEN	(sizeof(struct udphdr) + sizeof(struct udp_encap_hdr))
123#define MAX_HEADER_LEN	(sizeof(struct ipv6hdr) + ENC_HEADER_LEN + sizeof(struct tcphdr))
124#define MAX_PAYLOAD_LEN 1024
125
126/* Trivial demo encap. Stand-in for transport layer protocols like ESP or PSP */
127struct udp_encap_hdr {
128	uint8_t nexthdr;
129	uint8_t padding[3];
130};
131
132/* Ipaddrs, for pseudo csum. Global var is ugly, pass through funcs was worse */
133static void *iph_addr_p;
134
135static unsigned long gettimeofday_ms(void)
136{
137	struct timeval tv;
138
139	gettimeofday(&tv, NULL);
140	return (tv.tv_sec * 1000UL) + (tv.tv_usec / 1000UL);
141}
142
143static uint32_t checksum_nofold(char *data, size_t len, uint32_t sum)
144{
145	uint16_t *words = (uint16_t *)data;
146	int i;
147
148	for (i = 0; i < len / 2; i++)
149		sum += words[i];
150
151	if (len & 1)
152		sum += ((unsigned char *)data)[len - 1];
153
154	return sum;
155}
156
157static uint16_t checksum_fold(void *data, size_t len, uint32_t sum)
158{
159	sum = checksum_nofold(data, len, sum);
160
161	while (sum > 0xFFFF)
162		sum = (sum & 0xFFFF) + (sum >> 16);
163
164	return ~sum;
165}
166
167static uint16_t checksum(void *th, uint16_t proto, size_t len)
168{
169	uint32_t sum;
170	int alen;
171
172	alen = cfg_family == PF_INET6 ? 32 : 8;
173
174	sum = checksum_nofold(iph_addr_p, alen, 0);
175	sum += htons(proto);
176	sum += htons(len);
177
178	/* With CHECKSUM_PARTIAL kernel expects non-inverted pseudo csum */
179	if (cfg_do_tx && cfg_send_pfpacket)
180		return ~checksum_fold(NULL, 0, sum);
181	else
182		return checksum_fold(th, len, sum);
183}
184
185static void *build_packet_ipv4(void *_iph, uint8_t proto, unsigned int len)
186{
187	struct iphdr *iph = _iph;
188
189	memset(iph, 0, sizeof(*iph));
190
191	iph->version = 4;
192	iph->ihl = 5;
193	iph->ttl = 8;
194	iph->protocol = proto;
195	iph->saddr = cfg_saddr4.sin_addr.s_addr;
196	iph->daddr = cfg_daddr4.sin_addr.s_addr;
197	iph->tot_len = htons(sizeof(*iph) + len);
198	iph->check = checksum_fold(iph, sizeof(*iph), 0);
199
200	iph_addr_p = &iph->saddr;
201
202	return iph + 1;
203}
204
205static void *build_packet_ipv6(void *_ip6h, uint8_t proto, unsigned int len)
206{
207	struct ipv6hdr *ip6h = _ip6h;
208
209	memset(ip6h, 0, sizeof(*ip6h));
210
211	ip6h->version = 6;
212	ip6h->payload_len = htons(len);
213	ip6h->nexthdr = proto;
214	ip6h->hop_limit = 64;
215	ip6h->saddr = cfg_saddr6.sin6_addr;
216	ip6h->daddr = cfg_daddr6.sin6_addr;
217
218	iph_addr_p = &ip6h->saddr;
219
220	return ip6h + 1;
221}
222
223static void *build_packet_udp(void *_uh)
224{
225	struct udphdr *uh = _uh;
226
227	uh->source = htons(cfg_port_src);
228	uh->dest = htons(cfg_port_dst);
229	uh->len = htons(sizeof(*uh) + cfg_payload_len);
230	uh->check = 0;
231
232	/* choose source port so that uh->check adds up to zero */
233	if (cfg_zero_sum) {
234		uh->source = 0;
235		uh->source = checksum(uh, IPPROTO_UDP, sizeof(*uh) + cfg_payload_len);
236
237		fprintf(stderr, "tx: changing sport: %hu -> %hu\n",
238			cfg_port_src, ntohs(uh->source));
239		cfg_port_src = ntohs(uh->source);
240	}
241
242	if (cfg_zero_disable)
243		uh->check = 0;
244	else
245		uh->check = checksum(uh, IPPROTO_UDP, sizeof(*uh) + cfg_payload_len);
246
247	if (cfg_bad_csum)
248		uh->check = ~uh->check;
249
250	fprintf(stderr, "tx: sending checksum: 0x%x\n", uh->check);
251	return uh + 1;
252}
253
254static void *build_packet_tcp(void *_th)
255{
256	struct tcphdr *th = _th;
257
258	th->source = htons(cfg_port_src);
259	th->dest = htons(cfg_port_dst);
260	th->doff = 5;
261	th->check = 0;
262
263	th->check = checksum(th, IPPROTO_TCP, sizeof(*th) + cfg_payload_len);
264
265	if (cfg_bad_csum)
266		th->check = ~th->check;
267
268	fprintf(stderr, "tx: sending checksum: 0x%x\n", th->check);
269	return th + 1;
270}
271
272static char *build_packet_udp_encap(void *_uh)
273{
274	struct udphdr *uh = _uh;
275	struct udp_encap_hdr *eh = _uh + sizeof(*uh);
276
277	/* outer dst == inner dst, to simplify BPF filter
278	 * outer src != inner src, to demultiplex on recv
279	 */
280	uh->dest = htons(cfg_port_dst);
281	uh->source = htons(cfg_port_src_encap);
282	uh->check = 0;
283	uh->len = htons(sizeof(*uh) +
284			sizeof(*eh) +
285			sizeof(struct tcphdr) +
286			cfg_payload_len);
287
288	eh->nexthdr = IPPROTO_TCP;
289
290	return build_packet_tcp(eh + 1);
291}
292
293static char *build_packet(char *buf, int max_len, int *len)
294{
295	uint8_t proto;
296	char *off;
297	int tlen;
298
299	if (cfg_random_seed) {
300		int *buf32 = (void *)buf;
301		int i;
302
303		for (i = 0; i < (max_len / sizeof(int)); i++)
304			buf32[i] = rand();
305	} else {
306		memset(buf, cfg_payload_char, max_len);
307	}
308
309	if (cfg_proto == IPPROTO_UDP)
310		tlen = sizeof(struct udphdr) + cfg_payload_len;
311	else
312		tlen = sizeof(struct tcphdr) + cfg_payload_len;
313
314	if (cfg_encap) {
315		proto = IPPROTO_UDP;
316		tlen += ENC_HEADER_LEN;
317	} else {
318		proto = cfg_proto;
319	}
320
321	if (cfg_family == PF_INET)
322		off = build_packet_ipv4(buf, proto, tlen);
323	else
324		off = build_packet_ipv6(buf, proto, tlen);
325
326	if (cfg_encap)
327		off = build_packet_udp_encap(off);
328	else if (cfg_proto == IPPROTO_UDP)
329		off = build_packet_udp(off);
330	else
331		off = build_packet_tcp(off);
332
333	/* only pass the payload, but still compute headers for cfg_zero_sum */
334	if (cfg_send_udp) {
335		*len = cfg_payload_len;
336		return off;
337	}
338
339	*len = off - buf + cfg_payload_len;
340	return buf;
341}
342
343static int open_inet(int ipproto, int protocol)
344{
345	int fd;
346
347	fd = socket(cfg_family, ipproto, protocol);
348	if (fd == -1)
349		error(1, errno, "socket inet");
350
351	if (cfg_family == PF_INET6) {
352		/* may have been updated by cfg_zero_sum */
353		cfg_saddr6.sin6_port = htons(cfg_port_src);
354
355		if (bind(fd, (void *)&cfg_saddr6, sizeof(cfg_saddr6)))
356			error(1, errno, "bind dgram 6");
357		if (connect(fd, (void *)&cfg_daddr6, sizeof(cfg_daddr6)))
358			error(1, errno, "connect dgram 6");
359	} else {
360		/* may have been updated by cfg_zero_sum */
361		cfg_saddr4.sin_port = htons(cfg_port_src);
362
363		if (bind(fd, (void *)&cfg_saddr4, sizeof(cfg_saddr4)))
364			error(1, errno, "bind dgram 4");
365		if (connect(fd, (void *)&cfg_daddr4, sizeof(cfg_daddr4)))
366			error(1, errno, "connect dgram 4");
367	}
368
369	return fd;
370}
371
372static int open_packet(void)
373{
374	int fd, one = 1;
375
376	fd = socket(PF_PACKET, SOCK_RAW, 0);
377	if (fd == -1)
378		error(1, errno, "socket packet");
379
380	if (setsockopt(fd, SOL_PACKET, PACKET_VNET_HDR, &one, sizeof(one)))
381		error(1, errno, "setsockopt packet_vnet_ndr");
382
383	return fd;
384}
385
386static void send_inet(int fd, const char *buf, int len)
387{
388	int ret;
389
390	ret = write(fd, buf, len);
391	if (ret == -1)
392		error(1, errno, "write");
393	if (ret != len)
394		error(1, 0, "write: %d", ret);
395}
396
397static void eth_str_to_addr(const char *str, unsigned char *eth)
398{
399	if (sscanf(str, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
400		   &eth[0], &eth[1], &eth[2], &eth[3], &eth[4], &eth[5]) != 6)
401		error(1, 0, "cannot parse mac addr %s", str);
402}
403
404static void send_packet(int fd, const char *buf, int len)
405{
406	struct virtio_net_hdr vh = {0};
407	struct sockaddr_ll addr = {0};
408	struct msghdr msg = {0};
409	struct ethhdr eth;
410	struct iovec iov[3];
411	int ret;
412
413	addr.sll_family = AF_PACKET;
414	addr.sll_halen = ETH_ALEN;
415	addr.sll_ifindex = if_nametoindex(cfg_ifname);
416	if (!addr.sll_ifindex)
417		error(1, errno, "if_nametoindex %s", cfg_ifname);
418
419	vh.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
420	if (cfg_family == PF_INET6) {
421		vh.csum_start = sizeof(struct ethhdr) + sizeof(struct ipv6hdr);
422		addr.sll_protocol = htons(ETH_P_IPV6);
423	} else {
424		vh.csum_start = sizeof(struct ethhdr) + sizeof(struct iphdr);
425		addr.sll_protocol = htons(ETH_P_IP);
426	}
427
428	if (cfg_encap)
429		vh.csum_start += ENC_HEADER_LEN;
430
431	if (cfg_proto == IPPROTO_TCP) {
432		vh.csum_offset = __builtin_offsetof(struct tcphdr, check);
433		vh.hdr_len = vh.csum_start + sizeof(struct tcphdr);
434	} else {
435		vh.csum_offset = __builtin_offsetof(struct udphdr, check);
436		vh.hdr_len = vh.csum_start + sizeof(struct udphdr);
437	}
438
439	eth_str_to_addr(cfg_mac_src, eth.h_source);
440	eth_str_to_addr(cfg_mac_dst, eth.h_dest);
441	eth.h_proto = addr.sll_protocol;
442
443	iov[0].iov_base = &vh;
444	iov[0].iov_len = sizeof(vh);
445
446	iov[1].iov_base = &eth;
447	iov[1].iov_len = sizeof(eth);
448
449	iov[2].iov_base = (void *)buf;
450	iov[2].iov_len = len;
451
452	msg.msg_iov = iov;
453	msg.msg_iovlen = sizeof(iov) / sizeof(iov[0]);
454
455	msg.msg_name = &addr;
456	msg.msg_namelen = sizeof(addr);
457
458	ret = sendmsg(fd, &msg, 0);
459	if (ret == -1)
460		error(1, errno, "sendmsg packet");
461	if (ret != sizeof(vh) + sizeof(eth) + len)
462		error(1, errno, "sendmsg packet: %u", ret);
463}
464
465static int recv_prepare_udp(void)
466{
467	int fd;
468
469	fd = socket(cfg_family, SOCK_DGRAM, 0);
470	if (fd == -1)
471		error(1, errno, "socket r");
472
473	if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF,
474		       &cfg_rcvbuf, sizeof(cfg_rcvbuf)))
475		error(1, errno, "setsockopt SO_RCVBUF r");
476
477	if (cfg_family == PF_INET6) {
478		if (bind(fd, (void *)&cfg_daddr6, sizeof(cfg_daddr6)))
479			error(1, errno, "bind r");
480	} else {
481		if (bind(fd, (void *)&cfg_daddr4, sizeof(cfg_daddr4)))
482			error(1, errno, "bind r");
483	}
484
485	return fd;
486}
487
488/* Filter out all traffic that is not cfg_proto with our destination port.
489 *
490 * Otherwise background noise may cause PF_PACKET receive queue overflow,
491 * dropping the expected packets and failing the test.
492 */
493static void __recv_prepare_packet_filter(int fd, int off_nexthdr, int off_dport)
494{
495	struct sock_filter filter[] = {
496		BPF_STMT(BPF_LD + BPF_B + BPF_ABS, SKF_AD_OFF + SKF_AD_PKTTYPE),
497		BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, PACKET_HOST, 0, 4),
498		BPF_STMT(BPF_LD + BPF_B + BPF_ABS, off_nexthdr),
499		BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, cfg_encap ? IPPROTO_UDP : cfg_proto, 0, 2),
500		BPF_STMT(BPF_LD + BPF_H + BPF_ABS, off_dport),
501		BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, cfg_port_dst, 1, 0),
502		BPF_STMT(BPF_RET + BPF_K, 0),
503		BPF_STMT(BPF_RET + BPF_K, 0xFFFF),
504	};
505	struct sock_fprog prog = {};
506
507	prog.filter = filter;
508	prog.len = sizeof(filter) / sizeof(struct sock_filter);
509	if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog)))
510		error(1, errno, "setsockopt filter");
511}
512
513static void recv_prepare_packet_filter(int fd)
514{
515	const int off_dport = offsetof(struct tcphdr, dest); /* same for udp */
516
517	if (cfg_family == AF_INET)
518		__recv_prepare_packet_filter(fd, offsetof(struct iphdr, protocol),
519					     sizeof(struct iphdr) + off_dport);
520	else
521		__recv_prepare_packet_filter(fd, offsetof(struct ipv6hdr, nexthdr),
522					     sizeof(struct ipv6hdr) + off_dport);
523}
524
525static void recv_prepare_packet_bind(int fd)
526{
527	struct sockaddr_ll laddr = {0};
528
529	laddr.sll_family = AF_PACKET;
530
531	if (cfg_family == PF_INET)
532		laddr.sll_protocol = htons(ETH_P_IP);
533	else
534		laddr.sll_protocol = htons(ETH_P_IPV6);
535
536	laddr.sll_ifindex = if_nametoindex(cfg_ifname);
537	if (!laddr.sll_ifindex)
538		error(1, 0, "if_nametoindex %s", cfg_ifname);
539
540	if (bind(fd, (void *)&laddr, sizeof(laddr)))
541		error(1, errno, "bind pf_packet");
542}
543
544static int recv_prepare_packet(void)
545{
546	int fd, one = 1;
547
548	fd = socket(PF_PACKET, SOCK_DGRAM, 0);
549	if (fd == -1)
550		error(1, errno, "socket p");
551
552	if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF,
553		       &cfg_rcvbuf, sizeof(cfg_rcvbuf)))
554		error(1, errno, "setsockopt SO_RCVBUF p");
555
556	/* enable auxdata to recv checksum status (valid vs unknown) */
557	if (setsockopt(fd, SOL_PACKET, PACKET_AUXDATA, &one, sizeof(one)))
558		error(1, errno, "setsockopt auxdata");
559
560	/* install filter to restrict packet flow to match */
561	recv_prepare_packet_filter(fd);
562
563	/* bind to address family to start packet flow */
564	recv_prepare_packet_bind(fd);
565
566	return fd;
567}
568
569static int recv_udp(int fd)
570{
571	static char buf[MAX_PAYLOAD_LEN];
572	int ret, count = 0;
573
574	while (1) {
575		ret = recv(fd, buf, sizeof(buf), MSG_DONTWAIT);
576		if (ret == -1 && errno == EAGAIN)
577			break;
578		if (ret == -1)
579			error(1, errno, "recv r");
580
581		fprintf(stderr, "rx: udp: len=%u\n", ret);
582		count++;
583	}
584
585	return count;
586}
587
588static int recv_verify_csum(void *th, int len, uint16_t sport, uint16_t csum_field)
589{
590	uint16_t csum;
591
592	csum = checksum(th, cfg_proto, len);
593
594	fprintf(stderr, "rx: pkt: sport=%hu len=%u csum=0x%hx verify=0x%hx\n",
595		sport, len, csum_field, csum);
596
597	/* csum must be zero unless cfg_bad_csum indicates bad csum */
598	if (csum && !cfg_bad_csum) {
599		fprintf(stderr, "pkt: bad csum\n");
600		return 1;
601	} else if (cfg_bad_csum && !csum) {
602		fprintf(stderr, "pkt: good csum, while bad expected\n");
603		return 1;
604	}
605
606	if (cfg_zero_sum && csum_field != 0xFFFF) {
607		fprintf(stderr, "pkt: zero csum: field should be 0xFFFF, is 0x%hx\n", csum_field);
608		return 1;
609	}
610
611	return 0;
612}
613
614static int recv_verify_packet_tcp(void *th, int len)
615{
616	struct tcphdr *tcph = th;
617
618	if (len < sizeof(*tcph) || tcph->dest != htons(cfg_port_dst))
619		return -1;
620
621	return recv_verify_csum(th, len, ntohs(tcph->source), tcph->check);
622}
623
624static int recv_verify_packet_udp_encap(void *th, int len)
625{
626	struct udp_encap_hdr *eh = th;
627
628	if (len < sizeof(*eh) || eh->nexthdr != IPPROTO_TCP)
629		return -1;
630
631	return recv_verify_packet_tcp(eh + 1, len - sizeof(*eh));
632}
633
634static int recv_verify_packet_udp(void *th, int len)
635{
636	struct udphdr *udph = th;
637
638	if (len < sizeof(*udph))
639		return -1;
640
641	if (udph->dest != htons(cfg_port_dst))
642		return -1;
643
644	if (udph->source == htons(cfg_port_src_encap))
645		return recv_verify_packet_udp_encap(udph + 1,
646						    len - sizeof(*udph));
647
648	return recv_verify_csum(th, len, ntohs(udph->source), udph->check);
649}
650
651static int recv_verify_packet_ipv4(void *nh, int len)
652{
653	struct iphdr *iph = nh;
654	uint16_t proto = cfg_encap ? IPPROTO_UDP : cfg_proto;
655
656	if (len < sizeof(*iph) || iph->protocol != proto)
657		return -1;
658
659	iph_addr_p = &iph->saddr;
660	if (proto == IPPROTO_TCP)
661		return recv_verify_packet_tcp(iph + 1, len - sizeof(*iph));
662	else
663		return recv_verify_packet_udp(iph + 1, len - sizeof(*iph));
664}
665
666static int recv_verify_packet_ipv6(void *nh, int len)
667{
668	struct ipv6hdr *ip6h = nh;
669	uint16_t proto = cfg_encap ? IPPROTO_UDP : cfg_proto;
670
671	if (len < sizeof(*ip6h) || ip6h->nexthdr != proto)
672		return -1;
673
674	iph_addr_p = &ip6h->saddr;
675
676	if (proto == IPPROTO_TCP)
677		return recv_verify_packet_tcp(ip6h + 1, len - sizeof(*ip6h));
678	else
679		return recv_verify_packet_udp(ip6h + 1, len - sizeof(*ip6h));
680}
681
682/* return whether auxdata includes TP_STATUS_CSUM_VALID */
683static bool recv_verify_packet_csum(struct msghdr *msg)
684{
685	struct tpacket_auxdata *aux = NULL;
686	struct cmsghdr *cm;
687
688	if (msg->msg_flags & MSG_CTRUNC)
689		error(1, 0, "cmsg: truncated");
690
691	for (cm = CMSG_FIRSTHDR(msg); cm; cm = CMSG_NXTHDR(msg, cm)) {
692		if (cm->cmsg_level != SOL_PACKET ||
693		    cm->cmsg_type != PACKET_AUXDATA)
694			error(1, 0, "cmsg: level=%d type=%d\n",
695			      cm->cmsg_level, cm->cmsg_type);
696
697		if (cm->cmsg_len != CMSG_LEN(sizeof(struct tpacket_auxdata)))
698			error(1, 0, "cmsg: len=%lu expected=%lu",
699			      cm->cmsg_len, CMSG_LEN(sizeof(struct tpacket_auxdata)));
700
701		aux = (void *)CMSG_DATA(cm);
702	}
703
704	if (!aux)
705		error(1, 0, "cmsg: no auxdata");
706
707	return aux->tp_status & TP_STATUS_CSUM_VALID;
708}
709
710static int recv_packet(int fd)
711{
712	static char _buf[MAX_HEADER_LEN + MAX_PAYLOAD_LEN];
713	unsigned long total = 0, bad_csums = 0, bad_validations = 0;
714	char ctrl[CMSG_SPACE(sizeof(struct tpacket_auxdata))];
715	struct pkt *buf = (void *)_buf;
716	struct msghdr msg = {0};
717	struct iovec iov;
718	int len, ret;
719
720	iov.iov_base = _buf;
721	iov.iov_len = sizeof(_buf);
722
723	msg.msg_iov = &iov;
724	msg.msg_iovlen = 1;
725
726	msg.msg_control = ctrl;
727	msg.msg_controllen = sizeof(ctrl);
728
729	while (1) {
730		msg.msg_flags = 0;
731
732		len = recvmsg(fd, &msg, MSG_DONTWAIT);
733		if (len == -1 && errno == EAGAIN)
734			break;
735		if (len == -1)
736			error(1, errno, "recv p");
737
738		if (cfg_family == PF_INET6)
739			ret = recv_verify_packet_ipv6(buf, len);
740		else
741			ret = recv_verify_packet_ipv4(buf, len);
742
743		if (ret == -1 /* skip: non-matching */)
744			continue;
745
746		total++;
747		if (ret == 1)
748			bad_csums++;
749
750		/* Fail if kernel returns valid for known bad csum.
751		 * Do not fail if kernel does not validate a good csum:
752		 * Absence of validation does not imply invalid.
753		 */
754		if (recv_verify_packet_csum(&msg) && cfg_bad_csum) {
755			fprintf(stderr, "cmsg: expected bad csum, pf_packet returns valid\n");
756			bad_validations++;
757		}
758	}
759
760	if (bad_csums || bad_validations)
761		error(1, 0, "rx: errors at pf_packet: total=%lu bad_csums=%lu bad_valids=%lu\n",
762		      total, bad_csums, bad_validations);
763
764	return total;
765}
766
767static void parse_args(int argc, char *const argv[])
768{
769	const char *daddr = NULL, *saddr = NULL;
770	int c;
771
772	while ((c = getopt(argc, argv, "46d:D:eEi:l:L:n:r:PRs:S:tTuUzZ")) != -1) {
773		switch (c) {
774		case '4':
775			cfg_family = PF_INET;
776			break;
777		case '6':
778			cfg_family = PF_INET6;
779			break;
780		case 'd':
781			cfg_mac_dst = optarg;
782			break;
783		case 'D':
784			daddr = optarg;
785			break;
786		case 'e':
787			cfg_encap = true;
788			break;
789		case 'E':
790			cfg_bad_csum = true;
791			break;
792		case 'i':
793			cfg_ifname = optarg;
794			break;
795		case 'l':
796			cfg_payload_len = strtol(optarg, NULL, 0);
797			break;
798		case 'L':
799			cfg_timeout_ms = strtol(optarg, NULL, 0) * 1000;
800			break;
801		case 'n':
802			cfg_num_pkt = strtol(optarg, NULL, 0);
803			break;
804		case 'r':
805			cfg_random_seed = strtol(optarg, NULL, 0);
806			break;
807		case 'P':
808			cfg_send_pfpacket = true;
809			break;
810		case 'R':
811			/* only Rx: used with two machine tests */
812			cfg_do_tx = false;
813			break;
814		case 's':
815			cfg_mac_src = optarg;
816			break;
817		case 'S':
818			saddr = optarg;
819			break;
820		case 't':
821			cfg_proto = IPPROTO_TCP;
822			break;
823		case 'T':
824			/* only Tx: used with two machine tests */
825			cfg_do_rx = false;
826			break;
827		case 'u':
828			cfg_proto = IPPROTO_UDP;
829			break;
830		case 'U':
831			/* send using real udp socket,
832			 * to exercise tx checksum offload
833			 */
834			cfg_send_udp = true;
835			break;
836		case 'z':
837			cfg_zero_disable = true;
838			break;
839		case 'Z':
840			cfg_zero_sum = true;
841			break;
842		default:
843			error(1, 0, "unknown arg %c", c);
844		}
845	}
846
847	if (!daddr || !saddr)
848		error(1, 0, "Must pass -D <daddr> and -S <saddr>");
849
850	if (cfg_do_tx && cfg_send_pfpacket && (!cfg_mac_src || !cfg_mac_dst))
851		error(1, 0, "Transmit with pf_packet requires mac addresses");
852
853	if (cfg_payload_len > MAX_PAYLOAD_LEN)
854		error(1, 0, "Payload length exceeds max");
855
856	if (cfg_proto != IPPROTO_UDP && (cfg_zero_sum || cfg_zero_disable))
857		error(1, 0, "Only UDP supports zero csum");
858
859	if (cfg_zero_sum && !cfg_send_udp)
860		error(1, 0, "Zero checksum conversion requires -U for tx csum offload");
861	if (cfg_zero_sum && cfg_bad_csum)
862		error(1, 0, "Cannot combine zero checksum conversion and invalid checksum");
863	if (cfg_zero_sum && cfg_random_seed)
864		error(1, 0, "Cannot combine zero checksum conversion with randomization");
865
866	if (cfg_family == PF_INET6) {
867		cfg_saddr6.sin6_port = htons(cfg_port_src);
868		cfg_daddr6.sin6_port = htons(cfg_port_dst);
869
870		if (inet_pton(cfg_family, daddr, &cfg_daddr6.sin6_addr) != 1)
871			error(1, errno, "Cannot parse ipv6 -D");
872		if (inet_pton(cfg_family, saddr, &cfg_saddr6.sin6_addr) != 1)
873			error(1, errno, "Cannot parse ipv6 -S");
874	} else {
875		cfg_saddr4.sin_port = htons(cfg_port_src);
876		cfg_daddr4.sin_port = htons(cfg_port_dst);
877
878		if (inet_pton(cfg_family, daddr, &cfg_daddr4.sin_addr) != 1)
879			error(1, errno, "Cannot parse ipv4 -D");
880		if (inet_pton(cfg_family, saddr, &cfg_saddr4.sin_addr) != 1)
881			error(1, errno, "Cannot parse ipv4 -S");
882	}
883
884	if (cfg_do_tx && cfg_random_seed) {
885		/* special case: time-based seed */
886		if (cfg_random_seed == 1)
887			cfg_random_seed = (unsigned int)gettimeofday_ms();
888		srand(cfg_random_seed);
889		fprintf(stderr, "randomization seed: %u\n", cfg_random_seed);
890	}
891}
892
893static void do_tx(void)
894{
895	static char _buf[MAX_HEADER_LEN + MAX_PAYLOAD_LEN];
896	char *buf;
897	int fd, len, i;
898
899	buf = build_packet(_buf, sizeof(_buf), &len);
900
901	if (cfg_send_pfpacket)
902		fd = open_packet();
903	else if (cfg_send_udp)
904		fd = open_inet(SOCK_DGRAM, 0);
905	else
906		fd = open_inet(SOCK_RAW, IPPROTO_RAW);
907
908	for (i = 0; i < cfg_num_pkt; i++) {
909		if (cfg_send_pfpacket)
910			send_packet(fd, buf, len);
911		else
912			send_inet(fd, buf, len);
913
914		/* randomize each packet individually to increase coverage */
915		if (cfg_random_seed) {
916			cfg_payload_len = rand() % MAX_PAYLOAD_LEN;
917			buf = build_packet(_buf, sizeof(_buf), &len);
918		}
919	}
920
921	if (close(fd))
922		error(1, errno, "close tx");
923}
924
925static void do_rx(int fdp, int fdr)
926{
927	unsigned long count_udp = 0, count_pkt = 0;
928	long tleft, tstop;
929	struct pollfd pfd;
930
931	tstop = gettimeofday_ms() + cfg_timeout_ms;
932	tleft = cfg_timeout_ms;
933
934	do {
935		pfd.events = POLLIN;
936		pfd.fd = fdp;
937		if (poll(&pfd, 1, tleft) == -1)
938			error(1, errno, "poll");
939
940		if (pfd.revents & POLLIN)
941			count_pkt += recv_packet(fdp);
942
943		if (cfg_proto == IPPROTO_UDP)
944			count_udp += recv_udp(fdr);
945
946		tleft = tstop - gettimeofday_ms();
947	} while (tleft > 0);
948
949	if (close(fdr))
950		error(1, errno, "close r");
951	if (close(fdp))
952		error(1, errno, "close p");
953
954	if (count_pkt < cfg_num_pkt)
955		error(1, 0, "rx: missing packets at pf_packet: %lu < %u",
956		      count_pkt, cfg_num_pkt);
957
958	if (cfg_proto == IPPROTO_UDP) {
959		if (cfg_bad_csum && count_udp)
960			error(1, 0, "rx: unexpected packets at udp");
961		if (!cfg_bad_csum && !count_udp)
962			error(1, 0, "rx: missing packets at udp");
963	}
964}
965
966int main(int argc, char *const argv[])
967{
968	int fdp = -1, fdr = -1;		/* -1 to silence -Wmaybe-uninitialized */
969
970	parse_args(argc, argv);
971
972	/* open receive sockets before transmitting */
973	if (cfg_do_rx) {
974		fdp = recv_prepare_packet();
975		fdr = recv_prepare_udp();
976	}
977
978	if (cfg_do_tx)
979		do_tx();
980
981	if (cfg_do_rx)
982		do_rx(fdp, fdr);
983
984	fprintf(stderr, "OK\n");
985	return 0;
986}