Commit 6bdd7ae6 authored by Xu Du's avatar Xu Du Committed by Jakub Kicinski
Browse files

selftest: tun: Add test for receiving gso packet from tun 



The test validate that GSO information are correctly exposed
when reading packets from a TUN device.

Signed-off-by: default avatarXu Du <xudu@redhat.com>
Link: https://patch.msgid.link/fe75ac66466380490eba858eef50596a1bfbd071.1768979440.git.xudu@redhat.com


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent 400e658a

tools/testing/selftests/net/tun.c

+194 −0
Original line number Diff line number Diff line
@@ -364,6 +364,116 @@ static int ip_route_check(const char *intf, int family, void *addr) 
	return 0;

}



static int send_gso_udp_msg(int socket, struct sockaddr_storage *addr,

			    uint8_t *send_buf, int send_len, int gso_size)

{

	char control[CMSG_SPACE(sizeof(uint16_t))] = { 0 };

	int alen = sockaddr_len(addr->ss_family);

	struct msghdr msg = { 0 };

	struct iovec iov = { 0 };

	int ret;



	iov.iov_base = send_buf;

	iov.iov_len = send_len;



	msg.msg_iov = &iov;

	msg.msg_iovlen = 1;

	msg.msg_name = addr;

	msg.msg_namelen = alen;



	if (gso_size > 0) {

		struct cmsghdr *cmsg;



		msg.msg_control = control;

		msg.msg_controllen = sizeof(control);



		cmsg = CMSG_FIRSTHDR(&msg);

		cmsg->cmsg_level = SOL_UDP;

		cmsg->cmsg_type = UDP_SEGMENT;

		cmsg->cmsg_len = CMSG_LEN(sizeof(uint16_t));

		*(uint16_t *)CMSG_DATA(cmsg) = gso_size;

	}



	ret = sendmsg(socket, &msg, 0);

	if (ret < 0)

		perror("sendmsg");



	return ret;

}



static int validate_hdrlen(uint8_t **cur, int *len, int x)

{

	if (*len < x)

		return -1;

	*cur += x;

	*len -= x;

	return 0;

}



static int parse_udp_tunnel_vnet_packet(uint8_t *buf, int len, int tunnel_type,

					bool is_tap)

{

	struct ipv6hdr *iph6;

	struct udphdr *udph;

	struct iphdr *iph4;

	uint8_t *cur = buf;



	if (validate_hdrlen(&cur, &len, TUN_VNET_TNL_SIZE))

		return -1;



	if (is_tap) {

		if (validate_hdrlen(&cur, &len, ETH_HLEN))

			return -1;

	}



	if (tunnel_type & UDP_TUNNEL_OUTER_IPV4) {

		iph4 = (struct iphdr *)cur;

		if (validate_hdrlen(&cur, &len, sizeof(struct iphdr)))

			return -1;

		if (iph4->version != 4 || iph4->protocol != IPPROTO_UDP)

			return -1;

	} else {

		iph6 = (struct ipv6hdr *)cur;

		if (validate_hdrlen(&cur, &len, sizeof(struct ipv6hdr)))

			return -1;

		if (iph6->version != 6 || iph6->nexthdr != IPPROTO_UDP)

			return -1;

	}



	udph = (struct udphdr *)cur;

	if (validate_hdrlen(&cur, &len, sizeof(struct udphdr)))

		return -1;

	if (ntohs(udph->dest) != VN_PORT)

		return -1;



	if (validate_hdrlen(&cur, &len, GENEVE_HLEN))

		return -1;

	if (validate_hdrlen(&cur, &len, ETH_HLEN))

		return -1;



	if (tunnel_type & UDP_TUNNEL_INNER_IPV4) {

		iph4 = (struct iphdr *)cur;

		if (validate_hdrlen(&cur, &len, sizeof(struct iphdr)))

			return -1;

		if (iph4->version != 4 || iph4->protocol != IPPROTO_UDP)

			return -1;

	} else {

		iph6 = (struct ipv6hdr *)cur;

		if (validate_hdrlen(&cur, &len, sizeof(struct ipv6hdr)))

			return -1;

		if (iph6->version != 6 || iph6->nexthdr != IPPROTO_UDP)

			return -1;

	}



	udph = (struct udphdr *)cur;

	if (validate_hdrlen(&cur, &len, sizeof(struct udphdr)))

		return -1;

	if (ntohs(udph->dest) != UDP_DST_PORT)

		return -1;



	return len;

}



FIXTURE(tun)

{

	char ifname[IFNAMSIZ];
@@ -664,6 +774,68 @@ receive_gso_packet_from_tunnel(FIXTURE_DATA(tun_vnet_udptnl) * self, 
	return total_len;

}



static int send_gso_packet_into_tunnel(FIXTURE_DATA(tun_vnet_udptnl) * self,

				       const FIXTURE_VARIANT(tun_vnet_udptnl) *

					       variant)

{

	int family = (variant->tunnel_type & UDP_TUNNEL_INNER_IPV4) ? AF_INET :

								      AF_INET6;

	uint8_t buf[MAX_VNET_TUNNEL_PACKET_SZ] = { 0 };

	int payload_len = variant->data_size;

	int gso_size = variant->gso_size;

	struct sockaddr_storage ssa, dsa;



	assign_sockaddr_vars(family, 0, &ssa, &dsa);

	return send_gso_udp_msg(self->sock, &dsa, buf, payload_len, gso_size);

}



static int

receive_gso_packet_from_tun(FIXTURE_DATA(tun_vnet_udptnl) * self,

			    const FIXTURE_VARIANT(tun_vnet_udptnl) * variant,

			    struct virtio_net_hdr_v1_hash_tunnel *vnet_hdr)

{

	struct timeval timeout = { .tv_sec = TIMEOUT_SEC };

	uint8_t buf[MAX_VNET_TUNNEL_PACKET_SZ];

	int tunnel_type = variant->tunnel_type;

	int payload_len = variant->data_size;

	bool is_tap = variant->is_tap;

	int ret, len, total_len = 0;

	int tun_fd = self->fd;

	fd_set fdset;



	while (total_len < payload_len) {

		FD_ZERO(&fdset);

		FD_SET(tun_fd, &fdset);



		ret = select(tun_fd + 1, &fdset, NULL, NULL, &timeout);

		if (ret <= 0) {

			perror("select");

			break;

		}

		if (!FD_ISSET(tun_fd, &fdset))

			continue;



		len = read(tun_fd, buf, sizeof(buf));

		if (len <= 0) {

			if (len < 0 && errno != EAGAIN && errno != EWOULDBLOCK)

				perror("read");

			break;

		}



		len = parse_udp_tunnel_vnet_packet(buf, len, tunnel_type,

						   is_tap);

		if (len < 0)

			continue;



		if (total_len == 0)

			memcpy(vnet_hdr, buf, TUN_VNET_TNL_SIZE);



		total_len += len;

	}



	return total_len;

}



TEST_F(tun_vnet_udptnl, send_gso_packet)

{

	uint8_t pkt[MAX_VNET_TUNNEL_PACKET_SZ];
@@ -680,4 +852,26 @@ TEST_F(tun_vnet_udptnl, send_gso_packet) 
	ASSERT_EQ(r_num_mss, variant->r_num_mss);

}



TEST_F(tun_vnet_udptnl, recv_gso_packet)

{

	struct virtio_net_hdr_v1_hash_tunnel vnet_hdr = { 0 };

	struct virtio_net_hdr_v1 *vh = &vnet_hdr.hash_hdr.hdr;

	int ret, gso_type = VIRTIO_NET_HDR_GSO_UDP_L4;



	ret = send_gso_packet_into_tunnel(self, variant);

	ASSERT_EQ(ret, variant->data_size);



	memset(&vnet_hdr, 0, sizeof(vnet_hdr));

	ret = receive_gso_packet_from_tun(self, variant, &vnet_hdr);

	ASSERT_EQ(ret, variant->data_size);



	if (!variant->no_gso) {

		ASSERT_EQ(vh->gso_size, variant->gso_size);

		gso_type |= (variant->tunnel_type & UDP_TUNNEL_OUTER_IPV4) ?

				    (VIRTIO_NET_HDR_GSO_UDP_TUNNEL_IPV4) :

				    (VIRTIO_NET_HDR_GSO_UDP_TUNNEL_IPV6);

		ASSERT_EQ(vh->gso_type, gso_type);

	}

}



TEST_HARNESS_MAIN