From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001

From: Michael Chang <mchang@suse.com>

Date: Wed, 10 Jul 2019 15:42:36 +0200

Subject: [PATCH] bootp: New net_bootp6 command

Implement new net_bootp6 command for IPv6 network auto configuration via the

DHCPv6 protocol (RFC3315).

Signed-off-by: Michael Chang <mchang@suse.com>

Signed-off-by: Ken Lin <ken.lin@hpe.com>

[pjones: Put back our code to add a local route]

Signed-off-by: Peter Jones <pjones@redhat.com>

---

 grub-core/net/bootp.c              | 1059 ++++++++++++++++++++++++++++++------

 grub-core/net/drivers/efi/efinet.c |   20 +-

 grub-core/net/ip.c                 |   39 ++

 include/grub/efi/api.h             |    2 +-

 include/grub/net.h                 |   91 ++--

 5 files changed, 1002 insertions(+), 209 deletions(-)

diff --git a/grub-core/net/bootp.c b/grub-core/net/bootp.c

index 08b6b2b5d6..fe93b80f1c 100644

--- a/grub-core/net/bootp.c

+++ b/grub-core/net/bootp.c

@@ -24,6 +24,98 @@

 #include <grub/net/netbuff.h>

 #include <grub/net/udp.h>

 #include <grub/datetime.h>

+#include <grub/time.h>

+#include <grub/list.h>

+

+static int

+dissect_url (const char *url, char **proto, char **host, char **path)

+{

+  const char *p, *ps;

+  grub_size_t l;

+

+  *proto = *host = *path = NULL;

+  ps = p = url;

+

+  while ((p = grub_strchr (p, ':')))

+    {

+      if (grub_strlen (p) < sizeof ("://") - 1)

+	break;

+      if (grub_memcmp (p, "://", sizeof ("://") - 1) == 0)

+	{

+	  l = p - ps;

+	  *proto = grub_malloc (l + 1);

+	  if (!*proto)

+	    {

+	      grub_print_error ();

+	      return 0;

+	    }

+

+	  grub_memcpy (*proto, ps, l);

+	  (*proto)[l] = '\0';

+	  p +=  sizeof ("://") - 1;

+	  break;

+	}

+      ++p;

+    }

+

+  if (!*proto)

+    {

+      grub_dprintf ("bootp", "url: %s is not valid, protocol not found\n", url);

+      return 0;

+    }

+

+  ps = p;

+  p = grub_strchr (p, '/');

+

+  if (!p)

+    {

+      grub_dprintf ("bootp", "url: %s is not valid, host/path not found\n", url);

+      grub_free (*proto);

+      *proto = NULL;

+      return 0;

+    }

+

+  l = p - ps;

+

+  if (l > 2 && ps[0] == '[' && ps[l - 1] == ']')

+    {

+      *host = grub_malloc (l - 1);

+      if (!*host)

+	{

+	  grub_print_error ();

+	  grub_free (*proto);

+	  *proto = NULL;

+	  return 0;

+	}

+      grub_memcpy (*host, ps + 1, l - 2);

+      (*host)[l - 2] = 0;

+    }

+  else

+    {

+      *host = grub_malloc (l + 1);

+      if (!*host)

+	{

+	  grub_print_error ();

+	  grub_free (*proto);

+	  *proto = NULL;

+	  return 0;

+	}

+      grub_memcpy (*host, ps, l);

+      (*host)[l] = 0;

+    }

+

+  *path = grub_strdup (p);

+  if (!*path)

+    {

+      grub_print_error ();

+      grub_free (*host);

+      grub_free (*proto);

+      *host = NULL;

+      *proto = NULL;

+      return 0;

+    }

+  return 1;

+}

 struct grub_dhcp_discover_options

 {

@@ -604,6 +696,584 @@ out:

   return err;

 }

+/* The default netbuff size for sending DHCPv6 packets which should be

+   large enough to hold the information */

+#define GRUB_DHCP6_DEFAULT_NETBUFF_ALLOC_SIZE 512

+

+struct grub_dhcp6_options

+{

+  grub_uint8_t *client_duid;

+  grub_uint16_t client_duid_len;

+  grub_uint8_t *server_duid;

+  grub_uint16_t server_duid_len;

+  grub_uint32_t iaid;

+  grub_uint32_t t1;

+  grub_uint32_t t2;

+  grub_net_network_level_address_t *ia_addr;

+  grub_uint32_t preferred_lifetime;

+  grub_uint32_t valid_lifetime;

+  grub_net_network_level_address_t *dns_server_addrs;

+  grub_uint16_t num_dns_server;

+  char *boot_file_proto;

+  char *boot_file_server_ip;

+  char *boot_file_path;

+};

+

+typedef struct grub_dhcp6_options *grub_dhcp6_options_t;

+

+struct grub_dhcp6_session

+{

+  struct grub_dhcp6_session *next;

+  struct grub_dhcp6_session **prev;

+  grub_uint32_t iaid;

+  grub_uint32_t transaction_id:24;

+  grub_uint64_t start_time;

+  struct grub_net_dhcp6_option_duid_ll duid;

+  struct grub_net_network_level_interface *iface;

+

+  /* The associated dhcpv6 options */

+  grub_dhcp6_options_t adv;

+  grub_dhcp6_options_t reply;

+};

+

+typedef struct grub_dhcp6_session *grub_dhcp6_session_t;

+

+typedef void (*dhcp6_option_hook_fn) (const struct grub_net_dhcp6_option *opt, void *data);

+

+static void

+foreach_dhcp6_option (const struct grub_net_dhcp6_option *opt, grub_size_t size,

+		      dhcp6_option_hook_fn hook, void *hook_data);

+

+static void

+parse_dhcp6_iaaddr (const struct grub_net_dhcp6_option *opt, void *data)

+{

+  grub_dhcp6_options_t dhcp6 = (grub_dhcp6_options_t )data;

+

+  grub_uint16_t code = grub_be_to_cpu16 (opt->code);

+  grub_uint16_t len = grub_be_to_cpu16 (opt->len);

+

+  if (code == GRUB_NET_DHCP6_OPTION_IAADDR)

+    {

+      const struct grub_net_dhcp6_option_iaaddr *iaaddr;

+      iaaddr = (const struct grub_net_dhcp6_option_iaaddr *)opt->data;

+

+      if (len < sizeof (*iaaddr))

+	{

+	  grub_dprintf ("bootp", "DHCPv6: code %u with insufficient length %u\n", code, len);

+	  return;

+	}

+      if (!dhcp6->ia_addr)

+	{

+	  dhcp6->ia_addr = grub_malloc (sizeof(*dhcp6->ia_addr));

+	  dhcp6->ia_addr->type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6;

+	  dhcp6->ia_addr->ipv6[0] = grub_get_unaligned64 (iaaddr->addr);

+	  dhcp6->ia_addr->ipv6[1] = grub_get_unaligned64 (iaaddr->addr + 8);

+	  dhcp6->preferred_lifetime = grub_be_to_cpu32 (iaaddr->preferred_lifetime);

+	  dhcp6->valid_lifetime = grub_be_to_cpu32 (iaaddr->valid_lifetime);

+	}

+    }

+}

+

+static void

+parse_dhcp6_option (const struct grub_net_dhcp6_option *opt, void *data)

+{

+  grub_dhcp6_options_t dhcp6 = (grub_dhcp6_options_t)data;

+  grub_uint16_t code = grub_be_to_cpu16 (opt->code);

+  grub_uint16_t len = grub_be_to_cpu16 (opt->len);

+

+  switch (code)

+    {

+      case GRUB_NET_DHCP6_OPTION_CLIENTID:

+

+	if (dhcp6->client_duid || !len)

+	  {

+	    grub_dprintf ("bootp", "Skipped DHCPv6 CLIENTID with length %u\n", len);

+	    break;

+	  }

+	dhcp6->client_duid = grub_malloc (len);

+	grub_memcpy (dhcp6->client_duid, opt->data, len);

+	dhcp6->client_duid_len = len;

+	break;

+

+      case GRUB_NET_DHCP6_OPTION_SERVERID:

+

+	if (dhcp6->server_duid || !len)

+	  {

+	    grub_dprintf ("bootp", "Skipped DHCPv6 SERVERID with length %u\n", len);

+	    break;

+	  }

+	dhcp6->server_duid = grub_malloc (len);

+	grub_memcpy (dhcp6->server_duid, opt->data, len);

+	dhcp6->server_duid_len = len;

+	break;

+

+      case GRUB_NET_DHCP6_OPTION_IA_NA:

+	{

+	  const struct grub_net_dhcp6_option_iana *ia_na;

+	  grub_uint16_t data_len;

+

+	  if (dhcp6->iaid || len < sizeof (*ia_na))

+	    {

+	      grub_dprintf ("bootp", "Skipped DHCPv6 IA_NA with length %u\n", len);

+	      break;

+	    }

+	  ia_na = (const struct grub_net_dhcp6_option_iana *)opt->data;

+	  dhcp6->iaid = grub_be_to_cpu32 (ia_na->iaid);

+	  dhcp6->t1 = grub_be_to_cpu32 (ia_na->t1);

+	  dhcp6->t2 = grub_be_to_cpu32 (ia_na->t2);

+

+	  data_len = len - sizeof (*ia_na);

+	  if (data_len)

+	    foreach_dhcp6_option ((const struct grub_net_dhcp6_option *)ia_na->data, data_len, parse_dhcp6_iaaddr, dhcp6);

+	}

+	break;

+

+      case GRUB_NET_DHCP6_OPTION_DNS_SERVERS:

+	{

+	  const grub_uint8_t *po;

+	  grub_uint16_t ln;

+	  grub_net_network_level_address_t *la;

+

+	  if (!len || len & 0xf)

+	    {

+	      grub_dprintf ("bootp", "Skip invalid length DHCPv6 DNS_SERVERS \n");

+	      break;

+	    }

+	  dhcp6->num_dns_server = ln = len >> 4;

+	  dhcp6->dns_server_addrs = la = grub_zalloc (ln * sizeof (*la));

+

+	  for (po = opt->data; ln > 0; po += 0x10, la++, ln--)

+	    {

+	      la->type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6;

+	      la->ipv6[0] = grub_get_unaligned64 (po);

+	      la->ipv6[1] = grub_get_unaligned64 (po + 8);

+	      la->option = DNS_OPTION_PREFER_IPV6;

+	    }

+	}

+	break;

+

+      case GRUB_NET_DHCP6_OPTION_BOOTFILE_URL:

+	dissect_url ((const char *)opt->data,

+		      &dhcp6->boot_file_proto,

+		      &dhcp6->boot_file_server_ip,

+		      &dhcp6->boot_file_path);

+	break;

+

+      default:

+	break;

+    }

+}

+

+static void

+foreach_dhcp6_option (const struct grub_net_dhcp6_option *opt, grub_size_t size, dhcp6_option_hook_fn hook, void *hook_data)

+{

+  while (size)

+    {

+      grub_uint16_t code, len;

+

+      if (size < sizeof (*opt))

+	{

+	  grub_dprintf ("bootp", "DHCPv6: Options stopped with remaining size %" PRIxGRUB_SIZE "\n", size);

+	  break;

+	}

+      size -= sizeof (*opt);

+      len = grub_be_to_cpu16 (opt->len);

+      code = grub_be_to_cpu16 (opt->code);

+      if (size < len)

+	{

+	  grub_dprintf ("bootp", "DHCPv6: Options stopped at out of bound length %u for option %u\n", len, code);

+	  break;

+	}

+      if (!len)

+	{

+	  grub_dprintf ("bootp", "DHCPv6: Options stopped at zero length option %u\n", code);

+	  break;

+	}

+      else

+	{

+	  if (hook)

+	    hook (opt, hook_data);

+	  size -= len;

+	  opt = (const struct grub_net_dhcp6_option *)((grub_uint8_t *)opt + len + sizeof (*opt));

+	}

+    }

+}

+

+static grub_dhcp6_options_t

+grub_dhcp6_options_get (const struct grub_net_dhcp6_packet *v6h,

+			grub_size_t size)

+{

+  grub_dhcp6_options_t options;

+

+  if (size < sizeof (*v6h))

+    {

+      grub_error (GRUB_ERR_OUT_OF_RANGE, N_("DHCPv6 packet size too small"));

+      return NULL;

+    }

+

+  options = grub_zalloc (sizeof(*options));

+  if (!options)

+    return NULL;

+

+  foreach_dhcp6_option ((const struct grub_net_dhcp6_option *)v6h->dhcp_options,

+		       size - sizeof (*v6h), parse_dhcp6_option, options);

+

+  return options;

+}

+

+static void

+grub_dhcp6_options_free (grub_dhcp6_options_t options)

+{

+  if (options->client_duid)

+    grub_free (options->client_duid);

+  if (options->server_duid)

+    grub_free (options->server_duid);

+  if (options->ia_addr)

+    grub_free (options->ia_addr);

+  if (options->dns_server_addrs)

+    grub_free (options->dns_server_addrs);

+  if (options->boot_file_proto)

+    grub_free (options->boot_file_proto);

+  if (options->boot_file_server_ip)

+    grub_free (options->boot_file_server_ip);

+  if (options->boot_file_path)

+    grub_free (options->boot_file_path);

+

+  grub_free (options);

+}

+

+static grub_dhcp6_session_t grub_dhcp6_sessions;

+#define FOR_DHCP6_SESSIONS_SAFE(var, next) FOR_LIST_ELEMENTS_SAFE (var, next, grub_dhcp6_sessions)

+#define FOR_DHCP6_SESSIONS(var) FOR_LIST_ELEMENTS (var, grub_dhcp6_sessions)

+

+static void

+grub_net_configure_by_dhcp6_info (const char *name,

+	  struct grub_net_card *card,

+	  grub_dhcp6_options_t dhcp6,

+	  int is_def,

+	  int flags,

+	  struct grub_net_network_level_interface **ret_inf)

+{

+  grub_net_network_level_netaddress_t netaddr;

+  struct grub_net_network_level_interface *inf;

+

+  if (dhcp6->ia_addr)

+    {

+      inf = grub_net_add_addr (name, card, dhcp6->ia_addr, &card->default_address, flags);

+

+      netaddr.type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6;

+      netaddr.ipv6.base[0] = dhcp6->ia_addr->ipv6[0];

+      netaddr.ipv6.base[1] = 0;

+      netaddr.ipv6.masksize = 64;

+      grub_net_add_route (name, netaddr, inf);

+

+      if (ret_inf)

+	*ret_inf = inf;

+    }

+

+  if (dhcp6->dns_server_addrs)

+    {

+      grub_uint16_t i;

+

+      for (i = 0; i < dhcp6->num_dns_server; ++i)

+	grub_net_add_dns_server (dhcp6->dns_server_addrs + i);

+    }

+

+  if (dhcp6->boot_file_path)

+    grub_env_set_net_property (name, "boot_file", dhcp6->boot_file_path,

+			  grub_strlen (dhcp6->boot_file_path));

+

+  if (is_def && dhcp6->boot_file_server_ip)

+    {

+      grub_net_default_server = grub_strdup (dhcp6->boot_file_server_ip);

+      grub_env_set ("net_default_interface", name);

+      grub_env_export ("net_default_interface");

+    }

+}

+

+static void

+grub_dhcp6_session_add (struct grub_net_network_level_interface *iface,

+			grub_uint32_t iaid)

+{

+  grub_dhcp6_session_t se;

+  struct grub_datetime date;

+  grub_err_t err;

+  grub_int32_t t = 0;

+

+  se = grub_malloc (sizeof (*se));

+

+  err = grub_get_datetime (&date);

+  if (err || !grub_datetime2unixtime (&date, &t))

+    {

+      grub_errno = GRUB_ERR_NONE;

+      t = 0;

+    }

+

+  se->iface = iface;

+  se->iaid = iaid;

+  se->transaction_id = t;

+  se->start_time = grub_get_time_ms ();

+  se->duid.type = grub_cpu_to_be16_compile_time (3) ;

+  se->duid.hw_type = grub_cpu_to_be16_compile_time (1);

+  grub_memcpy (&se->duid.hwaddr, &iface->hwaddress.mac, sizeof (se->duid.hwaddr));

+  se->adv = NULL;

+  se->reply = NULL;

+  grub_list_push (GRUB_AS_LIST_P (&grub_dhcp6_sessions), GRUB_AS_LIST (se));

+}

+

+static void

+grub_dhcp6_session_remove (grub_dhcp6_session_t se)

+{

+  grub_list_remove (GRUB_AS_LIST (se));

+  if (se->adv)

+    grub_dhcp6_options_free (se->adv);

+  if (se->reply)

+    grub_dhcp6_options_free (se->reply);

+  grub_free (se);

+}

+

+static void

+grub_dhcp6_session_remove_all (void)

+{

+  grub_dhcp6_session_t se, next;

+

+  FOR_DHCP6_SESSIONS_SAFE (se, next)

+    {

+      grub_dhcp6_session_remove (se);

+    }

+  grub_dhcp6_sessions = NULL;

+}

+

+static grub_err_t

+grub_dhcp6_session_configure_network (grub_dhcp6_session_t se)

+{

+  char *name;

+

+  name = grub_xasprintf ("%s:dhcp6", se->iface->card->name);

+  if (!name)

+    return grub_errno;

+

+  grub_net_configure_by_dhcp6_info (name, se->iface->card, se->reply, 1, 0, 0);

+  grub_free (name);

+

+  return GRUB_ERR_NONE;

+}

+

+static grub_err_t

+grub_dhcp6_session_send_request (grub_dhcp6_session_t se)

+{

+  struct grub_net_buff *nb;

+  struct grub_net_dhcp6_option *opt;

+  struct grub_net_dhcp6_packet *v6h;

+  struct grub_net_dhcp6_option_iana *ia_na;

+  struct grub_net_dhcp6_option_iaaddr *iaaddr;

+  struct udphdr *udph;

+  grub_net_network_level_address_t multicast;

+  grub_net_link_level_address_t ll_multicast;

+  grub_uint64_t elapsed;

+  struct grub_net_network_level_interface *inf = se->iface;

+  grub_dhcp6_options_t dhcp6 = se->adv;

+  grub_err_t err = GRUB_ERR_NONE;

+

+  multicast.type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6;

+  multicast.ipv6[0] = grub_cpu_to_be64_compile_time (0xff02ULL << 48);

+  multicast.ipv6[1] = grub_cpu_to_be64_compile_time (0x10002ULL);

+

+  err = grub_net_link_layer_resolve (inf, &multicast, &ll_multicast);

+  if (err)

+    return err;

+

+  nb = grub_netbuff_alloc (GRUB_DHCP6_DEFAULT_NETBUFF_ALLOC_SIZE);

+

+  if (!nb)

+    return grub_errno;

+

+  err = grub_netbuff_reserve (nb, GRUB_DHCP6_DEFAULT_NETBUFF_ALLOC_SIZE);

+  if (err)

+    {

+      grub_netbuff_free (nb);

+      return err;

+    }

+

+  err = grub_netbuff_push (nb, dhcp6->client_duid_len + sizeof (*opt));

+  if (err)

+    {

+      grub_netbuff_free (nb);

+      return err;

+    }

+  opt = (struct grub_net_dhcp6_option *)nb->data;

+  opt->code = grub_cpu_to_be16_compile_time (GRUB_NET_DHCP6_OPTION_CLIENTID);

+  opt->len = grub_cpu_to_be16 (dhcp6->client_duid_len);

+  grub_memcpy (opt->data, dhcp6->client_duid , dhcp6->client_duid_len);

+

+  err = grub_netbuff_push (nb, dhcp6->server_duid_len + sizeof (*opt));

+  if (err)

+    {

+      grub_netbuff_free (nb);

+      return err;

+    }

+  opt = (struct grub_net_dhcp6_option *)nb->data;

+  opt->code = grub_cpu_to_be16_compile_time (GRUB_NET_DHCP6_OPTION_SERVERID);

+  opt->len = grub_cpu_to_be16 (dhcp6->server_duid_len);

+  grub_memcpy (opt->data, dhcp6->server_duid , dhcp6->server_duid_len);

+

+  err = grub_netbuff_push (nb, sizeof (*ia_na) + sizeof (*opt));

+  if (err)

+    {

+      grub_netbuff_free (nb);

+      return err;

+    }

+

+  if (dhcp6->ia_addr)

+    {

+      err = grub_netbuff_push (nb, sizeof(*iaaddr) + sizeof (*opt));

+      if (err)

+	{

+	  grub_netbuff_free (nb);

+	  return err;

+	}

+    }

+  opt = (struct grub_net_dhcp6_option *)nb->data;

+  opt->code = grub_cpu_to_be16_compile_time (GRUB_NET_DHCP6_OPTION_IA_NA);

+  opt->len = grub_cpu_to_be16 (sizeof (*ia_na));

+  if (dhcp6->ia_addr)

+    opt->len += grub_cpu_to_be16 (sizeof(*iaaddr) + sizeof (*opt));

+

+  ia_na = (struct grub_net_dhcp6_option_iana *)opt->data;

+  ia_na->iaid = grub_cpu_to_be32 (dhcp6->iaid);

+

+  ia_na->t1 = grub_cpu_to_be32 (dhcp6->t1);

+  ia_na->t2 = grub_cpu_to_be32 (dhcp6->t2);

+

+  if (dhcp6->ia_addr)

+    {

+      opt = (struct grub_net_dhcp6_option *)ia_na->data;

+      opt->code = grub_cpu_to_be16_compile_time (GRUB_NET_DHCP6_OPTION_IAADDR);

+      opt->len = grub_cpu_to_be16 (sizeof (*iaaddr));

+      iaaddr = (struct grub_net_dhcp6_option_iaaddr *)opt->data;

+      grub_set_unaligned64 (iaaddr->addr, dhcp6->ia_addr->ipv6[0]);

+      grub_set_unaligned64 (iaaddr->addr + 8, dhcp6->ia_addr->ipv6[1]);

+

+      iaaddr->preferred_lifetime = grub_cpu_to_be32 (dhcp6->preferred_lifetime);

+      iaaddr->valid_lifetime = grub_cpu_to_be32 (dhcp6->valid_lifetime);

+    }

+

+  err = grub_netbuff_push (nb, sizeof (*opt) + 2 * sizeof (grub_uint16_t));

+  if (err)

+    {

+      grub_netbuff_free (nb);

+      return err;

+    }

+

+  opt = (struct grub_net_dhcp6_option*) nb->data;

+  opt->code = grub_cpu_to_be16_compile_time (GRUB_NET_DHCP6_OPTION_ORO);

+  opt->len = grub_cpu_to_be16_compile_time (2 * sizeof (grub_uint16_t));

+  grub_set_unaligned16 (opt->data, grub_cpu_to_be16_compile_time (GRUB_NET_DHCP6_OPTION_BOOTFILE_URL));

+  grub_set_unaligned16 (opt->data + 2, grub_cpu_to_be16_compile_time (GRUB_NET_DHCP6_OPTION_DNS_SERVERS));

+

+  err = grub_netbuff_push (nb, sizeof (*opt) + sizeof (grub_uint16_t));

+  if (err)

+    {

+      grub_netbuff_free (nb);

+      return err;

+    }

+  opt = (struct grub_net_dhcp6_option*) nb->data;

+  opt->code = grub_cpu_to_be16_compile_time (GRUB_NET_DHCP6_OPTION_ELAPSED_TIME);

+  opt->len = grub_cpu_to_be16_compile_time (sizeof (grub_uint16_t));

+

+  /* the time is expressed in hundredths of a second */

+  elapsed = grub_divmod64 (grub_get_time_ms () - se->start_time, 10, 0);

+

+  if (elapsed > 0xffff)

+    elapsed = 0xffff;

+

+  grub_set_unaligned16 (opt->data,  grub_cpu_to_be16 ((grub_uint16_t)elapsed));

+

+  err = grub_netbuff_push (nb, sizeof (*v6h));

+  if (err)

+    {

+      grub_netbuff_free (nb);

+      return err;

+    }

+

+  v6h = (struct grub_net_dhcp6_packet *) nb->data;

+  v6h->message_type = GRUB_NET_DHCP6_REQUEST;

+  v6h->transaction_id = se->transaction_id;

+

+  err = grub_netbuff_push (nb, sizeof (*udph));

+  if (err)

+    {

+      grub_netbuff_free (nb);

+      return err;

+    }

+

+  udph = (struct udphdr *) nb->data;

+  udph->src = grub_cpu_to_be16_compile_time (DHCP6_CLIENT_PORT);

+  udph->dst = grub_cpu_to_be16_compile_time (DHCP6_SERVER_PORT);

+  udph->chksum = 0;

+  udph->len = grub_cpu_to_be16 (nb->tail - nb->data);

+

+  udph->chksum = grub_net_ip_transport_checksum (nb, GRUB_NET_IP_UDP,

+						 &inf->address,

+						 &multicast);

+  err = grub_net_send_ip_packet (inf, &multicast, &ll_multicast, nb,

+				 GRUB_NET_IP_UDP);

+

+  grub_netbuff_free (nb);

+

+  return err;

+}

+

+struct grub_net_network_level_interface *

+grub_net_configure_by_dhcpv6_reply (const char *name,

+	struct grub_net_card *card,

+	grub_net_interface_flags_t flags,

+	const struct grub_net_dhcp6_packet *v6h,

+	grub_size_t size,

+	int is_def,

+	char **device, char **path)

+{

+  struct grub_net_network_level_interface *inf;

+  grub_dhcp6_options_t dhcp6;

+  int mask = -1;

+

+  dhcp6 = grub_dhcp6_options_get (v6h, size);

+  if (!dhcp6)

+    {

+      grub_print_error ();

+      return NULL;

+    }

+

+  grub_net_configure_by_dhcp6_info (name, card, dhcp6, is_def, flags, &inf);

+

+  if (device && dhcp6->boot_file_proto && dhcp6->boot_file_server_ip)

+    {

+      *device = grub_xasprintf ("%s,%s", dhcp6->boot_file_proto, dhcp6->boot_file_server_ip);

+      grub_print_error ();

+    }

+  if (path && dhcp6->boot_file_path)

+    {

+      *path = grub_strdup (dhcp6->boot_file_path);

+      grub_print_error ();

+      if (*path)

+	{

+	  char *slash;

+	  slash = grub_strrchr (*path, '/');

+	  if (slash)

+	    *slash = 0;

+	  else

+	    **path = 0;

+	}

+    }

+

+  grub_dhcp6_options_free (dhcp6);

+

+  if (inf)

+    grub_net_add_ipv6_local (inf, mask);

+

+  return inf;

+}

+

 /*

  * This is called directly from net/ip.c:handle_dgram(), because those

  * BOOTP/DHCP packets are a bit special due to their improper

@@ -672,6 +1342,77 @@ grub_net_process_dhcp (struct grub_net_buff *nb,

     }

 }

+grub_err_t

+grub_net_process_dhcp6 (struct grub_net_buff *nb,

+                       struct grub_net_card *card __attribute__ ((unused)))

+{

+  const struct grub_net_dhcp6_packet *v6h;

+  grub_dhcp6_session_t se;

+  grub_size_t size;