[J-u-boot.git] / test / image / spl_load_net.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2023 Sean Anderson <[email protected]>
 */

#include <common.h>
#include <dm.h>
#include <spl.h>
#include <test/spl.h>
#include <asm/eth.h>
#include <test/ut.h>
#include "../../net/bootp.h"

/*
 * sandbox_eth_bootp_req_to_reply()
 *
 * Check if a BOOTP request was sent. If so, inject a reply
 *
 * returns 0 if injected, -EAGAIN if not
 */
static int sandbox_eth_bootp_req_to_reply(struct udevice *dev, void *packet,
					  unsigned int len)
{
	struct eth_sandbox_priv *priv = dev_get_priv(dev);
	struct ethernet_hdr *eth = packet;
	struct ip_udp_hdr *ip;
	struct bootp_hdr *bp;
	struct ethernet_hdr *eth_recv;
	struct ip_udp_hdr *ipr;
	struct bootp_hdr *bpr;

	if (ntohs(eth->et_protlen) != PROT_IP)
		return -EAGAIN;

	ip = packet + ETHER_HDR_SIZE;
	if (ip->ip_p != IPPROTO_UDP)
		return -EAGAIN;

	if (ntohs(ip->udp_dst) != PORT_BOOTPS)
		return -EAGAIN;

	bp = (void *)ip + IP_UDP_HDR_SIZE;
	if (bp->bp_op != OP_BOOTREQUEST)
		return -EAGAIN;

	/* Don't allow the buffer to overrun */
	if (priv->recv_packets >= PKTBUFSRX)
		return 0;

	/* reply to the request */
	eth_recv = (void *)priv->recv_packet_buffer[priv->recv_packets];
	memcpy(eth_recv, packet, len);
	ipr = (void *)eth_recv + ETHER_HDR_SIZE;
	bpr = (void *)ipr + IP_UDP_HDR_SIZE;
	memcpy(eth_recv->et_dest, eth->et_src, ARP_HLEN);
	memcpy(eth_recv->et_src, priv->fake_host_hwaddr, ARP_HLEN);
	ipr->ip_sum = 0;
	ipr->ip_off = 0;
	net_write_ip(&ipr->ip_dst, net_ip);
	net_write_ip(&ipr->ip_src, priv->fake_host_ipaddr);
	ipr->ip_sum = compute_ip_checksum(ipr, IP_HDR_SIZE);
	ipr->udp_src = ip->udp_dst;
	ipr->udp_dst = ip->udp_src;

	bpr->bp_op = OP_BOOTREPLY;
	net_write_ip(&bpr->bp_yiaddr, net_ip);
	net_write_ip(&bpr->bp_siaddr, priv->fake_host_ipaddr);
	copy_filename(bpr->bp_file, CONFIG_BOOTFILE, sizeof(CONFIG_BOOTFILE));
	memset(&bpr->bp_vend, 0, sizeof(bpr->bp_vend));

	priv->recv_packet_length[priv->recv_packets] = len;
	++priv->recv_packets;

	return 0;
}

struct spl_test_net_priv {
	struct unit_test_state *uts;
	void *img;
	size_t img_size;
	u16 port;
};

/* Well known TFTP port # */
#define TFTP_PORT	69
/* Transaction ID, chosen at random */
#define	TFTP_TID	21313

/*
 *	TFTP operations.
 */
#define TFTP_RRQ	1
#define TFTP_DATA	3
#define TFTP_ACK	4

/* default TFTP block size */
#define TFTP_BLOCK_SIZE		512

struct tftp_hdr {
	u16 opcode;
	u16 block;
};

#define TFTP_HDR_SIZE sizeof(struct tftp_hdr)

/*
 * sandbox_eth_tftp_req_to_reply()
 *
 * Check if a TFTP request was sent. If so, inject a reply. We don't support
 * options, and we don't check for rollover, so we are limited files of less
 * than 32M.
 *
 * returns 0 if injected, -EAGAIN if not
 */
static int sandbox_eth_tftp_req_to_reply(struct udevice *dev, void *packet,
					 unsigned int len)
{
	struct eth_sandbox_priv *priv = dev_get_priv(dev);
	struct spl_test_net_priv *test_priv = priv->priv;
	struct ethernet_hdr *eth = packet;
	struct ip_udp_hdr *ip;
	struct tftp_hdr *tftp;
	struct ethernet_hdr *eth_recv;
	struct ip_udp_hdr *ipr;
	struct tftp_hdr *tftpr;
	size_t size;
	u16 block;

	if (ntohs(eth->et_protlen) != PROT_IP)
		return -EAGAIN;

	ip = packet + ETHER_HDR_SIZE;
	if (ip->ip_p != IPPROTO_UDP)
		return -EAGAIN;

	if (ntohs(ip->udp_dst) == TFTP_PORT) {
		tftp = (void *)ip + IP_UDP_HDR_SIZE;
		if (htons(tftp->opcode) != TFTP_RRQ)
			return -EAGAIN;

		block = 0;
	} else if (ntohs(ip->udp_dst) == TFTP_TID) {
		tftp = (void *)ip + IP_UDP_HDR_SIZE;
		if (htons(tftp->opcode) != TFTP_ACK)
			return -EAGAIN;

		block = htons(tftp->block);
	} else {
		return -EAGAIN;
	}

	if (block * TFTP_BLOCK_SIZE > test_priv->img_size)
		return 0;

	size = min(test_priv->img_size - block * TFTP_BLOCK_SIZE,
		   (size_t)TFTP_BLOCK_SIZE);

	/* Don't allow the buffer to overrun */
	if (priv->recv_packets >= PKTBUFSRX)
		return 0;

	/* reply to the request */
	eth_recv = (void *)priv->recv_packet_buffer[priv->recv_packets];
	memcpy(eth_recv->et_dest, eth->et_src, ARP_HLEN);
	memcpy(eth_recv->et_src, priv->fake_host_hwaddr, ARP_HLEN);
	eth_recv->et_protlen = htons(PROT_IP);

	ipr = (void *)eth_recv + ETHER_HDR_SIZE;
	ipr->ip_hl_v = 0x45;
	ipr->ip_len = htons(IP_UDP_HDR_SIZE + TFTP_HDR_SIZE + size);
	ipr->ip_off = htons(IP_FLAGS_DFRAG);
	ipr->ip_ttl = 255;
	ipr->ip_p = IPPROTO_UDP;
	ipr->ip_sum = 0;
	net_copy_ip(&ipr->ip_dst, &ip->ip_src);
	net_copy_ip(&ipr->ip_src, &ip->ip_dst);
	ipr->ip_sum = compute_ip_checksum(ipr, IP_HDR_SIZE);

	ipr->udp_src = htons(TFTP_TID);
	ipr->udp_dst = ip->udp_src;
	ipr->udp_len = htons(UDP_HDR_SIZE + TFTP_HDR_SIZE + size);
	ipr->udp_xsum = 0;

	tftpr = (void *)ipr + IP_UDP_HDR_SIZE;
	tftpr->opcode = htons(TFTP_DATA);
	tftpr->block = htons(block + 1);
	memcpy((void *)tftpr + TFTP_HDR_SIZE,
	       test_priv->img + block * TFTP_BLOCK_SIZE, size);

	priv->recv_packet_length[priv->recv_packets] =
		ETHER_HDR_SIZE + IP_UDP_HDR_SIZE + TFTP_HDR_SIZE + size;
	++priv->recv_packets;

	return 0;
}

static int spl_net_handler(struct udevice *dev, void *packet,
			   unsigned int len)
{
	struct eth_sandbox_priv *priv = dev_get_priv(dev);
	int old_packets = priv->recv_packets;

	priv->fake_host_ipaddr = string_to_ip("1.1.2.4");
	net_ip = string_to_ip("1.1.2.2");

	sandbox_eth_arp_req_to_reply(dev, packet, len);
	sandbox_eth_bootp_req_to_reply(dev, packet, len);
	sandbox_eth_tftp_req_to_reply(dev, packet, len);

	if (old_packets == priv->recv_packets)
		return 0;

	return 0;
}

static int spl_test_net_write_image(struct unit_test_state *uts, void *img,
				    size_t img_size)
{
	struct spl_test_net_priv *test_priv = malloc(sizeof(*test_priv));

	ut_assertnonnull(test_priv);
	test_priv->uts = uts;
	test_priv->img = img;
	test_priv->img_size = img_size;

	sandbox_eth_set_tx_handler(0, spl_net_handler);
	sandbox_eth_set_priv(0, test_priv);
	return 0;
}

static int spl_test_net(struct unit_test_state *uts, const char *test_name,
			enum spl_test_image type)
{
	struct eth_sandbox_priv *priv;
	struct udevice *dev;
	int ret;

	net_server_ip = string_to_ip("1.1.2.4");
	ret = do_spl_test_load(uts, test_name, type,
			       SPL_LOAD_IMAGE_GET(0, BOOT_DEVICE_CPGMAC,
						  spl_net_load_image_cpgmac),
			       spl_test_net_write_image);

	sandbox_eth_set_tx_handler(0, NULL);
	ut_assertok(uclass_get_device(UCLASS_ETH, 0, &dev));
	priv = dev_get_priv(dev);
	free(priv->priv);
	return ret;
}
SPL_IMG_TEST(spl_test_net, LEGACY, DM_FLAGS);
SPL_IMG_TEST(spl_test_net, LEGACY_LZMA, DM_FLAGS);
SPL_IMG_TEST(spl_test_net, IMX8, DM_FLAGS);
SPL_IMG_TEST(spl_test_net, FIT_INTERNAL, DM_FLAGS);
SPL_IMG_TEST(spl_test_net, FIT_EXTERNAL, DM_FLAGS);
Commit	Line	Data
53d8bf8f SA	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (C) 2023 Sean Anderson <[email protected]>
	4	*/
	5
	6	#include <common.h>
	7	#include <dm.h>
	8	#include <spl.h>
	9	#include <test/spl.h>
	10	#include <asm/eth.h>
	11	#include <test/ut.h>
	12	#include "../../net/bootp.h"
	13
	14	/*
	15	* sandbox_eth_bootp_req_to_reply()
	16	*
	17	* Check if a BOOTP request was sent. If so, inject a reply
	18	*
	19	* returns 0 if injected, -EAGAIN if not
	20	*/
	21	static int sandbox_eth_bootp_req_to_reply(struct udevice dev, void packet,
	22	unsigned int len)
	23	{
	24	struct eth_sandbox_priv *priv = dev_get_priv(dev);
	25	struct ethernet_hdr *eth = packet;
	26	struct ip_udp_hdr *ip;
	27	struct bootp_hdr *bp;
	28	struct ethernet_hdr *eth_recv;
	29	struct ip_udp_hdr *ipr;
	30	struct bootp_hdr *bpr;
	31
	32	if (ntohs(eth->et_protlen) != PROT_IP)
	33	return -EAGAIN;
	34
	35	ip = packet + ETHER_HDR_SIZE;
	36	if (ip->ip_p != IPPROTO_UDP)
	37	return -EAGAIN;
	38
	39	if (ntohs(ip->udp_dst) != PORT_BOOTPS)
	40	return -EAGAIN;
	41
	42	bp = (void *)ip + IP_UDP_HDR_SIZE;
	43	if (bp->bp_op != OP_BOOTREQUEST)
	44	return -EAGAIN;
	45
	46	/* Don't allow the buffer to overrun */
	47	if (priv->recv_packets >= PKTBUFSRX)
	48	return 0;
	49
	50	/* reply to the request */
	51	eth_recv = (void *)priv->recv_packet_buffer[priv->recv_packets];
	52	memcpy(eth_recv, packet, len);
	53	ipr = (void *)eth_recv + ETHER_HDR_SIZE;
	54	bpr = (void *)ipr + IP_UDP_HDR_SIZE;
	55	memcpy(eth_recv->et_dest, eth->et_src, ARP_HLEN);
	56	memcpy(eth_recv->et_src, priv->fake_host_hwaddr, ARP_HLEN);
	57	ipr->ip_sum = 0;
	58	ipr->ip_off = 0;
	59	net_write_ip(&ipr->ip_dst, net_ip);
	60	net_write_ip(&ipr->ip_src, priv->fake_host_ipaddr);
	61	ipr->ip_sum = compute_ip_checksum(ipr, IP_HDR_SIZE);
	62	ipr->udp_src = ip->udp_dst;
	63	ipr->udp_dst = ip->udp_src;
	64
65	bpr->bp_op = OP_BOOTREPLY;
66	net_write_ip(&bpr->bp_yiaddr, net_ip);
67	net_write_ip(&bpr->bp_siaddr, priv->fake_host_ipaddr);
68	copy_filename(bpr->bp_file, CONFIG_BOOTFILE, sizeof(CONFIG_BOOTFILE));
69	memset(&bpr->bp_vend, 0, sizeof(bpr->bp_vend));
70
71	priv->recv_packet_length[priv->recv_packets] = len;
72	++priv->recv_packets;
73
74	return 0;
75	}
76
77	struct spl_test_net_priv {
78	struct unit_test_state *uts;
79	void *img;
80	size_t img_size;
81	u16 port;
82	};
83
84	/* Well known TFTP port # */
85	#define TFTP_PORT 69
86	/* Transaction ID, chosen at random */
87	#define TFTP_TID 21313
88
89	/*
90	* TFTP operations.
91	*/
92	#define TFTP_RRQ 1
93	#define TFTP_DATA 3
94	#define TFTP_ACK 4
95
96	/* default TFTP block size */
97	#define TFTP_BLOCK_SIZE 512
98
99	struct tftp_hdr {
100	u16 opcode;
101	u16 block;
102	};
103
104	#define TFTP_HDR_SIZE sizeof(struct tftp_hdr)
105
106	/*
107	* sandbox_eth_tftp_req_to_reply()
108	*
109	* Check if a TFTP request was sent. If so, inject a reply. We don't support
110	* options, and we don't check for rollover, so we are limited files of less
111	* than 32M.
112	*
113	* returns 0 if injected, -EAGAIN if not
114	*/
115	static int sandbox_eth_tftp_req_to_reply(struct udevice dev, void packet,
116	unsigned int len)
117	{
118	struct eth_sandbox_priv *priv = dev_get_priv(dev);
119	struct spl_test_net_priv *test_priv = priv->priv;
120	struct ethernet_hdr *eth = packet;
121	struct ip_udp_hdr *ip;
122	struct tftp_hdr *tftp;
123	struct ethernet_hdr *eth_recv;
124	struct ip_udp_hdr *ipr;
125	struct tftp_hdr *tftpr;
126	size_t size;
127	u16 block;
128
129	if (ntohs(eth->et_protlen) != PROT_IP)
130	return -EAGAIN;
131
132	ip = packet + ETHER_HDR_SIZE;
133	if (ip->ip_p != IPPROTO_UDP)
134	return -EAGAIN;
135
136	if (ntohs(ip->udp_dst) == TFTP_PORT) {
137	tftp = (void *)ip + IP_UDP_HDR_SIZE;
138	if (htons(tftp->opcode) != TFTP_RRQ)
139	return -EAGAIN;
140
141	block = 0;
142	} else if (ntohs(ip->udp_dst) == TFTP_TID) {
143	tftp = (void *)ip + IP_UDP_HDR_SIZE;
144	if (htons(tftp->opcode) != TFTP_ACK)
145	return -EAGAIN;
146
147	block = htons(tftp->block);
148	} else {
149	return -EAGAIN;
150	}
151
152	if (block * TFTP_BLOCK_SIZE > test_priv->img_size)
153	return 0;
154
155	size = min(test_priv->img_size - block * TFTP_BLOCK_SIZE,
156	(size_t)TFTP_BLOCK_SIZE);
157
158	/* Don't allow the buffer to overrun */
159	if (priv->recv_packets >= PKTBUFSRX)
160	return 0;
161
162	/* reply to the request */
163	eth_recv = (void *)priv->recv_packet_buffer[priv->recv_packets];
164	memcpy(eth_recv->et_dest, eth->et_src, ARP_HLEN);
165	memcpy(eth_recv->et_src, priv->fake_host_hwaddr, ARP_HLEN);
166	eth_recv->et_protlen = htons(PROT_IP);
167
168	ipr = (void *)eth_recv + ETHER_HDR_SIZE;
169	ipr->ip_hl_v = 0x45;
170	ipr->ip_len = htons(IP_UDP_HDR_SIZE + TFTP_HDR_SIZE + size);
171	ipr->ip_off = htons(IP_FLAGS_DFRAG);
172	ipr->ip_ttl = 255;
173	ipr->ip_p = IPPROTO_UDP;
174	ipr->ip_sum = 0;
175	net_copy_ip(&ipr->ip_dst, &ip->ip_src);
176	net_copy_ip(&ipr->ip_src, &ip->ip_dst);
177	ipr->ip_sum = compute_ip_checksum(ipr, IP_HDR_SIZE);
178
179	ipr->udp_src = htons(TFTP_TID);
180	ipr->udp_dst = ip->udp_src;
181	ipr->udp_len = htons(UDP_HDR_SIZE + TFTP_HDR_SIZE + size);
182	ipr->udp_xsum = 0;
183
184	tftpr = (void *)ipr + IP_UDP_HDR_SIZE;
185	tftpr->opcode = htons(TFTP_DATA);
186	tftpr->block = htons(block + 1);
187	memcpy((void *)tftpr + TFTP_HDR_SIZE,
188	test_priv->img + block * TFTP_BLOCK_SIZE, size);
189
190	priv->recv_packet_length[priv->recv_packets] =
191	ETHER_HDR_SIZE + IP_UDP_HDR_SIZE + TFTP_HDR_SIZE + size;
192	++priv->recv_packets;
193
194	return 0;
195	}
196
197	static int spl_net_handler(struct udevice dev, void packet,
198	unsigned int len)
199	{
200	struct eth_sandbox_priv *priv = dev_get_priv(dev);
201	int old_packets = priv->recv_packets;
202
203	priv->fake_host_ipaddr = string_to_ip("1.1.2.4");
204	net_ip = string_to_ip("1.1.2.2");
205
206	sandbox_eth_arp_req_to_reply(dev, packet, len);
207	sandbox_eth_bootp_req_to_reply(dev, packet, len);
208	sandbox_eth_tftp_req_to_reply(dev, packet, len);
209
210	if (old_packets == priv->recv_packets)
211	return 0;
212
213	return 0;
214	}
215
216	static int spl_test_net_write_image(struct unit_test_state uts, void img,
217	size_t img_size)
218	{
219	struct spl_test_net_priv test_priv = malloc(sizeof(test_priv));
220
221	ut_assertnonnull(test_priv);
222	test_priv->uts = uts;
223	test_priv->img = img;
224	test_priv->img_size = img_size;
225
226	sandbox_eth_set_tx_handler(0, spl_net_handler);
227	sandbox_eth_set_priv(0, test_priv);
228	return 0;
229	}
230
231	static int spl_test_net(struct unit_test_state uts, const char test_name,
232	enum spl_test_image type)
233	{
234	struct eth_sandbox_priv *priv;
235	struct udevice *dev;
236	int ret;
237
238	net_server_ip = string_to_ip("1.1.2.4");
239	ret = do_spl_test_load(uts, test_name, type,
240	SPL_LOAD_IMAGE_GET(0, BOOT_DEVICE_CPGMAC,
241	spl_net_load_image_cpgmac),
242	spl_test_net_write_image);
243
244	sandbox_eth_set_tx_handler(0, NULL);
245	ut_assertok(uclass_get_device(UCLASS_ETH, 0, &dev));
246	priv = dev_get_priv(dev);
247	free(priv->priv);
248	return ret;
249	}
250	SPL_IMG_TEST(spl_test_net, LEGACY, DM_FLAGS);
2e5476b5 SA	251	SPL_IMG_TEST(spl_test_net, LEGACY_LZMA, DM_FLAGS);
2e5476b5 SA	252	SPL_IMG_TEST(spl_test_net, IMX8, DM_FLAGS);
53d8bf8f SA	253	SPL_IMG_TEST(spl_test_net, FIT_INTERNAL, DM_FLAGS);
53d8bf8f SA	254	SPL_IMG_TEST(spl_test_net, FIT_EXTERNAL, DM_FLAGS);