On Thu, 28 Nov 2024 at 16:44, Adriano Cordova adrianox@gmail.com wrote:

Add efi_dp_from_ipv4 to form a device path from an ipv4 address.

Signed-off-by: Adriano Cordova adrianox@gmail.com

Changes in v6:

• Complete documentation of efi_dp_from_ipv4
• Return NULL in efi_dp_from_ipv4 if allocation fails

Changes in v5:

• Add function description to efi_dp_from_ipv4
• Allocate ipv4dp in the stack
• Make efi_dp_from_ipv4 static
• Remove u-boot log messages inside efi routine
• Change (void *)(uintptr_t) to char *

Changes in v4:

• Fix memcpy mistake

Changes in v3:

• Remove some unnecessary void* casts.
• Change sizeof(struct efi_device_path_ipv4) to sizeof(*ipv4dp) in efi_dp_from_ipv4.

lib/efi_loader/efi_device_path.c | 47 ++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+)

diff --git a/lib/efi_loader/efi_device_path.c b/lib/efi_loader/efi_device_path.c index ee387e1dfd..6fcbc91e0b 100644 --- a/lib/efi_loader/efi_device_path.c +++ b/lib/efi_loader/efi_device_path.c @@ -974,6 +974,53 @@ struct efi_device_path __maybe_unused *efi_dp_from_eth(void) return start; }

+/**

• • efi_dp_from_ipv4() - set device path from IPv4 address
• • Set the device path to an ethernet device path as provided by
• • efi_dp_from_eth() concatenated with a device path of subtype
• • DEVICE_PATH_SUB_TYPE_MSG_IPV4, and an END node.
• • @ip: IPv4 local address
• • @mask: network mask
• • @srv: IPv4 remote/server address
• • Return: pointer to device path, NULL on error
• */

+static struct efi_device_path *efi_dp_from_ipv4(struct efi_ipv4_address *ip,

•                                    struct efi_ipv4_address *mask,
  

•                                    struct efi_ipv4_address *srv)
  

+{

•   struct efi_device_path *dp1, *dp2, *pos;
  

•   struct {
  

•           struct efi_device_path_ipv4 ipv4dp;
  

•           struct efi_device_path end;
  

•   } dp;
  

•   memset(&dp.ipv4dp, 0, sizeof(dp.ipv4dp));
  

•   dp.ipv4dp.dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
  

•   dp.ipv4dp.dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_IPV4;
  

•   dp.ipv4dp.dp.length = sizeof(dp.ipv4dp);
  

•   dp.ipv4dp.protocol = 6;
  

•   if (ip)
  

•           memcpy(&dp.ipv4dp.local_ip_address, ip, sizeof(*ip));
  

•   if (mask)
  

•           memcpy(&dp.ipv4dp.subnet_mask, mask, sizeof(*mask));
  

•   if (srv)
  

•           memcpy(&dp.ipv4dp.remote_ip_address, srv, sizeof(*srv));
  

•   pos = &dp.end;
  

•   memcpy(pos, &END, sizeof(END));
  

•   dp1 = efi_dp_from_eth();
  

•   if (!dp1)
  

•           return NULL;
  

•   dp2 = efi_dp_concat(dp1, (const struct efi_device_path *)&dp, 0);
  

•   efi_free_pool(dp1);
  

•   return dp2;
  

+}

/* Construct a device-path for memory-mapped image */ struct efi_device_path *efi_dp_from_mem(uint32_t memory_type, uint64_t start_address, -- 2.43.0

Reviewed-by: Ilias Apalodimas ilias.apalodimas@linaro.org

On 12/3/24 11:51, Heinrich Schuchardt wrote:

On 28.11.24 15:44, Adriano Cordova wrote:

...

Add the functions efi_net_set_addr and  efi_net_get_addr to set and get the ip address from efi code in a network agnostic way. This could also go in net_common, or be compiled conditionally for each network stack.

Signed-off-by: Adriano Cordova adrianox@gmail.com

(no changes since v5) Changes in v5:

• When possible use sizeof in memcpy instead of hardcoded value

Changes in v4:   - Removed unnecessary casts   - Changed char *ipstr by char ipstr[].

(no changes since v2)   include/efi_loader.h     |  16 +++++   lib/efi_loader/efi_net.c | 125 +++++++++++++++++++++++++++++++++++++++   2 files changed, 141 insertions(+)

diff --git a/include/efi_loader.h b/include/efi_loader.h index 39809eac1b..612bc42816 100644 --- a/include/efi_loader.h +++ b/include/efi_loader.h @@ -125,6 +125,22 @@ static inline void efi_set_bootdev(const char *dev, const char *devnr,                      size_t buffer_size) { }   #endif

+#if CONFIG_IS_ENABLED(NETDEVICES) && CONFIG_IS_ENABLED(EFI_LOADER) +void efi_net_get_addr(struct efi_ipv4_address *ip, +              struct efi_ipv4_address *mask, +              struct efi_ipv4_address *gw); +void efi_net_set_addr(struct efi_ipv4_address *ip, +              struct efi_ipv4_address *mask, +              struct efi_ipv4_address *gw); +#else +static inline void efi_net_get_addr(struct efi_ipv4_address *ip, +                     struct efi_ipv4_address *mask, +                     struct efi_ipv4_address *gw) { } +static inline void efi_net_set_addr(struct efi_ipv4_address *ip, +                     struct efi_ipv4_address *mask, +                     struct efi_ipv4_address *gw) { } +#endif

/* Maximum number of configuration tables */   #define EFI_MAX_CONFIGURATION_TABLES 16

diff --git a/lib/efi_loader/efi_net.c b/lib/efi_loader/efi_net.c index 7cd536705f..3491d4c481 100644 --- a/lib/efi_loader/efi_net.c +++ b/lib/efi_loader/efi_net.c @@ -17,6 +17,7 @@

#include <efi_loader.h>   #include <malloc.h> +#include <vsprintf.h>   #include <net.h>

static const efi_guid_t efi_net_guid = EFI_SIMPLE_NETWORK_PROTOCOL_GUID; @@ -997,3 +998,127 @@ out_of_resources:       printf("ERROR: Out of memory\n");       return EFI_OUT_OF_RESOURCES;   }

+/**

• • efi_net_get_addr() - get IP address information
• • Copy the current IP address, mask, and gateway into the
• • efi_ipv4_address structs pointed to by ip, mask and gw,
• • respectively.
• • @ip:        pointer to an efi_ipv4_address struct to
• *        be filled with the current IP address
• • @mask:    pointer to an efi_ipv4_address struct to
• *        be filled with the current network mask
• • @gw:        pointer to an efi_ipv4_address struct to be
• *        filled with the current network gateway
• */

+void efi_net_get_addr(struct efi_ipv4_address *ip, +              struct efi_ipv4_address *mask, +              struct efi_ipv4_address *gw) +{ +#ifdef CONFIG_NET_LWIP +    char ipstr[] = "ipaddr\0\0"; +    char maskstr[] = "netmask\0\0"; +    char gwstr[] = "gatewayip\0\0"; +    int idx; +    struct in_addr tmp; +    char *env;

+    idx = dev_seq(eth_get_dev());

+    if (idx < 0 || idx > 99) { +        log_err("unexpected idx %d\n", idx); +        return; +    }

+    if (idx) { +        sprintf(ipstr, "ipaddr%d", idx); +        sprintf(maskstr, "netmask%d", idx); +        sprintf(gwstr, "gatewayip%d", idx); +    }

+    env = env_get(ipstr); +    if (env && ip) { +        tmp = string_to_ip(env); +        memcpy(ip, &tmp, sizeof(tmp)); +    }

+    env = env_get(maskstr); +    if (env && mask) { +        tmp = string_to_ip(env); +        memcpy(mask, &tmp, sizeof(tmp)); +    } +    env = env_get(gwstr); +    if (env && gw) { +        tmp = string_to_ip(env); +        memcpy(gw, &tmp, sizeof(tmp)); +    } +#else +    if (ip) +        memcpy(ip, &net_ip, sizeof(net_ip)); +    if (mask) +        memcpy(mask, &net_netmask, sizeof(net_netmask)); +#endif +}

+/**

• • efi_net_set_addr() - set IP address information
• • Set the current IP address, mask, and gateway to the
• • efi_ipv4_address structs pointed to by ip, mask and gw,
• • respectively.
• • @ip:        pointer to new IP address
• • @mask:    pointer to new network mask to set
• • @gw:        pointer to new network gateway
• */

+void efi_net_set_addr(struct efi_ipv4_address *ip, +              struct efi_ipv4_address *mask, +              struct efi_ipv4_address *gw) +{ +#ifdef CONFIG_NET_LWIP +    char ipstr[] = "ipaddr\0\0"; +    char maskstr[] = "netmask\0\0"; +    char gwstr[] = "gatewayip\0\0"; +    int idx; +    struct in_addr *addr; +    char tmp[46];

+    idx = dev_seq(eth_get_dev());

+    if (idx < 0 || idx > 99) { +        log_err("unexpected idx %d\n", idx); +        return; +    }

The same logic can be found in LWIP's dhcp_loop(), get_udev_ipv4_info().

After this series I think it is time to carve it out into a function.

It is unclear to me form where the idx > 99 in the LWIP stack is derived. struct udevice device defines seq_ as integer.

...

+    if (idx) { +        sprintf(ipstr, "ipaddr%d", idx); +        sprintf(maskstr, "netmask%d", idx); +        sprintf(gwstr, "gatewayip%d", idx);

@Jerome,

The usage of environment variables ipaddr#, netmask#, gatewayip# by the LWIP stack should be documented in doc/usage/environment.rst. Could you, please, provide a patch.

https://lists.denx.de/pipermail/u-boot/2024-December/573696.html

Thanks!

On Thu, 28 Nov 2024 at 16:44, Adriano Cordova adrianox@gmail.com wrote:

Add efi_dp_from_http to form a device path from HTTP. The device path is the concatenation of the device path returned by efi_dp_from_ipv4 together with an URI node and an END node.

Signed-off-by: Adriano Cordova adrianox@gmail.com Reviewed-by: Heinrich Schuchardt heinrich.schuchardt@canonical.com

---

include/efi_loader.h | 1 + lib/efi_loader/efi_device_path.c | 64 ++++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+)

diff --git a/include/efi_loader.h b/include/efi_loader.h index 612bc42816..96b204dfc3 100644 --- a/include/efi_loader.h +++ b/include/efi_loader.h @@ -872,6 +872,7 @@ struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part); struct efi_device_path *efi_dp_from_file(const struct efi_device_path *dp, const char *path); struct efi_device_path *efi_dp_from_eth(void); +struct efi_device_path *efi_dp_from_http(const char *server); struct efi_device_path *efi_dp_from_mem(uint32_t mem_type, uint64_t start_address, size_t size); diff --git a/lib/efi_loader/efi_device_path.c b/lib/efi_loader/efi_device_path.c index 6fcbc91e0b..a6d4300686 100644 --- a/lib/efi_loader/efi_device_path.c +++ b/lib/efi_loader/efi_device_path.c @@ -1021,6 +1021,70 @@ static struct efi_device_path *efi_dp_from_ipv4(struct efi_ipv4_address *ip, return dp2; }

+/**

• • efi_dp_from_http() - set device path from http
• • Set the device path to an IPv4 path as provided by efi_dp_from_ipv4
• • concatenated with a device path of subtype DEVICE_PATH_SUB_TYPE_MSG_URI,
• • and an END node.
• • @server: URI of remote server
• • Return: pointer to HTTP device path, NULL on error
• */

+struct efi_device_path *efi_dp_from_http(const char *server) +{

•   struct efi_device_path *dp1, *dp2;
  

•   struct efi_device_path_uri *uridp;
  

•   efi_uintn_t uridp_len;
  

•   char *pos;
  

•   char tmp[128];
  

•   struct efi_ipv4_address ip;
  

•   struct efi_ipv4_address mask;
  

•   if ((server && strlen("http://") + strlen(server) + 1  > sizeof(tmp)) ||
  

•       (!server && IS_ENABLED(CONFIG_NET_LWIP)))
  

•           return NULL;
  

•   efi_net_get_addr(&ip, &mask, NULL);
  

•   dp1 = efi_dp_from_ipv4(&ip, &mask, NULL);
  

•   if (!dp1)
  

•           return NULL;
  

•   strcpy(tmp, "http://");
  

•   if (server) {
  

•           strlcat(tmp, server, sizeof(tmp));
  

+#if !IS_ENABLED(CONFIG_NET_LWIP)

•   }
  

•   else {
  

•           ip_to_string(net_server_ip, tmp + strlen("http://"));
  

+#endif

•   }
  

•   uridp_len = sizeof(struct efi_device_path) + strlen(tmp) + 1;
  

•   uridp = efi_alloc(uridp_len + sizeof(END));
  

•   if (!uridp) {
  

•           log_err("Out of memory\n");
  

•           return NULL;
  

•   }
  

•   uridp->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
  

•   uridp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_URI;
  

•   uridp->dp.length = uridp_len;
  

•   debug("device path: setting uri device path to %s\n", tmp);
  

•   memcpy(uridp->uri, tmp, strlen(tmp) + 1);
  

•   pos = (char *)uridp + uridp_len;
  

•   memcpy(pos, &END, sizeof(END));
  

•   dp2 = efi_dp_concat(dp1, (const struct efi_device_path *)uridp, 0);
  

•   efi_free_pool(uridp);
  

•   efi_free_pool(dp1);
  

•   return dp2;
  

+}

/* Construct a device-path for memory-mapped image */ struct efi_device_path *efi_dp_from_mem(uint32_t memory_type, uint64_t start_address, -- 2.43.0

Reviewed-by: Ilias Apalodimas ilias.apalodimas@linaro.org

On 28.11.24 15:44, Adriano Cordova wrote:

Set the device path of the efi boot device to an HTTP device path (as formed by efi_dp_from_http) when the next boot stage is loaded using wget (i.e., when wget is used with wget_info.set_bootdev=1).

When loaded from HTTP, the device path should account for it so that the next boot stage is aware (e.g. grub only loads its http stack if it itself was loaded from http, and it checks this from its device path).

Signed-off-by: Adriano Cordova adrianox@gmail.com

Reviewed-by: Heinrich Schuchardt xypron.glpk@gmx.de

---

Changes in v6:

• Add error handling to efi_net_set_dp and put it inside efi_set_bootdev, reducing the number of calls to efi functions outside efi code.
• Free net_dp before an update
• Complete documentation for efi_net_get_dp. Error handling: returns NULL on error

Changes in v5:

• Add description of net_dp
• Change a void** for an efi_device_path**

(no changes since v2)

include/efi_loader.h | 5 +++ lib/efi_loader/efi_bootbin.c | 40 +++++++++++++---------- lib/efi_loader/efi_device_path.c | 5 +-- lib/efi_loader/efi_net.c | 55 +++++++++++++++++++++++++++++++- net/lwip/wget.c | 5 ++- net/wget.c | 2 +- 6 files changed, 89 insertions(+), 23 deletions(-)

diff --git a/include/efi_loader.h b/include/efi_loader.h index 96b204dfc3..0da0248db4 100644 --- a/include/efi_loader.h +++ b/include/efi_loader.h @@ -126,6 +126,10 @@ static inline void efi_set_bootdev(const char *dev, const char *devnr, #endif

#if CONFIG_IS_ENABLED(NETDEVICES) && CONFIG_IS_ENABLED(EFI_LOADER) +/* Call this to update the current device path of the efi net device */ +efi_status_t efi_net_set_dp(const char *dev, const char *server); +/* Call this to get the current device path of the efi net device */ +void efi_net_get_dp(struct efi_device_path **dp); void efi_net_get_addr(struct efi_ipv4_address *ip, struct efi_ipv4_address *mask, struct efi_ipv4_address *gw); @@ -133,6 +137,7 @@ void efi_net_set_addr(struct efi_ipv4_address *ip, struct efi_ipv4_address *mask, struct efi_ipv4_address *gw); #else +static inline void efi_net_get_dp(struct efi_device_path **dp) { } static inline void efi_net_get_addr(struct efi_ipv4_address *ip, struct efi_ipv4_address *mask, struct efi_ipv4_address *gw) { } diff --git a/lib/efi_loader/efi_bootbin.c b/lib/efi_loader/efi_bootbin.c index a87006b3c0..f8d3ee0bcf 100644 --- a/lib/efi_loader/efi_bootbin.c +++ b/lib/efi_loader/efi_bootbin.c @@ -93,24 +93,32 @@ void efi_set_bootdev(const char *dev, const char *devnr, const char *path, image_addr = buffer; image_size = buffer_size;

+#if IS_ENABLED(CONFIG_NETDEVICES)

• ret = efi_net_set_dp(dev, devnr);
• if (ret != EFI_SUCCESS)

• goto error;
  

+#endif

• ret = efi_dp_from_name(dev, devnr, path, &device, &image);

• if (ret == EFI_SUCCESS) {

• bootefi_device_path = device;
  

• if (image) {
  

• 	/* FIXME: image should not contain device */
  

• 	struct efi_device_path *image_tmp = image;
  

• 	efi_dp_split_file_path(image, &device, &image);
  

• 	efi_free_pool(image_tmp);
  

• }
  

• bootefi_image_path = image;
  

• log_debug("- boot device %pD\n", device);
  

• if (image)
  

• 	log_debug("- image %pD\n", image);
  

• } else {

• log_debug("- efi_dp_from_name() failed, err=%lx\n", ret);
  

• efi_clear_bootdev();
  

• if (ret != EFI_SUCCESS)

• goto error;
  

• bootefi_device_path = device;
• if (image) {

• /* FIXME: image should not contain device */
  

• struct efi_device_path *image_tmp = image;
  

• efi_dp_split_file_path(image, &device, &image);
  

• efi_free_pool(image_tmp);
  

  }
• bootefi_image_path = image;
• log_debug("- boot device %pD\n", device);
• if (image)

• log_debug("- image %pD\n", image);
  

• return;

+error:

• log_debug("- efi_dp_from_name() failed, err=%lx\n", ret);

• efi_clear_bootdev(); }

  /**

diff --git a/lib/efi_loader/efi_device_path.c b/lib/efi_loader/efi_device_path.c index a6d4300686..5eae6fd39c 100644 --- a/lib/efi_loader/efi_device_path.c +++ b/lib/efi_loader/efi_device_path.c @@ -1185,8 +1185,9 @@ efi_status_t efi_dp_from_name(const char *dev, const char *devnr,

dp = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE,
		     (uintptr_t)image_addr, image_size);

• } else if (IS_ENABLED(CONFIG_NETDEVICES) && !strcmp(dev, "Net")) {

• dp = efi_dp_from_eth();
  

• } else if (IS_ENABLED(CONFIG_NETDEVICES) &&

•    (!strcmp(dev, "Net") || !strcmp(dev, "Http"))) {
  

• efi_net_get_dp(&dp);
  

  } else if (!strcmp(dev, "Uart")) { dp = efi_dp_from_uart(); } else {

diff --git a/lib/efi_loader/efi_net.c b/lib/efi_loader/efi_net.c index 3491d4c481..e8af2e3d95 100644 --- a/lib/efi_loader/efi_net.c +++ b/lib/efi_loader/efi_net.c @@ -16,6 +16,7 @@ */

#include <efi_loader.h> +#include <dm.h> #include <malloc.h> #include <vsprintf.h> #include <net.h> @@ -32,6 +33,13 @@ static int rx_packet_idx; static int rx_packet_num; static struct efi_net_obj *netobj;

+/*

• • The current network device path. This device path is updated when a new
• • bootfile is downloaded from the network. If then the bootfile is loaded
• • as an efi image, net_dp is passed as the device path of the loaded image.
• */

+static struct efi_device_path *net_dp;

• /*
  • The notification function of this event is called in every timer cycle
  • to check if a new network packet has been received.

@@ -902,8 +910,10 @@ efi_status_t efi_net_register(void) &netobj->net); if (r != EFI_SUCCESS) goto failure_to_add_protocol;

• if (!net_dp)

• efi_net_set_dp("Net", NULL);
  

  r = efi_add_protocol(&netobj->header, &efi_guid_device_path,

• 	     efi_dp_from_eth());
  

• 	     net_dp);
  

  if (r != EFI_SUCCESS) goto failure_to_add_protocol; r = efi_add_protocol(&netobj->header, &efi_pxe_base_code_protocol_guid,

@@ -999,6 +1009,49 @@ out_of_resources: return EFI_OUT_OF_RESOURCES; }

+/**

• • efi_net_set_dp() - set device path of efi net device
• • This gets called to update the device path when a new boot
• • file is downloaded
• • @dev: dev to set the device path from
• • @server: remote server address
• • Return: status code
• */

+efi_status_t efi_net_set_dp(const char *dev, const char *server) +{

• efi_free_pool(net_dp);
• net_dp = NULL;
• if (!strcmp(dev, "Net"))

• net_dp = efi_dp_from_eth();
  

• else if (!strcmp(dev, "Http"))

• net_dp = efi_dp_from_http(server);
  

• if (!net_dp)

• return EFI_OUT_OF_RESOURCES;
  

• return EFI_SUCCESS;

+}

+/**

• • efi_net_get_dp() - get device path of efi net device
• • Produce a copy of the current device path
• • @dp: copy of the current device path, or NULL on error
• */

+void efi_net_get_dp(struct efi_device_path **dp) +{

• if (!dp)

• return;
  

• if (!net_dp)

• efi_net_set_dp("Net", NULL);
  

• if (net_dp)

• *dp = efi_dp_dup(net_dp);
  

+}

• /**
  • efi_net_get_addr() - get IP address information

diff --git a/net/lwip/wget.c b/net/lwip/wget.c index 2becb02f7b..fcc0e62512 100644 --- a/net/lwip/wget.c +++ b/net/lwip/wget.c @@ -260,10 +260,9 @@ static void httpc_result_cb(void *arg, httpc_result_t httpc_result, printf("%u bytes transferred in %lu ms (", rx_content_len, elapsed); print_size(rx_content_len / elapsed * 1000, "/s)\n"); printf("Bytes transferred = %lu (%lx hex)\n", ctx->size, ctx->size);

• if (wget_info->set_bootdev) {

• efi_set_bootdev("Net", "", ctx->path, map_sysmem(ctx->saved_daddr, 0),
  

• if (wget_info->set_bootdev)

• efi_set_bootdev("Http", ctx->server_name, ctx->path, map_sysmem(ctx->saved_daddr, 0),
  	rx_content_len);
  

• } wget_lwip_set_file_size(rx_content_len); if (env_set_hex("filesize", rx_content_len) || env_set_hex("fileaddr", ctx->saved_daddr)) {

diff --git a/net/wget.c b/net/wget.c index f3b43b06b8..d338eaf4ef 100644 --- a/net/wget.c +++ b/net/wget.c @@ -447,7 +447,7 @@ static void wget_handler(uchar *pkt, u16 dport, net_set_state(wget_loop_state); wget_info->file_size = net_boot_file_size; if (wget_info->method == WGET_HTTP_METHOD_GET && wget_info->set_bootdev) {

• 	efi_set_bootdev("Net", "", image_url,
  

• 	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);
  

On 28.11.24 15:44, Adriano Cordova wrote:

Add network-stack agnostic way to send an http request and parse http headers from efi drivers. This uses wget as a backend and communicates with it via efi_wget_info.

The function efi_net_do_request allocates a buffer on behalf of an efi application using efi_alloc and passes it to wget to receive the data. If the method is GET and the buffer is too small, it re-allocates the buffer based on the last received Content-Length header and tries again. If the method is HEAD it just issues one request. So issuing a HEAD request (to update Content-Length) and then a GET request is preferred but not required.

The function efi_net_parse_headers parses a raw buffer containing an http header into an array of EFI specific 'http_header' structs.

Signed-off-by: Adriano Cordova adrianox@gmail.com

Reviewed-by: Heinrich Schuchardt xypron.glpk@gmx.de

---

(no changes since v4)

Changes in v4:

• Remove void* casts
• Add documentation

Changes in v3:

• Add a struct wget_http_info efi_wget_info for efi_net to pass to wget when issuing wget requests, instead of using the old wget_info (see v2 of the series 'wget: Expose wget to applications').
• Let a pointer to the http status code be passed to efi_net_do_request for it to fill it for the client after a request. include/efi_loader.h | 13 ++++ lib/efi_loader/efi_net.c | 155 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 168 insertions(+)

diff --git a/include/efi_loader.h b/include/efi_loader.h index 0da0248db4..b6f865ca76 100644 --- a/include/efi_loader.h +++ b/include/efi_loader.h @@ -16,6 +16,7 @@ #include <image.h> #include <pe.h> #include <linux/list.h> +#include <linux/sizes.h> #include <linux/oid_registry.h>

struct blk_desc; @@ -136,6 +137,18 @@ void efi_net_get_addr(struct efi_ipv4_address *ip, void efi_net_set_addr(struct efi_ipv4_address *ip, struct efi_ipv4_address *mask, struct efi_ipv4_address *gw); +efi_status_t efi_net_do_request(u8 *url, enum efi_http_method method, void **buffer,

• 		u32 *status_code, ulong *file_size, char *headers_buffer);
  

+#define MAX_HTTP_HEADERS_SIZE SZ_64K +#define MAX_HTTP_HEADERS 100 +#define MAX_HTTP_HEADER_NAME 128 +#define MAX_HTTP_HEADER_VALUE 512 +struct http_header {

• uchar name[MAX_HTTP_HEADER_NAME];
• uchar value[MAX_HTTP_HEADER_VALUE];

+};

+void efi_net_parse_headers(ulong *num_headers, struct http_header *headers); #else static inline void efi_net_get_dp(struct efi_device_path **dp) { } static inline void efi_net_get_addr(struct efi_ipv4_address *ip, diff --git a/lib/efi_loader/efi_net.c b/lib/efi_loader/efi_net.c index e8af2e3d95..368f62c5b2 100644 --- a/lib/efi_loader/efi_net.c +++ b/lib/efi_loader/efi_net.c @@ -17,6 +17,7 @@

#include <efi_loader.h> #include <dm.h> +#include <linux/sizes.h> #include <malloc.h> #include <vsprintf.h> #include <net.h> @@ -40,6 +41,12 @@ static struct efi_net_obj *netobj; */ static struct efi_device_path *net_dp;

+static struct wget_http_info efi_wget_info = {

• .set_bootdev = false,
• .check_buffer_size = true,

+};

• /*
  • The notification function of this event is called in every timer cycle
  • to check if a new network packet has been received.

@@ -1175,3 +1182,151 @@ void efi_net_set_addr(struct efi_ipv4_address *ip, memcpy(&net_netmask, mask, sizeof(*mask)); #endif }

+/**

• • efi_net_set_buffer() - allocate a buffer of min 64K
• • @buffer: allocated buffer
• • @size: desired buffer size
• • Return: status code
• */

+static efi_status_t efi_net_set_buffer(void **buffer, size_t size) +{

• efi_status_t ret = EFI_SUCCESS;
• if (size < SZ_64K)

• size = SZ_64K;
  

• efi_free_pool(*buffer);
• *buffer = efi_alloc(size);
• if (!*buffer)

• ret = EFI_OUT_OF_RESOURCES;
  

• efi_wget_info.buffer_size = (ulong)size;
• return ret;

+}

+/**

• • efi_net_parse_headers() - parse HTTP headers
• • Parses the raw buffer efi_wget_info.headers into an array headers
• • of efi structs http_headers. The array should be at least
• • MAX_HTTP_HEADERS long.
• • @num_headers: number of headers
• • @headers: caller provided array of struct http_headers
• */

+void efi_net_parse_headers(ulong *num_headers, struct http_header *headers) +{

• if (!num_headers || !headers)

• return;
  

• // Populate info with http headers.
• *num_headers = 0;
• const uchar *line_start = efi_wget_info.headers;
• const uchar *line_end;
• ulong count;
• struct http_header *current_header;
• const uchar *separator;
• size_t name_length, value_length;
• // Skip the first line (request or status line)
• line_end = strstr(line_start, "\r\n");
• if (line_end)

• line_start = line_end + 2;
  

• while ((line_end = strstr(line_start, "\r\n")) != NULL) {

• count = *num_headers;
  

• if (line_start == line_end || count >= MAX_HTTP_HEADERS)
  

• 	break;
  

• current_header = headers + count;
  

• separator = strchr(line_start, ':');
  

• if (separator) {
  

• 	name_length = separator - line_start;
  

• 	++separator;
  

• 	while (*separator == ' ')
  

• 		++separator;
  

• 	value_length = line_end - separator;
  

• 	if (name_length < MAX_HTTP_HEADER_NAME &&
  

• 	    value_length < MAX_HTTP_HEADER_VALUE) {
  

• 		strncpy(current_header->name, line_start, name_length);
  

• 		current_header->name[name_length] = '\0';
  

• 		strncpy(current_header->value, separator, value_length);
  

• 		current_header->value[value_length] = '\0';
  

• 		(*num_headers)++;
  

• 	}
  

• }
  

• line_start = line_end + 2;
  

• }

+}

+/**

• • efi_net_do_request() - issue an HTTP request using wget
• • @url: url
• • @method: HTTP method
• • @buffer: data buffer
• • @status_code: HTTP status code
• • @file_size: file size in bytes
• • @headers_buffer: headers buffer
• • Return: status code
• */

+efi_status_t efi_net_do_request(u8 *url, enum efi_http_method method, void **buffer,

• 		u32 *status_code, ulong *file_size, char *headers_buffer)
  

+{

• efi_status_t ret = EFI_SUCCESS;
• int wget_ret;
• static bool last_head;
• if (!buffer || !file_size)

• return EFI_ABORTED;
  

• efi_wget_info.method = (enum wget_http_method)method;
• efi_wget_info.headers = headers_buffer;
• switch (method) {
• case HTTP_METHOD_GET:

• ret = efi_net_set_buffer(buffer, last_head ? (size_t)efi_wget_info.hdr_cont_len : 0);
  

• if (ret != EFI_SUCCESS)
  

• 	goto out;
  

• wget_ret = wget_request((ulong)*buffer, url, &efi_wget_info);
  

• if ((ulong)efi_wget_info.hdr_cont_len > efi_wget_info.buffer_size) {
  

• 	// Try again with updated buffer size
  

• 	ret = efi_net_set_buffer(buffer, (size_t)efi_wget_info.hdr_cont_len);
  

• 	if (ret != EFI_SUCCESS)
  

• 		goto out;
  

• 	if (wget_request((ulong)*buffer, url, &efi_wget_info)) {
  

• 		efi_free_pool(*buffer);
  

• 		ret = EFI_DEVICE_ERROR;
  

• 		goto out;
  

• 	}
  

• } else if (wget_ret) {
  

• 	efi_free_pool(*buffer);
  

• 	ret = EFI_DEVICE_ERROR;
  

• 	goto out;
  

• }
  

• // Pass the actual number of received bytes to the application
  

• *file_size = efi_wget_info.file_size;
  

• *status_code = efi_wget_info.status_code;
  

• last_head = false;
  

• break;
  

• case HTTP_METHOD_HEAD:

• ret = efi_net_set_buffer(buffer, 0);
  

• if (ret != EFI_SUCCESS)
  

• 	goto out;
  

• wget_request((ulong)*buffer, url, &efi_wget_info);
  

• *file_size = 0;
  

• *status_code = efi_wget_info.status_code;
  

• last_head = true;
  

• break;
  

• default:

• ret = EFI_UNSUPPORTED;
  

• break;
  

• }

+out:

• return ret;

+}

[...]

--- /dev/null +++ b/lib/efi_loader/efi_ipconfig.c @@ -0,0 +1,214 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/*

• • Implementation of EFI_IP4_CONFIG2_PROTOCOL
• */

+#include <efi_loader.h> +#include <image.h> +#include <malloc.h> +#include <mapmem.h> +#include <net.h>

+static const efi_guid_t efi_ip4_config2_guid = EFI_IP4_CONFIG2_PROTOCOL_GUID;

+struct efi_ip4_config2_manual_address current_http_ip; +static enum efi_ip4_config2_policy current_policy; +static char current_mac_addr[32];

+/* EFI_IP4_CONFIG2_PROTOCOL */

+/*

• • efi_ip4_config2_set_data() - Set the configuration for the EFI IPv4 network
• • stack running on the communication device
• • This function implements EFI_IP4_CONFIG2_PROTOCOL.SetData()
• • See the Unified Extensible Firmware Interface
• • (UEFI) specification for details.
• • @this: pointer to the protocol instance
• • @data_type: the type of data to set
• • @data_size: size of the buffer pointed to by data in bytes
• • @data: the data buffer to set
• • Return: status code
• */

+static efi_status_t EFIAPI efi_ip4_config2_set_data(struct efi_ip4_config2_protocol *this,

•                                               enum efi_ip4_config2_data_type data_type,
  

•                                               efi_uintn_t data_size,
  

•                                               void *data)
  

+{

•   EFI_ENTRY("%p, %d, %zu, %p", this, data_type, data_size, data);
  

•   efi_status_t ret = EFI_SUCCESS;
  

•   if (!this || (data && !data_size) || (!data && data_size))
  

•           return EFI_EXIT(EFI_INVALID_PARAMETER);
  

•   switch (data_type) {
  

•   case EFI_IP4_CONFIG2_DATA_TYPE_INTERFACEINFO:
  

•           return EFI_EXIT(EFI_WRITE_PROTECTED);
  

•   case EFI_IP4_CONFIG2_DATA_TYPE_MANUAL_ADDRESS:
  

•           if (current_policy != EFI_IP4_CONFIG2_POLICY_STATIC)
  

•                   return EFI_EXIT(EFI_WRITE_PROTECTED);
  

•           if (data_size == 0 && !data) {
  

we usually do if (!data_size && ...)

•                   memset((void *)&current_http_ip, 0,
  

•                          sizeof(current_http_ip));
  

•                   return EFI_EXIT(EFI_SUCCESS);
  

•           }
  

•           if (data && data_size == sizeof(struct efi_ip4_config2_manual_address)) {
  

•                   memcpy((void *)&current_http_ip, data,
  

•                          sizeof(struct efi_ip4_config2_manual_address));
  

•                   efi_net_set_addr(&current_http_ip.address,
  

•                                    &current_http_ip.subnet_mask, NULL);
  

•                   return EFI_EXIT(EFI_SUCCESS);
  

•           }
  

•           return EFI_EXIT(EFI_INVALID_PARAMETER);
  

•   case EFI_IP4_CONFIG2_DATA_TYPE_POLICY:
  

•                   if (data && data_size == sizeof(enum efi_ip4_config2_policy)) {
  

•                           current_policy = *(enum efi_ip4_config2_policy *)data;
  

•                           return EFI_EXIT(EFI_SUCCESS);
  

•                   }
  

The spec is a bit cryptic here, but it says

EFI_INVALID_PARAMETER One or more of the following are TRUE: - This is NULL. - One or more fields in Data and DataSize do not match the requirement of the data type indicated by DataType

and

EFI_BAD_BUFFER_SIZE - The DataSize does not match the size of the type indicated by DataType

I think we should return EFI_BAD_BUFFER_SIZE on both of the checks above.

Heinrich any idea?

•           return EFI_EXIT(EFI_INVALID_PARAMETER);
  

•   default:
  

•           return EFI_EXIT(EFI_UNSUPPORTED);
  

•   }
  

•   return EFI_EXIT(ret);
  

+}

+/*

• • efi_ip4_config2_get_data() - Get the configuration for the EFI IPv4 network
• • stack running on the communication device
• • This function implements EFI_IP4_CONFIG2_PROTOCOL.GetData()
• • See the Unified Extensible Firmware Interface
• • (UEFI) specification for details.
• • @this: pointer to the protocol instance
• • @data_type: the type of data to get
• • @data_size: size
• • @data: the data buffer
• • Return: status code
• */

+static efi_status_t EFIAPI efi_ip4_config2_get_data(struct efi_ip4_config2_protocol *this,

•                                               enum efi_ip4_config2_data_type data_type,
  

•                                               efi_uintn_t *data_size,
  

•                                               void *data)
  

+{

•   EFI_ENTRY("%p, %d, %p, %p", this, data_type, data_size, data);
  

•   efi_status_t ret = EFI_SUCCESS;
  

•   struct efi_ip4_config2_interface_info *info;
  

•   int tmp;
  

•   if (!this || !data_size)
  

•           return EFI_EXIT(EFI_INVALID_PARAMETER);
  

•   if (*data_size && !data)
  

•           return EFI_EXIT(EFI_INVALID_PARAMETER);
  

•   tmp = sizeof(struct efi_ip4_config2_interface_info) + sizeof(struct efi_ip4_route_table);
  

•   switch (data_type) {
  

•   case EFI_IP4_CONFIG2_DATA_TYPE_INTERFACEINFO:
  

•           if (*data_size < tmp) {
  

•                   *data_size = tmp;
  

•                   return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
  

•           }
  

•           info = (struct efi_ip4_config2_interface_info *)data;
  

•           memset(info, 0, sizeof(*info));
  

•           info->hw_address_size = 6;
  

•           memcpy(info->hw_address.mac_addr, current_mac_addr, 6);
  

•           // Set the route table size
  

•           info->route_table_size = 0;
  

•           break;
  

•   case EFI_IP4_CONFIG2_DATA_TYPE_MANUAL_ADDRESS:
  

•           if (*data_size < sizeof(struct efi_ip4_config2_manual_address)) {
  

•                   *data_size = sizeof(struct efi_ip4_config2_manual_address);
  

•                   return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
  

•           }
  

•           efi_net_get_addr(&current_http_ip.address, &current_http_ip.subnet_mask, NULL);
  

•           memcpy(data, (void *)&current_http_ip,
  

•                  sizeof(struct efi_ip4_config2_manual_address));
  

•           break;
  

•   default:
  

•           return EFI_EXIT(EFI_UNSUPPORTED);
  

The spec doesn't have EFI_UNSUPPORTED for GetData. Instead it says EFI_NOT_FOUND "The specified configuration data is not found.". So we should return that for every data type that was marked as EFI_UNSUPPORTED (I think)

•   }
  

•   return EFI_EXIT(ret);
  

+}

+/*

• • efi_ip4_config2_register_notify() - Register an event that is to be signaled whenever
• • a configuration process on the specified configuration
• • data is done
• • This function implements EFI_IP4_CONFIG2_PROTOCOL.RegisterDataNotify()
• • See the Unified Extensible Firmware Interface
• • (UEFI) specification for details.
• • @this: pointer to the protocol instance
• • @data_type: the type of data to register the event for
• • @event: the event to register
• • Return: status code
• */

+static efi_status_t EFIAPI efi_ip4_config2_register_notify(struct efi_ip4_config2_protocol *this,

•                                                      enum efi_ip4_config2_data_type data_type,
  

•                                                      struct efi_event *event)
  

+{

•   EFI_ENTRY("%p, %d, %p", this, data_type, event);
  

•   return EFI_EXIT(EFI_UNSUPPORTED);
  

+}

+/*

• • efi_ip4_config2_unregister_notify() - Remove a previously registered eventfor
• • the specified configuration data
• • This function implements EFI_IP4_CONFIG2_PROTOCOL.UnregisterDataNotify()
• • See the Unified Extensible Firmware Interface
• • (UEFI) specification for details.
• • @this: pointer to the protocol instance
• • @data_type: the type of data to remove the event for
• • @event: the event to unregister
• • Return: status code
• */

+static efi_status_t EFIAPI efi_ip4_config2_unregister_notify(struct efi_ip4_config2_protocol *this,

•                                                        enum efi_ip4_config2_data_type data_type,
  

•                                                        struct efi_event *event)
  

+{

•   EFI_ENTRY("%p, %d, %p", this, data_type, event);
  

•   return EFI_EXIT(EFI_UNSUPPORTED);
  

+}

+/**

• • efi_ipconfig_register() - register the ip4_config2 protocol
• */

+efi_status_t efi_ipconfig_register(const efi_handle_t handle,

•                              struct efi_ip4_config2_protocol *ip4config)
  

+{

•   efi_status_t r = EFI_SUCCESS;
  

•   r = efi_add_protocol(handle, &efi_ip4_config2_guid,
  

•                        ip4config);
  

•   if (r != EFI_SUCCESS) {
  

•           log_err("ERROR: Failure to add protocol\n");
  

•           return r;
  

•   }
  

•   memcpy(current_mac_addr, eth_get_ethaddr(), 6);
  

You don't need the static variable for this, just copy it on the fly when required.

•   ip4config->set_data = efi_ip4_config2_set_data;
  

•   ip4config->get_data = efi_ip4_config2_get_data;
  

•   ip4config->register_data_notify = efi_ip4_config2_register_notify;
  

•   ip4config->unregister_data_notify = efi_ip4_config2_unregister_notify;
  

•   return EFI_SUCCESS;
  

+} diff --git a/lib/efi_loader/efi_net.c b/lib/efi_loader/efi_net.c index 368f62c5b2..d3a8deecd0 100644 --- a/lib/efi_loader/efi_net.c +++ b/lib/efi_loader/efi_net.c @@ -60,11 +60,12 @@ static struct efi_event *wait_for_packet; /**

• struct efi_net_obj - EFI object representing a network interface

• • @header: EFI object header
• • @net: simple network protocol interface
• • @net_mode: status of the network interface
• • @pxe: PXE base code protocol interface
• • @pxe_mode: status of the PXE base code protocol

• • @header: EFI object header
• • @net: simple network protocol interface
• • @net_mode: status of the network interface
• • @pxe: PXE base code protocol interface
• • @pxe_mode: status of the PXE base code protocol
• • @ip4_config2: IP4 Config2 protocol interface
  */

struct efi_net_obj { struct efi_object header; @@ -72,6 +73,9 @@ struct efi_net_obj { struct efi_simple_network_mode net_mode; struct efi_pxe_base_code_protocol pxe; struct efi_pxe_mode pxe_mode; +#if IS_ENABLED(CONFIG_EFI_IP4_CONFIG2_PROTOCOL)

•   struct efi_ip4_config2_protocol ip4_config2;
  

+#endif };

/* @@ -999,6 +1003,12 @@ efi_status_t efi_net_register(void) return r; }

+#ifdef CONFIG_EFI_IP4_CONFIG2_PROTOCOL

#if IS_ENABLED here as well etc

•   r = efi_ipconfig_register(&netobj->header, &netobj->ip4_config2);
  

•   if (r != EFI_SUCCESS)
  

•           goto failure_to_add_protocol;
  

+#endif

•   return EFI_SUCCESS;
  

failure_to_add_protocol: printf("ERROR: Failure to add protocol\n"); -- 2.43.0

Thanks /Ilias

El mar, 3 dic 2024 a las 10:11, Ilias Apalodimas (< ilias.apalodimas@linaro.org>) escribió:

On Thu, 28 Nov 2024 at 16:44, Adriano Cordova adrianox@gmail.com wrote:

...

Add a test for the EFI_HTTP_PROTOCOL and EFI_SEVICE_BINDING_PROTOCOL.

Signed-off-by: Adriano Cordova adrianox@gmail.com

(no changes since v2) lib/efi_selftest/Makefile | 2 +- lib/efi_selftest/efi_selftest_http.c | 315 +++++++++++++++++++++++++++ 2 files changed, 316 insertions(+), 1 deletion(-) create mode 100644 lib/efi_selftest/efi_selftest_http.c

diff --git a/lib/efi_selftest/Makefile b/lib/efi_selftest/Makefile index 414701893f..140c08effc 100644 --- a/lib/efi_selftest/Makefile +++ b/lib/efi_selftest/Makefile @@ -52,7 +52,7 @@ efi_selftest_watchdog.o

obj-$(CONFIG_EFI_ECPT) += efi_selftest_ecpt.o obj-$(CONFIG_NETDEVICES) += efi_selftest_snp.o

+obj-$(CONFIG_EFI_HTTP_PROTOCOL) += efi_selftest_http.o obj-$(CONFIG_EFI_DEVICE_PATH_TO_TEXT) += efi_selftest_devicepath.o obj-$(CONFIG_EFI_UNICODE_COLLATION_PROTOCOL2) += \ efi_selftest_unicode_collation.o diff --git a/lib/efi_selftest/efi_selftest_http.c

b/lib/efi_selftest/efi_selftest_http.c

...

new file mode 100644 index 0000000000..ce3cf33887 --- /dev/null +++ b/lib/efi_selftest/efi_selftest_http.c @@ -0,0 +1,315 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/*

• • efi_selftest_http
• • This unit test covers the IPv4 Config2 Protocol, Http Service

Binding Protocol,

...

• • and Http Protocol.
• • An Http HEAD and an Http GET request are sent to the same

destination. The test

...

• • is successful if the HEAD request gets a response with a valid

Content-Length header

...

• • and the subsequent GET request receives the amount of bytes informed

by the previous

...

• • Content-Length header.
• */

+#include <efi_selftest.h> +#include <charset.h> +#include <net.h>

+static struct efi_boot_services *boottime;

+static struct efi_http_protocol *http; +static struct efi_service_binding_protocol *http_service; +static struct efi_ip4_config2_protocol *ip4_config2; +static efi_handle_t http_protocol_handle;

+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 int callback_done;

+/*

• • Setup unit test.
• • @handle: handle of the loaded image
• • @systable: system table
• • Return: EFI_ST_SUCCESS for success
• */

+static int setup(const efi_handle_t handle,

•            const struct efi_system_table *systable)
  

+{

•   efi_status_t ret;
  

•   efi_handle_t *net_handle;
  

•   efi_uintn_t num_handles;
  

•   efi_handle_t *handles;
  

•   struct efi_http_config_data http_config;
  

•   struct efi_httpv4_access_point ipv4_node;
  

•   boottime = systable->boottime;
  

•   boottime->locate_handle_buffer(BY_PROTOCOL,
  

&efi_ip4_config2_guid,

...

•                                  NULL, &num_handles, &handles);
  

Same remarks as the other test-related patch, Check the number of handles early and exit

...

•   for (net_handle = handles; num_handles--; net_handle++) {
  

•           ret = boottime->open_protocol(*net_handle,
  

&efi_ip4_config2_guid,

...

•                                         (void **)&ip4_config2, 0,
  

0,

...

EFI_OPEN_PROTOCOL_GET_PROTOCOL);

...

•           if (ret != EFI_SUCCESS || !ip4_config2)
  

•                   continue;
  

•           ret = boottime->open_protocol(*net_handle,
  

&efi_http_service_binding_guid,

...

•                                         (void **)&http_service, 0,
  

0,

...

EFI_OPEN_PROTOCOL_GET_PROTOCOL);

...

•           if (ret != EFI_SUCCESS || !http_service)
  

•                   continue;
  

•           break; // Get first handle that supports both protocols
  

•   }
  

•   if (!ip4_config2 || !http_service) {
  

•           efi_st_error("Failed to locate ipv4 config2 or http
  

service binding protocol\n");

...

•           return EFI_ST_FAILURE;
  

•   }
  

•   http_protocol_handle = NULL;
  

•   ret = http_service->create_child(http_service,
  

&http_protocol_handle);

I haven't checked the creation patches yet, but does it make sense to return EFI_SUCCESS if the protocol handle for the creation failed? IOW if http_protocol_handle == NULL shouldn't we return something else?

Hi Ilias, thanks again for the reviews,

I am not sure I understand your point here. If the creation fails then we return EFI_ST_FAILURE

...

•   if (ret != EFI_SUCCESS || !http_protocol_handle) {
  

•           efi_st_error("Failed to create an http service
  

instance\n");

...

•           return EFI_ST_FAILURE;
  

•   }
  

•   ret = boottime->open_protocol(http_protocol_handle,
  

&efi_http_guid,

...

•                                 (void **)&http, 0, 0,
  

EFI_OPEN_PROTOCOL_GET_PROTOCOL);

...

•   if (ret != EFI_SUCCESS || !http) {
  

•           efi_st_error("Failed to open http protocol\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

•   efi_st_printf("HTTP Service Binding: child created
  

successfully\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) {
  

•           efi_st_error("Failed to configure http instance\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

•   return EFI_ST_SUCCESS;
  

+}

+void EFIAPI efi_test_http_callback(struct efi_event *event, void

*context)

...

+{

•   callback_done = 1;
  

+}

+/*

• • Execute unit test.
• • Return: EFI_ST_SUCCESS for success
• */

+static int execute(void) +{

•   efi_status_t ret;
  

•   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;
  

•   void *response_buffer;
  

•   efi_uintn_t len, sum;
  

•   char *url = "http://example.com/";
  

•   u16 url_16[64];
  

•   u16 *tmp;
  

•   /* Setup may have failed */
  

•   if (!ip4_config2 || !http) {
  

•           efi_st_error("Cannot proceed with test after setup
  

failure\n");

...

•           return EFI_ST_FAILURE;
  

•   }
  

•   tmp = url_16;
  

•   utf8_utf16_strcpy(&tmp, url);
  

•   request_data.url = url_16;
  

•   request_data.method = HTTP_METHOD_GET;
  

•   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 = boottime->create_event(EVT_NOTIFY_SIGNAL,
  

•                   TPL_CALLBACK,
  

•                   efi_test_http_callback,
  

•                   NULL,
  

•                   &request_token.event);
  

•   if (ret != EFI_SUCCESS) {
  

•           efi_st_error("Failed to create request event\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

•   ret = http->request(http, &request_token);
  

•   if (ret != EFI_SUCCESS) {
  

•           boottime->close_event(request_token.event);
  

•           efi_st_printf("Failed to proceed with the http
  

request\n");

...

•           return EFI_ST_SUCCESS;
  

•   }
  

•   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 = boottime->create_event(EVT_NOTIFY_SIGNAL,
  

•                   TPL_CALLBACK,
  

•                   efi_test_http_callback,
  

•                   NULL,
  

•                   &response_token.event);
  

•   if (ret != EFI_SUCCESS) {
  

•           boottime->close_event(request_token.event);
  

•           efi_st_error("Failed to create response event\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

•   response_token.status = EFI_SUCCESS;
  

•   response_token.message = &response_message;
  

•   callback_done = 0;
  

•   ret = http->response(http, &response_token);
  

•   if (ret != EFI_SUCCESS) {
  

•           efi_st_error("Failed http first response\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) {
  

•                   efi_st_error("File not found\n");
  

•           } else {
  

•                   efi_st_error("Bad http status %d\n",
  

response_message.data.response->status_code);

...

•           }
  

•           goto fail_free_hdr;
  

•   }
  

•   ret = boottime->allocate_pool(EFI_LOADER_CODE,
  

response_message.body_length,

...

•                                 &response_buffer);
  

•   if (ret != EFI_SUCCESS) {
  

•           efi_st_error("Failed allocating response buffer\n");
  

•           goto fail_free_hdr;
  

•   }
  

•   len = response_message.body_length;
  

•   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 = response_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) {
  

•                   efi_st_error("Failed http second response\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)
  

•           goto fail_free_buf;
  

•   boottime->free_pool(response_buffer);
  

•   if (response_message.headers)
  

•           boottime->free_pool(response_message.headers);
  

•   boottime->close_event(request_token.event);
  

•   boottime->close_event(response_token.event);
  

•   efi_st_printf("Efi Http request executed successfully\n");
  

•   return EFI_ST_SUCCESS;
  

+fail_free_buf:

•   boottime->free_pool(response_buffer);
  

+fail_free_hdr:

•   if (response_message.headers)
  

•           boottime->free_pool(response_message.headers);
  

+fail:

•   boottime->close_event(request_token.event);
  

•   boottime->close_event(response_token.event);
  

•   return EFI_ST_FAILURE;
  

+}

+/*

• • Tear down unit test.
• • Return: EFI_ST_SUCCESS for success
• */

+static int teardown(void) +{

•   efi_status_t ret;
  

•   int exit_status = EFI_ST_SUCCESS;
  

•   if (!http_service || !http_protocol_handle) {
  

•           efi_st_error("No handles to destroy http instance");
  

•           exit_status = EFI_ST_FAILURE;
  

•   } else {
  

•           ret = http_service->destroy_child(http_service,
  

http_protocol_handle);

...

•           if (ret != EFI_SUCCESS) {
  

•                   efi_st_error("Failed to destroy http instance");
  

•                   exit_status = EFI_ST_FAILURE;
  

•           }
  

•           efi_st_printf("HTTP Service Binding: child destroyed
  

successfully\n");

...

•   }
  

•   return exit_status;
  

+}

+EFI_UNIT_TEST(http) = {

•   .name = "http protocol",
  

•   .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
  

•   .setup = setup,
  

•   .execute = execute,
  

•   .teardown = teardown,
  

+#ifdef CONFIG_SANDBOX

•   /*
  

•    * Running this test on the sandbox requires setting environment
  

•    * variable ethact to a network interface connected to a DHCP
  

server and

...

•    * ethrotate to 'no'.
  

•    */
  

•   .on_request = true,
  

+#endif

+};

2.43.0

Hi Adriano

On Thu, 28 Nov 2024 at 16:44, Adriano Cordova adrianox@gmail.com wrote:

Add a test for the EFI_IP4_CONFIG2_PROTOCOL. The test sets the ip policy to static, adds an ip address, and then reads the current ip address and checks for it to be the same as the one that was set.

Signed-off-by: Adriano Cordova adrianox@gmail.com

(no changes since v4) Changes in v4:

• Removed unnecessary void* casts

(no changes since v2) lib/efi_selftest/Makefile | 2 + lib/efi_selftest/efi_selftest_ipconfig.c | 170 +++++++++++++++++++++++ 2 files changed, 172 insertions(+) create mode 100644 lib/efi_selftest/efi_selftest_ipconfig.c

diff --git a/lib/efi_selftest/Makefile b/lib/efi_selftest/Makefile index 140c08effc..17fbfad116 100644 --- a/lib/efi_selftest/Makefile +++ b/lib/efi_selftest/Makefile @@ -53,6 +53,8 @@ efi_selftest_watchdog.o obj-$(CONFIG_EFI_ECPT) += efi_selftest_ecpt.o obj-$(CONFIG_NETDEVICES) += efi_selftest_snp.o obj-$(CONFIG_EFI_HTTP_PROTOCOL) += efi_selftest_http.o +obj-$(CONFIG_EFI_HTTP_PROTOCOL) += efi_selftest_ipconfig.o

obj-$(CONFIG_EFI_DEVICE_PATH_TO_TEXT) += efi_selftest_devicepath.o obj-$(CONFIG_EFI_UNICODE_COLLATION_PROTOCOL2) += \ efi_selftest_unicode_collation.o diff --git a/lib/efi_selftest/efi_selftest_ipconfig.c b/lib/efi_selftest/efi_selftest_ipconfig.c new file mode 100644 index 0000000000..67a7d4f411 --- /dev/null +++ b/lib/efi_selftest/efi_selftest_ipconfig.c @@ -0,0 +1,170 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/*

• • efi_selftest_ipconfig
• • This unit test covers the IPv4 Config2 Protocol.
• */

+#include <efi_selftest.h> +#include <charset.h> +#include <net.h>

+static struct efi_boot_services *boottime;

+static struct efi_ip4_config2_protocol *ip4_config2; +static const efi_guid_t efi_ip4_config2_guid = EFI_IP4_CONFIG2_PROTOCOL_GUID;

+/*

• • Setup unit test.
• • Open IPv4 Config2 protocol
• • @handle: handle of the loaded image
• • @systable: system table
• • Return: EFI_ST_SUCCESS for success
• */

+static int setup(const efi_handle_t handle,

•            const struct efi_system_table *systable)
  

+{

•   efi_status_t ret;
  

•   efi_handle_t *net_handle;
  

•   efi_uintn_t num_handles;
  

•   efi_handle_t *handles;
  

•   boottime = systable->boottime;
  

•   boottime->locate_handle_buffer(BY_PROTOCOL, &efi_ip4_config2_guid,
  

•                                  NULL, &num_handles, &handles);
  

You can avoid looping over a null handle here by checking num_handles and remove the if (!ip4_config2) { later.

•   for (net_handle = handles; num_handles--; net_handle++) {
  

•           ret = boottime->open_protocol(*net_handle, &efi_ip4_config2_guid,
  

•                                         (void **)&ip4_config2, 0, 0,
  

•                                         EFI_OPEN_PROTOCOL_GET_PROTOCOL);
  

•           if (ret != EFI_SUCCESS || !ip4_config2)
  

•                   continue;
  

•           break; // Get first handle that supports ipv4
  

•   }
  

•   if (!ip4_config2) {
  

•           efi_st_error("Failed to locate ipv4 config2 protocol\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

•   return EFI_ST_SUCCESS;
  

+}

+/*

• • Execute unit test.
• • Return: EFI_ST_SUCCESS for success
• */

+static int execute(void) +{

•   efi_status_t ret;
  

•   enum efi_ip4_config2_policy policy;
  

•   efi_uintn_t data_size;
  

•   struct efi_ip4_config2_manual_address manual_address;
  

•   struct efi_ip4_config2_manual_address orig_address;
  

•   u8 netmask[] = {255, 255, 255, 0};
  

•   u8 ip[] = {10, 0, 0, 1};
  

•   /* Setup may have failed */
  

•   if (!ip4_config2) {
  

•           efi_st_error("Setup failure, cannot proceed with test\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

Will this run if setup fails?

•   /* Set policy to static */
  

•   policy = EFI_IP4_CONFIG2_POLICY_STATIC;
  

•   ret = ip4_config2->set_data(ip4_config2, EFI_IP4_CONFIG2_DATA_TYPE_POLICY,
  

•                         sizeof(enum efi_ip4_config2_policy), (void *)&policy);
  

•   if (ret != EFI_SUCCESS) {
  

•           efi_st_error("Failed to set policy\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

•   /* Save original ip address and netmask */
  

•   data_size = sizeof(struct efi_ip4_config2_manual_address);
  

sizeof(manual_address); same for the rest of the code

•   ret = ip4_config2->get_data(ip4_config2, EFI_IP4_CONFIG2_DATA_TYPE_MANUAL_ADDRESS,
  

•                         &data_size, &orig_address);
  

•   if (ret != EFI_SUCCESS) {
  

•           efi_st_error("Failed to save original ip address and netmask\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

•   /* 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(struct efi_ip4_config2_manual_address), &manual_address);
  

•   if (ret != EFI_SUCCESS) {
  

•           efi_st_error("Failed to get ip address and netmask\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

•   /* Try to set interface info, this should fail */
  

•   ret = ip4_config2->set_data(ip4_config2, EFI_IP4_CONFIG2_DATA_TYPE_INTERFACEINFO, 0, NULL);
  

•   if (ret == EFI_SUCCESS) {
  

•           efi_st_error("Interface info is read-only\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

•   /* Get ip address and netmask and check that they match with the previously set ones */
  

•   data_size = sizeof(struct efi_ip4_config2_manual_address);
  

•   ret = ip4_config2->get_data(ip4_config2, EFI_IP4_CONFIG2_DATA_TYPE_MANUAL_ADDRESS,
  

•                         &data_size, &manual_address);
  

•   if (ret != EFI_SUCCESS) {
  

•           efi_st_error("Failed to get ip address and netmask\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

•   if (memcmp(ip, &manual_address.address,
  

•              sizeof(struct efi_ipv4_address)) ||
  

•       memcmp(netmask, &manual_address.subnet_mask,
  

•              sizeof(struct efi_ipv4_address))) {
  

•           efi_st_error("Ip address mismatch\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

•   /* Restore original ip address and netmask */
  

•   ret = ip4_config2->set_data(ip4_config2, EFI_IP4_CONFIG2_DATA_TYPE_MANUAL_ADDRESS,
  

•                         sizeof(struct efi_ip4_config2_manual_address), &orig_address);
  

•   if (ret != EFI_SUCCESS) {
  

•           efi_st_error("Failed to restore original ip address and netmask\n");
  

•           return EFI_ST_FAILURE;
  

•   }
  

•   efi_st_printf("Efi ipconfig test execute succeeded\n");
  

•   return EFI_ST_SUCCESS;
  

+}

+/*

• • Tear down unit test.
• • Return: EFI_ST_SUCCESS for success
• */

+static int teardown(void) +{

•   int exit_status = EFI_ST_SUCCESS;
  

•   return exit_status;
  

+}

+EFI_UNIT_TEST(ipconfig) = {

•   .name = "IPv4 config2 protocol",
  

•   .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
  

•   .setup = setup,
  

•   .execute = execute,
  

•   .teardown = teardown,
  

+#ifdef CONFIG_SANDBOX

•   /*
  

•    * Running this test on the sandbox requires setting environment
  

•    * variable ethact to a network interface connected to a DHCP server and
  

•    * ethrotate to 'no'.
  

•    */
  

•   .on_request = true,
  

+#endif

+};

2.43.0

Thanks /Ilias