[thirdparty/u-boot.git] / net / wget.c

// SPDX-License-Identifier: GPL-2.0
/*
 * WGET/HTTP support driver based on U-BOOT's nfs.c
 * Copyright Duncan Hare <dh@synoia.com> 2017
 */

#include <asm/global_data.h>
#include <command.h>
#include <display_options.h>
#include <env.h>
#include <efi_loader.h>
#include <image.h>
#include <lmb.h>
#include <mapmem.h>
#include <net.h>
#include <net/tcp.h>
#include <net/wget.h>
#include <stdlib.h>

DECLARE_GLOBAL_DATA_PTR;

/* The default, change with environment variable 'httpdstp' */
#define SERVER_PORT		80

#define HASHES_PER_LINE		65

#define HTTP_MAX_HDR_LEN	2048

#define HTTP_STATUS_BAD		0
#define HTTP_STATUS_OK		200

static const char http_proto[] = "HTTP/1.0";
static const char http_eom[] = "\r\n\r\n";
static const char content_len[] = "Content-Length:";
static const char linefeed[] = "\r\n";
static struct in_addr web_server_ip;
static unsigned int server_port;
static unsigned long content_length;
static u32 http_hdr_size, max_rx_pos;
static int wget_tsize_num_hash;

static char *image_url;
static enum net_loop_state wget_loop_state;

/**
 * store_block() - store block in memory
 * @src: source of data
 * @offset: offset
 * @len: length
 */
static inline int store_block(uchar *src, unsigned int offset, unsigned int len)
{
	ulong store_addr = image_load_addr + offset;
	uchar *ptr;

	// Avoid overflow
	if (wget_info->buffer_size && wget_info->buffer_size < offset + len)
		return -1;
	if (CONFIG_IS_ENABLED(LMB) && wget_info->set_bootdev) {
		if (store_addr < image_load_addr ||
		    lmb_read_check(store_addr, len)) {
			if (!wget_info->silent) {
				printf("\nwget error: ");
				printf("trying to overwrite reserved memory\n");
			}
			return -1;
		}
	}

	ptr = map_sysmem(store_addr, len);
	memcpy(ptr, src, len);
	unmap_sysmem(ptr);

	return 0;
}

static void show_block_marker(u32 packets)
{
	int cnt;

	if (wget_info->silent)
		return;

	if (content_length != -1) {
		if (net_boot_file_size > content_length)
			content_length = net_boot_file_size;

		cnt = net_boot_file_size * 50 / content_length;
		while (wget_tsize_num_hash < cnt) {
			putc('#');
			wget_tsize_num_hash++;
		}
	} else {
		if ((packets % 10) == 0)
			putc('#');
		else if (((packets + 1) % (10 * HASHES_PER_LINE)) == 0)
			puts("\n");
	}
}

static void tcp_stream_on_closed(struct tcp_stream *tcp)
{
	if (tcp->status != TCP_ERR_OK)
		wget_loop_state = NETLOOP_FAIL;

	net_set_state(wget_loop_state);
	if (wget_loop_state != NETLOOP_SUCCESS) {
		net_boot_file_size = 0;
		if (!wget_info->silent)
			printf("\nwget: Transfer Fail, TCP status - %d\n",
			       tcp->status);
		return;
	}

	if (!wget_info->silent)
		printf("\nPackets received %d, Transfer Successful\n",
		       tcp->rx_packets);
	wget_info->file_size = net_boot_file_size;
	if (wget_info->method == WGET_HTTP_METHOD_GET && wget_info->set_bootdev) {
		efi_set_bootdev("Http", NULL, image_url,
				map_sysmem(image_load_addr, 0),
				net_boot_file_size);
		env_set_hex("filesize", net_boot_file_size);
	}
}

static void tcp_stream_on_rcv_nxt_update(struct tcp_stream *tcp, u32 rx_bytes)
{
	char	*pos, *tail;
	uchar	saved, *ptr;
	int	reply_len;

	if (http_hdr_size) {
		net_boot_file_size = rx_bytes - http_hdr_size;
		show_block_marker(tcp->rx_packets);
		return;
	}

	ptr = map_sysmem(image_load_addr, rx_bytes + 1);

	saved = ptr[rx_bytes];
	ptr[rx_bytes] = '\0';
	pos = strstr((char *)ptr, http_eom);
	ptr[rx_bytes] = saved;

	if (!pos) {
		if (rx_bytes < HTTP_MAX_HDR_LEN &&
		    tcp->state == TCP_ESTABLISHED)
			goto end;

		if (!wget_info->silent)
			printf("ERROR: misssed HTTP header\n");
		tcp_stream_close(tcp);
		goto end;
	}

	http_hdr_size = pos - (char *)ptr + strlen(http_eom);
	*pos = '\0';

	if (wget_info->headers && http_hdr_size < MAX_HTTP_HEADERS_SIZE)
		strcpy(wget_info->headers, ptr);

	/* check for HTTP proto */
	if (strncasecmp((char *)ptr, "HTTP/", 5)) {
		debug_cond(DEBUG_WGET, "wget: Connected Bad Xfer "
				       "(no HTTP Status Line found)\n");
		tcp_stream_close(tcp);
		goto end;
	}

	/* get HTTP reply len */
	pos = strstr((char *)ptr, linefeed);
	if (pos)
		reply_len = pos - (char *)ptr;
	else
		reply_len = http_hdr_size - strlen(http_eom);

	pos = strchr((char *)ptr, ' ');
	if (!pos || pos - (char *)ptr > reply_len) {
		debug_cond(DEBUG_WGET, "wget: Connected Bad Xfer "
				       "(no HTTP Status Code found)\n");
		tcp_stream_close(tcp);
		goto end;
	}

	wget_info->status_code = (u32)simple_strtoul(pos + 1, &tail, 10);
	if (tail == pos + 1 || *tail != ' ') {
		debug_cond(DEBUG_WGET, "wget: Connected Bad Xfer "
				       "(bad HTTP Status Code)\n");
		tcp_stream_close(tcp);
		goto end;
	}

	debug_cond(DEBUG_WGET,
		   "wget: HTTP Status Code %d\n", wget_info->status_code);

	if (wget_info->status_code != HTTP_STATUS_OK) {
		debug_cond(DEBUG_WGET, "wget: Connected Bad Xfer\n");
		tcp_stream_close(tcp);
		goto end;
	}

	debug_cond(DEBUG_WGET, "wget: Connctd pkt %p  hlen %x\n",
		   ptr, http_hdr_size);

	content_length = -1;
	pos = strstr((char *)ptr, content_len);
	if (pos) {
		pos += strlen(content_len) + 1;
		while (*pos == ' ')
			pos++;
		content_length = simple_strtoul(pos, &tail, 10);
		if (*tail != '\r' && *tail != '\n' && *tail != '\0')
			content_length = -1;
	}

	if (content_length >= 0) {
		debug_cond(DEBUG_WGET,
			   "wget: Connected Len %lu\n",
			   content_length);
		wget_info->hdr_cont_len = content_length;
		if (wget_info->buffer_size && wget_info->buffer_size < wget_info->hdr_cont_len){
			tcp_stream_reset(tcp);
			goto end;
		}

	}

	net_boot_file_size = rx_bytes - http_hdr_size;
	memmove(ptr, ptr + http_hdr_size, max_rx_pos + 1 - http_hdr_size);
	wget_loop_state = NETLOOP_SUCCESS;

end:
	unmap_sysmem(ptr);
}

static int tcp_stream_rx(struct tcp_stream *tcp, u32 rx_offs, void *buf, int len)
{
	if ((max_rx_pos == (u32)(-1)) || (max_rx_pos < rx_offs + len - 1))
		max_rx_pos = rx_offs + len - 1;

	// Avoid overflow
	if (store_block(buf, rx_offs - http_hdr_size, len) < 0)
		return -1;

	return len;
}

static int tcp_stream_tx(struct tcp_stream *tcp, u32 tx_offs, void *buf, int maxlen)
{
	int ret;
	const char *method;

	if (tx_offs)
		return 0;

	switch (wget_info->method) {
	case WGET_HTTP_METHOD_HEAD:
		method = "HEAD";
		break;
	case WGET_HTTP_METHOD_GET:
	default:
		method = "GET";
		break;
	}

	ret = snprintf(buf, maxlen, "%s %s %s\r\n\r\n",
		       method, image_url, http_proto);

	return ret;
}

static int tcp_stream_on_create(struct tcp_stream *tcp)
{
	if (tcp->rhost.s_addr != web_server_ip.s_addr ||
	    tcp->rport != server_port)
		return 0;

	tcp->max_retry_count = WGET_RETRY_COUNT;
	tcp->initial_timeout = WGET_TIMEOUT;
	tcp->on_closed = tcp_stream_on_closed;
	tcp->on_rcv_nxt_update = tcp_stream_on_rcv_nxt_update;
	tcp->rx = tcp_stream_rx;
	tcp->tx = tcp_stream_tx;

	return 1;
}

#define BLOCKSIZE 512

void wget_start(void)
{
	struct tcp_stream *tcp;

	if (!wget_info)
		wget_info = &default_wget_info;

	image_url = strchr(net_boot_file_name, ':');
	if (image_url > 0) {
		web_server_ip = string_to_ip(net_boot_file_name);
		++image_url;
		net_server_ip = web_server_ip;
	} else {
		web_server_ip = net_server_ip;
		image_url = net_boot_file_name;
	}

	debug_cond(DEBUG_WGET,
		   "wget: Transfer HTTP Server %pI4; our IP %pI4\n",
		   &web_server_ip, &net_ip);

	/* Check if we need to send across this subnet */
	if (net_gateway.s_addr && net_netmask.s_addr) {
		struct in_addr our_net;
		struct in_addr server_net;

		our_net.s_addr = net_ip.s_addr & net_netmask.s_addr;
		server_net.s_addr = net_server_ip.s_addr & net_netmask.s_addr;
		if (our_net.s_addr != server_net.s_addr)
			debug_cond(DEBUG_WGET,
				   "wget: sending through gateway %pI4",
				   &net_gateway);
	}
	debug_cond(DEBUG_WGET, "URL '%s'\n", image_url);

	if (net_boot_file_expected_size_in_blocks) {
		debug_cond(DEBUG_WGET, "wget: Size is 0x%x Bytes = ",
			   net_boot_file_expected_size_in_blocks * BLOCKSIZE);
		print_size(net_boot_file_expected_size_in_blocks * BLOCKSIZE,
			   "");
	}
	debug_cond(DEBUG_WGET,
		   "\nwget:Load address: 0x%lx\nLoading: *\b", image_load_addr);

	/*
	 * Zero out server ether to force arp resolution in case
	 * the server ip for the previous u-boot command, for example dns
	 * is not the same as the web server ip.
	 */

	memset(net_server_ethaddr, 0, 6);

	max_rx_pos = (u32)(-1);
	net_boot_file_size = 0;
	http_hdr_size = 0;
	wget_tsize_num_hash = 0;
	wget_loop_state = NETLOOP_FAIL;

	wget_info->status_code = HTTP_STATUS_BAD;
	wget_info->file_size = 0;
	wget_info->hdr_cont_len = 0;
	if (wget_info->headers)
		wget_info->headers[0] = 0;

	server_port = env_get_ulong("httpdstp", 10, SERVER_PORT) & 0xffff;
	tcp_stream_set_on_create_handler(tcp_stream_on_create);
	tcp = tcp_stream_connect(web_server_ip, server_port);
	if (!tcp) {
		if (!wget_info->silent)
			printf("No free tcp streams\n");
		net_set_state(NETLOOP_FAIL);
		return;
	}
	tcp_stream_put(tcp);
}

int wget_do_request(ulong dst_addr, char *uri)
{
	int ret;
	char *s, *host_name, *file_name, *str_copy;

	/*
	 * Download file using wget.
	 *
	 * U-Boot wget takes the target uri in this format.
	 *  "<http server ip>:<file path>"  e.g.) 192.168.1.1:/sample/test.iso
	 * Need to resolve the http server ip address before starting wget.
	 */
	str_copy = strdup(uri);
	if (!str_copy)
		return -ENOMEM;

	s = str_copy + strlen("http://");
	host_name = strsep(&s, "/");
	if (!s) {
		ret = -EINVAL;
		goto out;
	}
	file_name = s;

	host_name = strsep(&host_name, ":");

	if (string_to_ip(host_name).s_addr) {
		s = host_name;
	} else {
#if IS_ENABLED(CONFIG_CMD_DNS)
		net_dns_resolve = host_name;
		net_dns_env_var = "httpserverip";
		if (net_loop(DNS) < 0) {
			ret = -EINVAL;
			goto out;
		}
		s = env_get("httpserverip");
		if (!s) {
			ret = -EINVAL;
			goto out;
		}
#else
		ret = -EINVAL;
		goto out;
#endif
	}

	strlcpy(net_boot_file_name, s, sizeof(net_boot_file_name));
	strlcat(net_boot_file_name, ":/", sizeof(net_boot_file_name)); /* append '/' which is removed by strsep() */
	strlcat(net_boot_file_name, file_name, sizeof(net_boot_file_name));
	image_load_addr = dst_addr;
	ret = net_loop(WGET);

out:
	free(str_copy);

	return ret < 0 ? ret : 0;
}

/**
 * wget_validate_uri() - validate the uri for wget
 *
 * @uri:	uri string
 *
 * This function follows the current U-Boot wget implementation.
 * scheme: only "http:" is supported
 * authority:
 *   - user information: not supported
 *   - host: supported
 *   - port: not supported(always use the default port)
 *
 * Uri is expected to be correctly percent encoded.
 * This is the minimum check, control codes(0x1-0x19, 0x7F, except '\0')
 * and space character(0x20) are not allowed.
 *
 * TODO: stricter uri conformance check
 *
 * Return:	true on success, false on failure
 */
bool wget_validate_uri(char *uri)
{
	char c;
	bool ret = true;
	char *str_copy, *s, *authority;

	for (c = 0x1; c < 0x21; c++) {
		if (strchr(uri, c)) {
			log_err("invalid character is used\n");
			return false;
		}
	}
	if (strchr(uri, 0x7f)) {
		log_err("invalid character is used\n");
		return false;
	}

	if (strncmp(uri, "http://", 7)) {
		log_err("only http:// is supported\n");
		return false;
	}
	str_copy = strdup(uri);
	if (!str_copy)
		return false;

	s = str_copy + strlen("http://");
	authority = strsep(&s, "/");
	if (!s) {
		log_err("invalid uri, no file path\n");
		ret = false;
		goto out;
	}
	s = strchr(authority, '@');
	if (s) {
		log_err("user information is not supported\n");
		ret = false;
		goto out;
	}
	s = strchr(authority, ':');
	if (s) {
		log_err("user defined port is not supported\n");
		ret = false;
		goto out;
	}

out:
	free(str_copy);

	return ret;
}
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* WGET/HTTP support driver based on U-BOOT's nfs.c
	4	* Copyright Duncan Hare <dh@synoia.com> 2017
	5	*/
	6
	7	#include <asm/global_data.h>
	8	#include <command.h>
	9	#include <display_options.h>
	10	#include <env.h>
	11	#include <efi_loader.h>
	12	#include <image.h>
	13	#include <lmb.h>
	14	#include <mapmem.h>
	15	#include <net.h>
	16	#include <net/tcp.h>
	17	#include <net/wget.h>
	18	#include <stdlib.h>
	19
	20	DECLARE_GLOBAL_DATA_PTR;
	21
	22	/* The default, change with environment variable 'httpdstp' */
	23	#define SERVER_PORT 80
	24
	25	#define HASHES_PER_LINE 65
	26
	27	#define HTTP_MAX_HDR_LEN 2048
	28
	29	#define HTTP_STATUS_BAD 0
	30	#define HTTP_STATUS_OK 200
	31
	32	static const char http_proto[] = "HTTP/1.0";
	33	static const char http_eom[] = "\r\n\r\n";
	34	static const char content_len[] = "Content-Length:";
	35	static const char linefeed[] = "\r\n";
	36	static struct in_addr web_server_ip;
	37	static unsigned int server_port;
	38	static unsigned long content_length;
	39	static u32 http_hdr_size, max_rx_pos;
	40	static int wget_tsize_num_hash;
	41
	42	static char *image_url;
	43	static enum net_loop_state wget_loop_state;
	44
	45	/**
	46	* store_block() - store block in memory
	47	* @src: source of data
	48	* @offset: offset
	49	* @len: length
	50	*/
	51	static inline int store_block(uchar *src, unsigned int offset, unsigned int len)
	52	{
	53	ulong store_addr = image_load_addr + offset;
	54	uchar *ptr;
	55
	56	// Avoid overflow
	57	if (wget_info->buffer_size && wget_info->buffer_size < offset + len)
	58	return -1;
	59	if (CONFIG_IS_ENABLED(LMB) && wget_info->set_bootdev) {
	60	if (store_addr < image_load_addr \|\|
	61	lmb_read_check(store_addr, len)) {
	62	if (!wget_info->silent) {
	63	printf("\nwget error: ");
	64	printf("trying to overwrite reserved memory\n");
	65	}
	66	return -1;
	67	}
	68	}
	69
	70	ptr = map_sysmem(store_addr, len);
	71	memcpy(ptr, src, len);
	72	unmap_sysmem(ptr);
	73
	74	return 0;
	75	}
	76
	77	static void show_block_marker(u32 packets)
	78	{
	79	int cnt;
	80
	81	if (wget_info->silent)
	82	return;
	83
	84	if (content_length != -1) {
	85	if (net_boot_file_size > content_length)
	86	content_length = net_boot_file_size;
	87
	88	cnt = net_boot_file_size * 50 / content_length;
	89	while (wget_tsize_num_hash < cnt) {
	90	putc('#');
	91	wget_tsize_num_hash++;
	92	}
	93	} else {
	94	if ((packets % 10) == 0)
	95	putc('#');
	96	else if (((packets + 1) % (10 * HASHES_PER_LINE)) == 0)
	97	puts("\n");
	98	}
	99	}
	100
	101	static void tcp_stream_on_closed(struct tcp_stream *tcp)
	102	{
	103	if (tcp->status != TCP_ERR_OK)
	104	wget_loop_state = NETLOOP_FAIL;
	105
	106	net_set_state(wget_loop_state);
	107	if (wget_loop_state != NETLOOP_SUCCESS) {
	108	net_boot_file_size = 0;
	109	if (!wget_info->silent)
	110	printf("\nwget: Transfer Fail, TCP status - %d\n",
	111	tcp->status);
	112	return;
	113	}
	114
	115	if (!wget_info->silent)
	116	printf("\nPackets received %d, Transfer Successful\n",
	117	tcp->rx_packets);
	118	wget_info->file_size = net_boot_file_size;
	119	if (wget_info->method == WGET_HTTP_METHOD_GET && wget_info->set_bootdev) {
	120	efi_set_bootdev("Http", NULL, image_url,
	121	map_sysmem(image_load_addr, 0),
	122	net_boot_file_size);
	123	env_set_hex("filesize", net_boot_file_size);
	124	}
	125	}
	126
	127	static void tcp_stream_on_rcv_nxt_update(struct tcp_stream *tcp, u32 rx_bytes)
	128	{
	129	char pos, tail;
	130	uchar saved, *ptr;
	131	int reply_len;
	132
	133	if (http_hdr_size) {
	134	net_boot_file_size = rx_bytes - http_hdr_size;
	135	show_block_marker(tcp->rx_packets);
	136	return;
	137	}
	138
	139	ptr = map_sysmem(image_load_addr, rx_bytes + 1);
	140
	141	saved = ptr[rx_bytes];
	142	ptr[rx_bytes] = '\0';
	143	pos = strstr((char *)ptr, http_eom);
	144	ptr[rx_bytes] = saved;
	145
	146	if (!pos) {
	147	if (rx_bytes < HTTP_MAX_HDR_LEN &&
	148	tcp->state == TCP_ESTABLISHED)
	149	goto end;
	150
	151	if (!wget_info->silent)
	152	printf("ERROR: misssed HTTP header\n");
	153	tcp_stream_close(tcp);
	154	goto end;
	155	}
	156
	157	http_hdr_size = pos - (char *)ptr + strlen(http_eom);
	158	*pos = '\0';
	159
	160	if (wget_info->headers && http_hdr_size < MAX_HTTP_HEADERS_SIZE)
	161	strcpy(wget_info->headers, ptr);
	162
	163	/* check for HTTP proto */
	164	if (strncasecmp((char *)ptr, "HTTP/", 5)) {
	165	debug_cond(DEBUG_WGET, "wget: Connected Bad Xfer "
	166	"(no HTTP Status Line found)\n");
	167	tcp_stream_close(tcp);
	168	goto end;
	169	}
	170
	171	/* get HTTP reply len */
	172	pos = strstr((char *)ptr, linefeed);
	173	if (pos)
	174	reply_len = pos - (char *)ptr;
	175	else
	176	reply_len = http_hdr_size - strlen(http_eom);
	177
	178	pos = strchr((char *)ptr, ' ');
	179	if (!pos \|\| pos - (char *)ptr > reply_len) {
	180	debug_cond(DEBUG_WGET, "wget: Connected Bad Xfer "
	181	"(no HTTP Status Code found)\n");
	182	tcp_stream_close(tcp);
	183	goto end;
	184	}
	185
	186	wget_info->status_code = (u32)simple_strtoul(pos + 1, &tail, 10);
	187	if (tail == pos + 1 \|\| *tail != ' ') {
	188	debug_cond(DEBUG_WGET, "wget: Connected Bad Xfer "
	189	"(bad HTTP Status Code)\n");
	190	tcp_stream_close(tcp);
	191	goto end;
	192	}
	193
	194	debug_cond(DEBUG_WGET,
	195	"wget: HTTP Status Code %d\n", wget_info->status_code);
	196
	197	if (wget_info->status_code != HTTP_STATUS_OK) {
	198	debug_cond(DEBUG_WGET, "wget: Connected Bad Xfer\n");
	199	tcp_stream_close(tcp);
	200	goto end;
	201	}
	202
	203	debug_cond(DEBUG_WGET, "wget: Connctd pkt %p hlen %x\n",
	204	ptr, http_hdr_size);
	205
	206	content_length = -1;
	207	pos = strstr((char *)ptr, content_len);
	208	if (pos) {
	209	pos += strlen(content_len) + 1;
	210	while (*pos == ' ')
	211	pos++;
	212	content_length = simple_strtoul(pos, &tail, 10);
	213	if (tail != '\r' && tail != '\n' && *tail != '\0')
	214	content_length = -1;
	215	}
	216
	217	if (content_length >= 0) {
	218	debug_cond(DEBUG_WGET,
	219	"wget: Connected Len %lu\n",
	220	content_length);
	221	wget_info->hdr_cont_len = content_length;
	222	if (wget_info->buffer_size && wget_info->buffer_size < wget_info->hdr_cont_len){
	223	tcp_stream_reset(tcp);
	224	goto end;
	225	}
	226
	227	}
	228
	229	net_boot_file_size = rx_bytes - http_hdr_size;
	230	memmove(ptr, ptr + http_hdr_size, max_rx_pos + 1 - http_hdr_size);
	231	wget_loop_state = NETLOOP_SUCCESS;
	232
	233	end:
	234	unmap_sysmem(ptr);
	235	}
	236
	237	static int tcp_stream_rx(struct tcp_stream tcp, u32 rx_offs, void buf, int len)
	238	{
	239	if ((max_rx_pos == (u32)(-1)) \|\| (max_rx_pos < rx_offs + len - 1))
	240	max_rx_pos = rx_offs + len - 1;
	241
	242	// Avoid overflow
	243	if (store_block(buf, rx_offs - http_hdr_size, len) < 0)
	244	return -1;
	245
	246	return len;
	247	}
	248
	249	static int tcp_stream_tx(struct tcp_stream tcp, u32 tx_offs, void buf, int maxlen)
	250	{
	251	int ret;
	252	const char *method;
	253
	254	if (tx_offs)
	255	return 0;
	256
	257	switch (wget_info->method) {
	258	case WGET_HTTP_METHOD_HEAD:
	259	method = "HEAD";
	260	break;
	261	case WGET_HTTP_METHOD_GET:
	262	default:
	263	method = "GET";
	264	break;
	265	}
	266
	267	ret = snprintf(buf, maxlen, "%s %s %s\r\n\r\n",
	268	method, image_url, http_proto);
	269
	270	return ret;
	271	}
	272
	273	static int tcp_stream_on_create(struct tcp_stream *tcp)
	274	{
	275	if (tcp->rhost.s_addr != web_server_ip.s_addr \|\|
	276	tcp->rport != server_port)
	277	return 0;
	278
	279	tcp->max_retry_count = WGET_RETRY_COUNT;
	280	tcp->initial_timeout = WGET_TIMEOUT;
	281	tcp->on_closed = tcp_stream_on_closed;
	282	tcp->on_rcv_nxt_update = tcp_stream_on_rcv_nxt_update;
	283	tcp->rx = tcp_stream_rx;
	284	tcp->tx = tcp_stream_tx;
	285
	286	return 1;
	287	}
	288
	289	#define BLOCKSIZE 512
	290
	291	void wget_start(void)
	292	{
	293	struct tcp_stream *tcp;
	294
	295	if (!wget_info)
	296	wget_info = &default_wget_info;
	297
	298	image_url = strchr(net_boot_file_name, ':');
	299	if (image_url > 0) {
	300	web_server_ip = string_to_ip(net_boot_file_name);
	301	++image_url;
	302	net_server_ip = web_server_ip;
	303	} else {
	304	web_server_ip = net_server_ip;
	305	image_url = net_boot_file_name;
	306	}
	307
	308	debug_cond(DEBUG_WGET,
	309	"wget: Transfer HTTP Server %pI4; our IP %pI4\n",
	310	&web_server_ip, &net_ip);
	311
	312	/* Check if we need to send across this subnet */
	313	if (net_gateway.s_addr && net_netmask.s_addr) {
	314	struct in_addr our_net;
	315	struct in_addr server_net;
	316
	317	our_net.s_addr = net_ip.s_addr & net_netmask.s_addr;
	318	server_net.s_addr = net_server_ip.s_addr & net_netmask.s_addr;
	319	if (our_net.s_addr != server_net.s_addr)
	320	debug_cond(DEBUG_WGET,
	321	"wget: sending through gateway %pI4",
	322	&net_gateway);
	323	}
	324	debug_cond(DEBUG_WGET, "URL '%s'\n", image_url);
	325
	326	if (net_boot_file_expected_size_in_blocks) {
	327	debug_cond(DEBUG_WGET, "wget: Size is 0x%x Bytes = ",
	328	net_boot_file_expected_size_in_blocks * BLOCKSIZE);
	329	print_size(net_boot_file_expected_size_in_blocks * BLOCKSIZE,
	330	"");
	331	}
	332	debug_cond(DEBUG_WGET,
	333	"\nwget:Load address: 0x%lx\nLoading: *\b", image_load_addr);
	334
	335	/*
	336	* Zero out server ether to force arp resolution in case
	337	* the server ip for the previous u-boot command, for example dns
	338	* is not the same as the web server ip.
	339	*/
	340
	341	memset(net_server_ethaddr, 0, 6);
	342
	343	max_rx_pos = (u32)(-1);
	344	net_boot_file_size = 0;
	345	http_hdr_size = 0;
	346	wget_tsize_num_hash = 0;
	347	wget_loop_state = NETLOOP_FAIL;
	348
	349	wget_info->status_code = HTTP_STATUS_BAD;
	350	wget_info->file_size = 0;
	351	wget_info->hdr_cont_len = 0;
	352	if (wget_info->headers)
	353	wget_info->headers[0] = 0;
	354
	355	server_port = env_get_ulong("httpdstp", 10, SERVER_PORT) & 0xffff;
	356	tcp_stream_set_on_create_handler(tcp_stream_on_create);
	357	tcp = tcp_stream_connect(web_server_ip, server_port);
	358	if (!tcp) {
	359	if (!wget_info->silent)
	360	printf("No free tcp streams\n");
	361	net_set_state(NETLOOP_FAIL);
	362	return;
	363	}
	364	tcp_stream_put(tcp);
	365	}
	366
	367	int wget_do_request(ulong dst_addr, char *uri)
	368	{
	369	int ret;
	370	char s, host_name, file_name, str_copy;
	371
	372	/*
	373	* Download file using wget.
	374	*
	375	* U-Boot wget takes the target uri in this format.
	376	* "<http server ip>:<file path>" e.g.) 192.168.1.1:/sample/test.iso
	377	* Need to resolve the http server ip address before starting wget.
	378	*/
	379	str_copy = strdup(uri);
	380	if (!str_copy)
	381	return -ENOMEM;
	382
	383	s = str_copy + strlen("http://");
	384	host_name = strsep(&s, "/");
	385	if (!s) {
	386	ret = -EINVAL;
	387	goto out;
	388	}
	389	file_name = s;
	390
	391	host_name = strsep(&host_name, ":");
	392
	393	if (string_to_ip(host_name).s_addr) {
	394	s = host_name;
	395	} else {
	396	#if IS_ENABLED(CONFIG_CMD_DNS)
	397	net_dns_resolve = host_name;
	398	net_dns_env_var = "httpserverip";
	399	if (net_loop(DNS) < 0) {
	400	ret = -EINVAL;
	401	goto out;
	402	}
	403	s = env_get("httpserverip");
	404	if (!s) {
	405	ret = -EINVAL;
	406	goto out;
	407	}
	408	#else
	409	ret = -EINVAL;
	410	goto out;
	411	#endif
	412	}
	413
	414	strlcpy(net_boot_file_name, s, sizeof(net_boot_file_name));
	415	strlcat(net_boot_file_name, ":/", sizeof(net_boot_file_name)); /* append '/' which is removed by strsep() */
	416	strlcat(net_boot_file_name, file_name, sizeof(net_boot_file_name));
	417	image_load_addr = dst_addr;
	418	ret = net_loop(WGET);
	419
	420	out:
	421	free(str_copy);
	422
	423	return ret < 0 ? ret : 0;
	424	}
	425
	426	/**
	427	* wget_validate_uri() - validate the uri for wget
	428	*
	429	* @uri: uri string
	430	*
	431	* This function follows the current U-Boot wget implementation.
	432	* scheme: only "http:" is supported
	433	* authority:
	434	* - user information: not supported
	435	* - host: supported
	436	* - port: not supported(always use the default port)
	437	*
	438	* Uri is expected to be correctly percent encoded.
	439	* This is the minimum check, control codes(0x1-0x19, 0x7F, except '\0')
	440	* and space character(0x20) are not allowed.
	441	*
	442	* TODO: stricter uri conformance check
	443	*
	444	* Return: true on success, false on failure
	445	*/
	446	bool wget_validate_uri(char *uri)
	447	{
	448	char c;
	449	bool ret = true;
	450	char str_copy, s, *authority;
	451
	452	for (c = 0x1; c < 0x21; c++) {
	453	if (strchr(uri, c)) {
	454	log_err("invalid character is used\n");
	455	return false;
	456	}
	457	}
	458	if (strchr(uri, 0x7f)) {
	459	log_err("invalid character is used\n");
	460	return false;
	461	}
	462
	463	if (strncmp(uri, "http://", 7)) {
	464	log_err("only http:// is supported\n");
	465	return false;
	466	}
	467	str_copy = strdup(uri);
	468	if (!str_copy)
	469	return false;
	470
	471	s = str_copy + strlen("http://");
	472	authority = strsep(&s, "/");
	473	if (!s) {
	474	log_err("invalid uri, no file path\n");
	475	ret = false;
	476	goto out;
	477	}
	478	s = strchr(authority, '@');
	479	if (s) {
	480	log_err("user information is not supported\n");
	481	ret = false;
	482	goto out;
	483	}
	484	s = strchr(authority, ':');
	485	if (s) {
	486	log_err("user defined port is not supported\n");
	487	ret = false;
	488	goto out;
	489	}
	490
	491	out:
	492	free(str_copy);
	493
	494	return ret;
	495	}