[PATCH 8/9] efi_loader: Add netdump efi app

Adriano Cordova adrianox at gmail.com
Fri May 16 10:18:38 CEST 2025


Add a netdump EFI app to test the U-Boot EFI network
stack.

Signed-off-by: Adriano Cordova <adriano.cordova at canonical.com>
---
 lib/efi_loader/Makefile  |   1 +
 lib/efi_loader/netdump.c | 851 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 852 insertions(+)
 create mode 100644 lib/efi_loader/netdump.c

diff --git a/lib/efi_loader/Makefile b/lib/efi_loader/Makefile
index 92c6822bc13..98c8ad40f95 100644
--- a/lib/efi_loader/Makefile
+++ b/lib/efi_loader/Makefile
@@ -17,6 +17,7 @@ apps-$(CONFIG_RISCV) += boothart
 apps-$(CONFIG_BOOTEFI_HELLO_COMPILE) += helloworld
 apps-$(CONFIG_GENERATE_SMBIOS_TABLE) += smbiosdump
 apps-$(CONFIG_EFI_LOAD_FILE2_INITRD) += initrddump
+apps-$(CONFIG_EFI_HTTP_PROTOCOL) += netdump
 ifeq ($(CONFIG_GENERATE_ACPI_TABLE),)
 apps-y += dtbdump
 endif
diff --git a/lib/efi_loader/netdump.c b/lib/efi_loader/netdump.c
new file mode 100644
index 00000000000..c4ed4243c56
--- /dev/null
+++ b/lib/efi_loader/netdump.c
@@ -0,0 +1,851 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * netdump.efi tests EFI network protocols
+ *
+ * Specifying 'nocolor' as load option data suppresses colored output and
+ * clearing of the screen.
+ */
+
+#include <efi_api.h>
+#include <charset.h>
+#include <net.h>
+
+#define BUFFER_SIZE 64
+#define ESC 0x17
+
+#define efi_size_in_pages(size) (((size) + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT)
+
+static struct efi_system_table *systable;
+static struct efi_boot_services *bs;
+static struct efi_simple_text_output_protocol *cerr;
+static struct efi_simple_text_output_protocol *cout;
+static struct efi_simple_text_input_protocol *cin;
+
+static efi_handle_t http_protocol_handle;
+static int callback_done;
+
+static const efi_guid_t loaded_image_guid = EFI_LOADED_IMAGE_PROTOCOL_GUID;
+static const efi_guid_t efi_http_guid = EFI_HTTP_PROTOCOL_GUID;
+static const efi_guid_t efi_http_service_binding_guid = EFI_HTTP_SERVICE_BINDING_PROTOCOL_GUID;
+static const efi_guid_t efi_ip4_config2_guid = EFI_IP4_CONFIG2_PROTOCOL_GUID;
+
+static efi_handle_t handle;
+static efi_handle_t net_handle;
+
+static bool nocolor;
+
+/**
+ * color() - set foreground color
+ *
+ * @color:	foreground color
+ */
+static void color(u8 color)
+{
+	if (!nocolor)
+		cout->set_attribute(cout, color | EFI_BACKGROUND_BLACK);
+}
+
+/**
+ * print() - print string
+ *
+ * @string:	text
+ */
+static void print(u16 *string)
+{
+	cout->output_string(cout, string);
+}
+
+/**
+ * cls() - clear screen
+ */
+static void cls(void)
+{
+	if (nocolor)
+		print(u"\r\n");
+	else
+		cout->clear_screen(cout);
+}
+
+/**
+ * error() - print error string
+ *
+ * @string:	error text
+ */
+static void error(u16 *string)
+{
+	color(EFI_LIGHTRED);
+	print(string);
+	color(EFI_LIGHTBLUE);
+}
+
+/*
+ * printx() - print hexadecimal number
+ *
+ * @val:	value to print;
+ * @prec:	minimum number of digits to print
+ */
+static void printx(u64 val, u32 prec)
+{
+	int i;
+	u16 c;
+	u16 buf[16];
+	u16 *pos = buf;
+
+	for (i = 2 * sizeof(val) - 1; i >= 0; --i) {
+		c = (val >> (4 * i)) & 0x0f;
+		if (c || pos != buf || !i || i < prec) {
+			c += '0';
+			if (c > '9')
+				c += 'a' - '9' - 1;
+			*pos++ = c;
+		}
+	}
+	*pos = 0;
+	print(buf);
+}
+
+/*
+ * printd() - print decimal byte
+ *
+ * @val:	value to print;
+ */
+static void printd(u64 val)
+{
+	u16 buf[21];
+	u16 tmp;
+	int i = 0;
+
+	do {
+		buf[i++] = '0' + (val % 10);
+		val /= 10;
+	} while (val > 0);
+
+	for (int j = 0; j < i / 2; ++j) {
+		tmp = buf[j];
+		buf[j] = buf[i - 1 - j];
+		buf[i - 1 - j] = tmp;
+	}
+
+	buf[i] = 0;
+	print(buf);
+}
+
+/**
+ * efi_drain_input() - drain console input
+ */
+static void efi_drain_input(void)
+{
+	cin->reset(cin, true);
+}
+
+/**
+ * efi_input() - read string from console
+ *
+ * @buffer:		input buffer
+ * @buffer_size:	buffer size
+ * Return:		status code
+ */
+static efi_status_t efi_input(u16 *buffer, efi_uintn_t buffer_size)
+{
+	struct efi_input_key key = {0};
+	efi_uintn_t index;
+	efi_uintn_t pos = 0;
+	u16 outbuf[2] = u" ";
+	efi_status_t ret;
+
+	*buffer = 0;
+	for (;;) {
+		ret = bs->wait_for_event(1, &cin->wait_for_key, &index);
+		if (ret != EFI_SUCCESS)
+			continue;
+		ret = cin->read_key_stroke(cin, &key);
+		if (ret != EFI_SUCCESS)
+			continue;
+		switch (key.scan_code) {
+		case 0x17: /* Escape */
+			print(u"\r\nAborted\r\n");
+			return EFI_ABORTED;
+		default:
+			break;
+		}
+		switch (key.unicode_char) {
+		case 0x08: /* Backspace */
+			if (pos) {
+				buffer[pos--] = 0;
+				print(u"\b \b");
+			}
+			break;
+		case 0x0a: /* Linefeed */
+		case 0x0d: /* Carriage return */
+			print(u"\r\n");
+			return EFI_SUCCESS;
+		default:
+			break;
+		}
+		/* Ignore surrogate codes */
+		if (key.unicode_char >= 0xD800 && key.unicode_char <= 0xDBFF)
+			continue;
+		if (key.unicode_char >= 0x20 &&
+		    pos < buffer_size - 1) {
+			*outbuf = key.unicode_char;
+			buffer[pos++] = key.unicode_char;
+			buffer[pos] = 0;
+			print(outbuf);
+		}
+	}
+}
+
+/**
+ * skip_whitespace() - skip over leading whitespace
+ *
+ * @pos:	UTF-16 string
+ * Return:	pointer to first non-whitespace
+ */
+static u16 *skip_whitespace(u16 *pos)
+{
+	for (; *pos && *pos <= 0x20; ++pos)
+		;
+	return pos;
+}
+
+/**
+ * starts_with() - check if @string starts with @keyword
+ *
+ * @string:	string to search for keyword
+ * @keyword:	keyword to be searched
+ * Return:	true if @string starts with the keyword
+ */
+static bool starts_with(u16 *string, u16 *keyword)
+{
+	if (!string || !keyword)
+		return false;
+
+	for (; *keyword; ++string, ++keyword) {
+		if (*string != *keyword)
+			return false;
+	}
+	return true;
+}
+
+/*
+ * efi_dectoul() - decimal string to efi_uintn_t
+ *
+ * @s:		string
+ * Return:	string as efi_uintn_t
+ */
+static efi_uintn_t efi_dectoul(char *s)
+{
+	efi_uintn_t result = 0;
+
+	while (*s >= '0' && *s <= '9') {
+		result = result * 10 + (*s - '0');
+		s++;
+	}
+	return result;
+}
+
+/*
+ * parse_address() - parse string IP address into ip_addr
+ *
+ * @input:	string IP address
+ * @address:	pointer to u8[4] buffer
+ */
+static void parse_address(u8 **input, u8 *address)
+{
+	int i = 0;
+	efi_uintn_t part;
+
+	if (**input < '0' || **input > '9')
+		return;
+
+	while (i <= 3) {
+		part = efi_dectoul(*input);
+		if (part > 255)
+			return;
+		address[i] = (u8)part;
+		while (**input >= '0' && **input <= '9')
+			(*input)++;
+		if (**input == '.')
+			(*input)++;
+		else
+			break;
+		i++;
+	}
+}
+
+/*
+ * utf16le_ascii_to_utf8() - simple utf16to utf8 converter
+ *
+ * @out:	output utf8 buffer
+ * @in:		input utf16 buffer
+ * @max_out:	maximum characters to convert
+ */
+static int utf16le_ascii_to_utf8(char *out, const u16 *in, size_t max_out)
+{
+	size_t i = 0;
+
+	while (in[i] && i < max_out - 1) {
+		if (in[i] > 0x7F)
+			return -1;  // non-ASCII detected, not supported
+		out[i] = (char)(in[i] & 0xFF);
+		i++;
+	}
+	out[i] = '\0';
+	return 0;
+}
+
+/**
+ * do_help() - print help
+ */
+static void do_help(void)
+{
+	error(u"set address <ip> <netmask> - set IP and netmask\r\n");
+	error(u"get address                - get IP and netmask\r\n");
+	error(u"set policy static          - set policy to static\r\n");
+	error(u"wget <uri>                 - fetch a file via EFI_HTTP_PROTOCOL\r\n");
+	error(u"exit                       - exit the shell\r\n");
+}
+
+/**
+ * do_set_address() - sets IP and netmask using EFI_IP4_CONFIG2_PROTOCOL
+ *
+ * @address:		ip and netmask
+ * Return:		status code
+ */
+static efi_status_t do_set_address(u16 *address)
+{
+	efi_uintn_t ret;
+	struct efi_ip4_config2_protocol *ip4_config2;
+	struct efi_ip4_config2_manual_address manual_address;
+	u8 netmask[4];
+	u8 ip[4];
+	u8 utf8[128];
+	u8 *tmp;
+
+	ret = bs->open_protocol(net_handle, &efi_ip4_config2_guid,
+					(void **)&ip4_config2, 0, 0,
+					EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+
+	if (ret != EFI_SUCCESS) {
+		error(u"set address: failed to open ipv4 config2 protocol\r\n");
+		return ret;
+	}
+
+	// Convert the UTF-16 string to UTF-8
+	if (utf16le_ascii_to_utf8(utf8, address, sizeof(utf8)) != 0) {
+		error(u"set address: failed to convert address to utf8\r\n");
+		return EFI_DEVICE_ERROR;
+	}
+
+	tmp = utf8;
+	parse_address(&tmp, ip);
+	tmp++;
+	parse_address(&tmp, netmask);
+
+	/* Set static ip and netmask */
+	memcpy(&manual_address.address, ip,
+	       sizeof(struct efi_ipv4_address));
+	memcpy(&manual_address.subnet_mask, netmask,
+	       sizeof(struct efi_ipv4_address));
+	ret = ip4_config2->set_data(ip4_config2, EFI_IP4_CONFIG2_DATA_TYPE_MANUAL_ADDRESS,
+			      sizeof(manual_address), &manual_address);
+	if (ret != EFI_SUCCESS) {
+		error(u"set address: failed to set ip address and netmask\r\n");
+		return ret;
+	}
+
+	return EFI_SUCCESS;
+}
+
+/**
+ * do_get_address() - get IP and netmask using EFI_IP4_CONFIG2_PROTOCOL
+ *
+ * Return:		status code
+ */
+static efi_status_t do_get_address(void)
+{
+	efi_uintn_t ret;
+	struct efi_ip4_config2_protocol *ip4_config2;
+	struct efi_ip4_config2_manual_address manual_address;
+	efi_uintn_t data_size;
+
+	ret = bs->open_protocol(net_handle, &efi_ip4_config2_guid,
+					(void **)&ip4_config2, 0, 0,
+					EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+
+	if (ret != EFI_SUCCESS) {
+		error(u"get address: failed to open ipv4 config2 protocol\r\n");
+		return ret;
+	}
+
+	/* Get IP address and netmask */
+	data_size = sizeof(manual_address);
+	ret = ip4_config2->get_data(ip4_config2, EFI_IP4_CONFIG2_DATA_TYPE_MANUAL_ADDRESS,
+			      &data_size, &manual_address);
+	if (ret != EFI_SUCCESS) {
+		error(u"get address: failed to get IP address and netmask\r\n");
+		return ret;
+	}
+
+	print(u"CURRENT IP: ");
+	printd(manual_address.address.ip_addr[0]);
+	print(u".");
+	printd(manual_address.address.ip_addr[1]);
+	print(u".");
+	printd(manual_address.address.ip_addr[2]);
+	print(u".");
+	printd(manual_address.address.ip_addr[3]);
+	print(u"\r\n");
+	print(u"CURRENT NETMASK: ");
+	printd(manual_address.subnet_mask.ip_addr[0]);
+	print(u".");
+	printd(manual_address.subnet_mask.ip_addr[1]);
+	print(u".");
+	printd(manual_address.subnet_mask.ip_addr[2]);
+	print(u".");
+	printd(manual_address.subnet_mask.ip_addr[3]);
+	print(u"\r\n");
+
+	return EFI_SUCCESS;
+}
+
+/**
+ * do_set_policy_static() - sets policy to static
+ *
+ * Return:		status code
+ */
+static efi_status_t do_set_policy_static(void)
+{
+	efi_uintn_t ret;
+	struct efi_ip4_config2_protocol *ip4_config2;
+	enum efi_ip4_config2_policy policy;
+
+	ret = bs->open_protocol(net_handle, &efi_ip4_config2_guid,
+					(void **)&ip4_config2, 0, 0,
+					EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+	if (ret != EFI_SUCCESS) {
+		error(u"set polict: failed to open ipv4 config2 protocol\r\n");
+		return ret;
+	}
+
+	/* Set policy to static */
+	policy = EFI_IP4_CONFIG2_POLICY_STATIC;
+	ret = ip4_config2->set_data(ip4_config2, EFI_IP4_CONFIG2_DATA_TYPE_POLICY,
+			      sizeof(policy), (void *)&policy);
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to set policy\r\n");
+		return ret;
+	}
+
+	return EFI_SUCCESS;
+}
+
+/**
+ * select_net() - get a handle for networking
+ *
+ * Return:		status code
+ */
+static efi_status_t select_net(void)
+{
+	efi_uintn_t ret;
+	efi_uintn_t num_handles;
+	efi_handle_t *current_handle;
+	efi_handle_t *handles;
+	struct efi_ip4_config2_protocol *ip4_config2;
+
+	num_handles = 0;
+	ret = bs->locate_handle_buffer(BY_PROTOCOL, &efi_ip4_config2_guid,
+				       NULL, &num_handles, &handles);
+
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to locate ipv4 config2 protocol\r\n");
+		return ret;
+	}
+
+	for (current_handle = handles; num_handles--; current_handle++) {
+		ret = bs->open_protocol(*current_handle, &efi_ip4_config2_guid,
+					      (void **)&ip4_config2, 0, 0,
+					      EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+		if (ret != EFI_SUCCESS)
+			continue;
+		break; // Get first handle that supports
+	}
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to open ipv4 config2 protocol\r\n");
+		return ret;
+	}
+
+	net_handle = *current_handle;
+
+	return EFI_SUCCESS;
+}
+
+/**
+ * setup_http() - get handles and open protocols
+ *
+ * Return:		status code
+ */
+static efi_status_t setup_http(void)
+{
+	efi_uintn_t ret;
+	struct efi_http_config_data http_config;
+	struct efi_httpv4_access_point ipv4_node;
+	struct efi_http_protocol *http;
+	struct efi_service_binding_protocol *http_service;
+
+	ret = bs->open_protocol(net_handle, &efi_http_service_binding_guid,
+					(void **)&http_service, 0, 0,
+					EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to open http service binding protocol\r\n");
+		return ret;
+	}
+
+	http_protocol_handle = NULL;
+	ret = http_service->create_child(http_service, &http_protocol_handle);
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to create an http service instance\r\n");
+		return ret;
+	}
+
+	ret = bs->open_protocol(http_protocol_handle, &efi_http_guid,
+				      (void **)&http, 0, 0, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to open http protocol\r\n");
+		return ret;
+	}
+	print(u"HTTP Service Binding: child created successfully\r\n");
+
+	http_config.http_version = HTTPVERSION11;
+	http_config.is_ipv6 = false;
+	http_config.access_point.ipv4_node = &ipv4_node;
+	ipv4_node.use_default_address = true;
+
+	ret = http->configure(http, &http_config);
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to configure http instance\r\n");
+		return ret;
+	}
+
+	return EFI_SUCCESS;
+}
+
+static void EFIAPI callback_http(struct efi_event *event, void *context)
+{
+	callback_done = 1;
+}
+
+/**
+ * execute_http() - execute http request
+ *
+ * @filename:	file name
+ * Return:	status code
+ */
+static efi_status_t execute_http(u16 *filename, void **buffer, efi_uintn_t *buffer_size)
+{
+	efi_status_t ret;
+	struct efi_http_protocol *http;
+	struct efi_http_request_data request_data;
+	struct efi_http_message request_message;
+	struct efi_http_token request_token;
+	struct efi_http_response_data response_data;
+	struct efi_http_message response_message;
+	struct efi_http_token response_token;
+	enum efi_http_status_code status_code;
+	efi_uintn_t len, sum, content_len;
+	int i;
+
+	request_data.method = HTTP_METHOD_GET;
+	request_data.url = filename;
+	request_message.data.request = &request_data;
+	request_message.header_count = 3;
+	request_message.body_length = 0;
+	request_message.body = NULL;
+
+	/* request token */
+	request_token.event = NULL;
+	request_token.status = EFI_NOT_READY;
+	request_token.message = &request_message;
+	callback_done = 0;
+	ret = bs->create_event(EVT_NOTIFY_SIGNAL,
+			TPL_CALLBACK,
+			callback_http,
+			NULL,
+			&request_token.event);
+
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to create request event\r\n");
+		return ret;
+	}
+
+	ret = bs->open_protocol(http_protocol_handle, &efi_http_guid,
+				      (void **)&http, 0, 0, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to open http protocol\r\n");
+		return ret;
+	}
+
+	ret = http->request(http, &request_token);
+
+	if (ret != EFI_SUCCESS) {
+		bs->close_event(request_token.event);
+		error(u"Failed to proceed with the http request\r\n");
+		return ret;
+	}
+
+	while (!callback_done)
+		http->poll(http);
+
+	response_data.status_code = HTTP_STATUS_UNSUPPORTED_STATUS;
+	response_message.data.response = &response_data;
+	response_message.header_count = 0;
+	response_message.headers = NULL;
+	response_message.body_length = 0;
+	response_message.body = NULL;
+	response_token.event = NULL;
+
+	ret = bs->create_event(EVT_NOTIFY_SIGNAL,
+			TPL_CALLBACK,
+			callback_http,
+			NULL,
+			&response_token.event);
+
+	if (ret != EFI_SUCCESS) {
+		bs->close_event(request_token.event);
+		error(u"Failed to create response event\r\n");
+		return ret;
+	}
+
+	response_token.status = EFI_SUCCESS;
+	response_token.message = &response_message;
+
+	callback_done = 0;
+	ret = http->response(http, &response_token);
+
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed http first response\r\n");
+		goto fail;
+	}
+
+	while (!callback_done)
+		http->poll(http);
+
+	if (response_message.data.response->status_code != HTTP_STATUS_200_OK) {
+		status_code = response_message.data.response->status_code;
+		if (status_code == HTTP_STATUS_404_NOT_FOUND) {
+			error(u"File not found\r\n");
+		} else {
+			error(u"Bad http status:\r\n");
+			printx(response_message.data.response->status_code, 2);
+			print(u"\r\n");
+		}
+		goto fail_free_hdr;
+	}
+
+	for (i = 0; i < response_message.header_count; i++) {
+		if (!memcmp(response_message.headers[i].field_name,
+			    "Content-Length", sizeof("Content-Length")))
+			content_len = efi_dectoul(response_message.headers[i].field_value);
+	}
+
+	ret = bs->allocate_pool(EFI_LOADER_CODE, content_len,
+				      buffer);
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed allocating response buffer\r\n");
+		goto fail_free_hdr;
+	}
+
+	*buffer_size = content_len;
+	len = content_len;
+	sum = 0;
+	while (len) {
+		response_message.data.response = NULL;
+		response_message.header_count = 0;
+		response_message.headers = NULL;
+		response_message.body_length = len;
+		response_message.body = *buffer + sum;
+
+		response_token.message = &response_message;
+		response_token.status = EFI_NOT_READY;
+
+		callback_done = 0;
+		ret = http->response(http, &response_token);
+		if (ret != EFI_SUCCESS) {
+			error(u"Failed http second response\r\n");
+			goto fail_free_buf;
+		}
+
+		while (!callback_done)
+			http->poll(http);
+
+		if (!response_message.body_length)
+			break;
+
+		len -= response_message.body_length;
+		sum += response_message.body_length;
+	}
+
+	if (len) {
+		ret = EFI_DEVICE_ERROR;
+		goto fail_free_buf;
+	}
+
+	if (response_message.headers)
+		bs->free_pool(response_message.headers);
+	bs->close_event(request_token.event);
+	bs->close_event(response_token.event);
+	print(u"Efi Http request executed successfully\r\n");
+	return EFI_SUCCESS;
+
+fail_free_buf:
+	bs->free_pool(*buffer);
+	*buffer = NULL;
+fail_free_hdr:
+	if (response_message.headers)
+		bs->free_pool(response_message.headers);
+fail:
+	bs->close_event(request_token.event);
+	bs->close_event(response_token.event);
+	return ret;
+}
+
+/**
+ * do_netdump_wget() - fetch a file via EFI_HTTP_PROTOCOL
+ *
+ * @filename:	file name
+ * Return:	status code
+ */
+static efi_status_t do_netdump_wget(u16 *filename)
+{
+	void *buffer;
+	efi_uintn_t buffer_size;
+	u32 crc32;
+	efi_uintn_t ret = EFI_SUCCESS;
+
+	ret = do_set_policy_static();
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to set static network policy\r\n");
+		return ret;
+	}
+
+	ret = setup_http();
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to set up http protocol\r\n");
+		return ret;
+	}
+
+	buffer = NULL;
+	ret = execute_http(filename, &buffer, &buffer_size);
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to execute http request\r\n");
+		return ret;
+	}
+
+	ret = bs->calculate_crc32(buffer, buffer_size, &crc32);
+	if (ret != EFI_SUCCESS) {
+		error(u"Calculating CRC32 failed\r\n");
+		goto out;
+	}
+
+	print(u"length: ");
+	printd(buffer_size);
+	print(u"\r\n");
+
+	print(u"crc32: 0x");
+	printx(crc32, 8);
+	print(u"\r\n");
+out:
+	bs->free_pool(buffer);
+	return ret;
+}
+
+/**
+ * get_load_options() - get load options
+ *
+ * Return:	load options or NULL
+ */
+static u16 *get_load_options(void)
+{
+	efi_status_t ret;
+	struct efi_loaded_image *loaded_image;
+
+	ret = bs->open_protocol(handle, &loaded_image_guid,
+				(void **)&loaded_image, NULL, NULL,
+				EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+	if (ret != EFI_SUCCESS) {
+		error(u"Loaded image protocol not found\r\n");
+		return NULL;
+	}
+
+	if (!loaded_image->load_options_size || !loaded_image->load_options)
+		return NULL;
+
+	return loaded_image->load_options;
+}
+
+/**
+ * efi_main() - entry point of the EFI application.
+ *
+ * @handle:	handle of the loaded image
+ * @systab:	system table
+ * Return:	status code
+ */
+efi_status_t EFIAPI efi_main(efi_handle_t image_handle,
+			     struct efi_system_table *systab)
+{
+	u16 *load_options;
+	efi_status_t ret;
+
+	handle = image_handle;
+	systable = systab;
+	cerr = systable->std_err;
+	cout = systable->con_out;
+	cin = systable->con_in;
+	bs = systable->boottime;
+	load_options = get_load_options();
+
+	if (starts_with(load_options, u"nocolor"))
+		nocolor = true;
+
+	ret = select_net();
+	if (ret != EFI_SUCCESS) {
+		error(u"Failed to set up networking\r\n");
+		return ret;
+	}
+
+	color(EFI_WHITE);
+	cls();
+	print(u"NET Dump\r\n========\r\n\r\n");
+
+	color(EFI_LIGHTBLUE);
+
+	for (;;) {
+		u16 command[BUFFER_SIZE];
+		u16 *pos;
+		efi_uintn_t ret;
+
+		efi_drain_input();
+		print(u"=> ");
+		ret = efi_input(command, sizeof(command));
+		if (ret == EFI_ABORTED)
+			break;
+		pos = skip_whitespace(command);
+		if (starts_with(pos, u"exit"))
+			break;
+		else if (starts_with(pos, u"set address "))
+			do_set_address(pos + 12);
+		else if (starts_with(pos, u"get address"))
+			do_get_address();
+		else if (starts_with(pos, u"set policy static"))
+			do_set_policy_static();
+		else if (starts_with(pos, u"wget "))
+			do_netdump_wget(pos + 5);
+		else
+			do_help();
+	}
+
+	color(EFI_LIGHTGRAY);
+	cls();
+
+	return EFI_SUCCESS;
+}
-- 
2.48.1



More information about the U-Boot mailing list