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>

Last-Update: 2021-09-24

Patch-Name: bootp-new-net_bootp6-command.patch
This commit is contained in:
Michael Chang 2016-10-27 17:41:04 -04:00 committed by Colin Watson
parent c7e2338904
commit 2ce72d9b58
3 changed files with 1018 additions and 1 deletions

View File

@ -24,6 +24,98 @@
#include <grub/net/netbuff.h> #include <grub/net/netbuff.h>
#include <grub/net/udp.h> #include <grub/net/udp.h>
#include <grub/datetime.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 struct grub_dhcp_discover_options
{ {
@ -607,6 +699,578 @@ out:
return err; 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_calloc (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(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_int64_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;
FOR_DHCP6_SESSIONS (se)
{
grub_dhcp6_session_remove (se);
se = grub_dhcp6_sessions;
}
}
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;
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);
return inf;
}
/* /*
* This is called directly from net/ip.c:handle_dgram(), because those * This is called directly from net/ip.c:handle_dgram(), because those
* BOOTP/DHCP packets are a bit special due to their improper * BOOTP/DHCP packets are a bit special due to their improper
@ -675,6 +1339,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;
grub_dhcp6_options_t options;
v6h = (const struct grub_net_dhcp6_packet *) nb->data;
size = nb->tail - nb->data;
options = grub_dhcp6_options_get (v6h, size);
if (!options)
return grub_errno;
if (!options->client_duid || !options->server_duid || !options->ia_addr)
{
grub_dhcp6_options_free (options);
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Bad DHCPv6 Packet");
}
FOR_DHCP6_SESSIONS (se)
{
if (se->transaction_id == v6h->transaction_id &&
grub_memcmp (options->client_duid, &se->duid, sizeof (se->duid)) == 0 &&
se->iaid == options->iaid)
break;
}
if (!se)
{
grub_dprintf ("bootp", "DHCPv6 session not found\n");
grub_dhcp6_options_free (options);
return GRUB_ERR_NONE;
}
if (v6h->message_type == GRUB_NET_DHCP6_ADVERTISE)
{
if (se->adv)
{
grub_dprintf ("bootp", "Skipped DHCPv6 Advertised .. \n");
grub_dhcp6_options_free (options);
return GRUB_ERR_NONE;
}
se->adv = options;
return grub_dhcp6_session_send_request (se);
}
else if (v6h->message_type == GRUB_NET_DHCP6_REPLY)
{
if (!se->adv)
{
grub_dprintf ("bootp", "Skipped DHCPv6 Reply .. \n");
grub_dhcp6_options_free (options);
return GRUB_ERR_NONE;
}
se->reply = options;
grub_dhcp6_session_configure_network (se);
grub_dhcp6_session_remove (se);
return GRUB_ERR_NONE;
}
else
{
grub_dhcp6_options_free (options);
}
return GRUB_ERR_NONE;
}
static grub_err_t static grub_err_t
grub_cmd_dhcpopt (struct grub_command *cmd __attribute__ ((unused)), grub_cmd_dhcpopt (struct grub_command *cmd __attribute__ ((unused)),
int argc, char **args) int argc, char **args)
@ -900,7 +1635,174 @@ grub_cmd_bootp (struct grub_command *cmd __attribute__ ((unused)),
return err; return err;
} }
static grub_command_t cmd_getdhcp, cmd_bootp, cmd_dhcp; static grub_err_t
grub_cmd_bootp6 (struct grub_command *cmd __attribute__ ((unused)),
int argc, char **args)
{
struct grub_net_card *card;
grub_uint32_t iaid = 0;
int interval;
grub_err_t err;
grub_dhcp6_session_t se;
err = GRUB_ERR_NONE;
FOR_NET_CARDS (card)
{
struct grub_net_network_level_interface *iface;
if (argc > 0 && grub_strcmp (card->name, args[0]) != 0)
continue;
iface = grub_net_ipv6_get_link_local (card, &card->default_address);
if (!iface)
{
grub_dhcp6_session_remove_all ();
return grub_errno;
}
grub_dhcp6_session_add (iface, iaid++);
}
for (interval = 200; interval < 10000; interval *= 2)
{
int done = 1;
FOR_DHCP6_SESSIONS (se)
{
struct grub_net_buff *nb;
struct grub_net_dhcp6_option *opt;
struct grub_net_dhcp6_packet *v6h;
struct grub_net_dhcp6_option_duid_ll *duid;
struct grub_net_dhcp6_option_iana *ia_na;
grub_net_network_level_address_t multicast;
grub_net_link_level_address_t ll_multicast;
struct udphdr *udph;
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 (se->iface,
&multicast, &ll_multicast);
if (err)
{
grub_dhcp6_session_remove_all ();
return err;
}
nb = grub_netbuff_alloc (GRUB_DHCP6_DEFAULT_NETBUFF_ALLOC_SIZE);
if (!nb)
{
grub_dhcp6_session_remove_all ();
return grub_errno;
}
err = grub_netbuff_reserve (nb, GRUB_DHCP6_DEFAULT_NETBUFF_ALLOC_SIZE);
if (err)
{
grub_dhcp6_session_remove_all ();
grub_netbuff_free (nb);
return err;
}
err = grub_netbuff_push (nb, sizeof (*opt) + sizeof (grub_uint16_t));
if (err)
{
grub_dhcp6_session_remove_all ();
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));
grub_set_unaligned16 (opt->data, 0);
err = grub_netbuff_push (nb, sizeof (*opt) + sizeof (*duid));
if (err)
{
grub_dhcp6_session_remove_all ();
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 (sizeof (*duid));
duid = (struct grub_net_dhcp6_option_duid_ll *) opt->data;
grub_memcpy (duid, &se->duid, sizeof (*duid));
err = grub_netbuff_push (nb, sizeof (*opt) + sizeof (*ia_na));
if (err)
{
grub_dhcp6_session_remove_all ();
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));
ia_na = (struct grub_net_dhcp6_option_iana *)opt->data;
ia_na->iaid = grub_cpu_to_be32 (se->iaid);
ia_na->t1 = 0;
ia_na->t2 = 0;
err = grub_netbuff_push (nb, sizeof (*v6h));
if (err)
{
grub_dhcp6_session_remove_all ();
grub_netbuff_free (nb);
return err;
}
v6h = (struct grub_net_dhcp6_packet *)nb->data;
v6h->message_type = GRUB_NET_DHCP6_SOLICIT;
v6h->transaction_id = se->transaction_id;
grub_netbuff_push (nb, sizeof (*udph));
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,
&se->iface->address, &multicast);
err = grub_net_send_ip_packet (se->iface, &multicast,
&ll_multicast, nb, GRUB_NET_IP_UDP);
done = 0;
grub_netbuff_free (nb);
if (err)
{
grub_dhcp6_session_remove_all ();
return err;
}
}
if (!done)
grub_net_poll_cards (interval, 0);
}
FOR_DHCP6_SESSIONS (se)
{
grub_error_push ();
err = grub_error (GRUB_ERR_FILE_NOT_FOUND,
N_("couldn't autoconfigure %s"),
se->iface->card->name);
}
grub_dhcp6_session_remove_all ();
return err;
}
static grub_command_t cmd_getdhcp, cmd_bootp, cmd_dhcp, cmd_bootp6;
void void
grub_bootp_init (void) grub_bootp_init (void)
@ -914,6 +1816,9 @@ grub_bootp_init (void)
cmd_getdhcp = grub_register_command ("net_get_dhcp_option", grub_cmd_dhcpopt, cmd_getdhcp = grub_register_command ("net_get_dhcp_option", grub_cmd_dhcpopt,
N_("VAR INTERFACE NUMBER DESCRIPTION"), N_("VAR INTERFACE NUMBER DESCRIPTION"),
N_("retrieve DHCP option and save it into VAR. If VAR is - then print the value.")); N_("retrieve DHCP option and save it into VAR. If VAR is - then print the value."));
cmd_bootp6 = grub_register_command ("net_bootp6", grub_cmd_bootp6,
N_("[CARD]"),
N_("perform a DHCPv6 autoconfiguration"));
} }
void void
@ -922,4 +1827,5 @@ grub_bootp_fini (void)
grub_unregister_command (cmd_getdhcp); grub_unregister_command (cmd_getdhcp);
grub_unregister_command (cmd_bootp); grub_unregister_command (cmd_bootp);
grub_unregister_command (cmd_dhcp); grub_unregister_command (cmd_dhcp);
grub_unregister_command (cmd_bootp6);
} }

View File

@ -239,6 +239,45 @@ handle_dgram (struct grub_net_buff *nb,
{ {
struct udphdr *udph; struct udphdr *udph;
udph = (struct udphdr *) nb->data; udph = (struct udphdr *) nb->data;
if (proto == GRUB_NET_IP_UDP && udph->dst == grub_cpu_to_be16_compile_time (DHCP6_CLIENT_PORT))
{
if (udph->chksum)
{
grub_uint16_t chk, expected;
chk = udph->chksum;
udph->chksum = 0;
expected = grub_net_ip_transport_checksum (nb,
GRUB_NET_IP_UDP,
source,
dest);
if (expected != chk)
{
grub_dprintf ("net", "Invalid UDP checksum. "
"Expected %x, got %x\n",
grub_be_to_cpu16 (expected),
grub_be_to_cpu16 (chk));
grub_netbuff_free (nb);
return GRUB_ERR_NONE;
}
udph->chksum = chk;
}
err = grub_netbuff_pull (nb, sizeof (*udph));
if (err)
{
grub_netbuff_free (nb);
return err;
}
err = grub_net_process_dhcp6 (nb, card);
if (err)
grub_print_error ();
grub_netbuff_free (nb);
return GRUB_ERR_NONE;
}
if (proto == GRUB_NET_IP_UDP && grub_be_to_cpu16 (udph->dst) == 68) if (proto == GRUB_NET_IP_UDP && grub_be_to_cpu16 (udph->dst) == 68)
{ {
const struct grub_net_bootp_packet *bootp; const struct grub_net_bootp_packet *bootp;

View File

@ -448,6 +448,66 @@ struct grub_net_bootp_packet
grub_uint8_t vendor[0]; grub_uint8_t vendor[0];
} GRUB_PACKED; } GRUB_PACKED;
struct grub_net_dhcp6_packet
{
grub_uint32_t message_type:8;
grub_uint32_t transaction_id:24;
grub_uint8_t dhcp_options[0];
} GRUB_PACKED;
struct grub_net_dhcp6_option {
grub_uint16_t code;
grub_uint16_t len;
grub_uint8_t data[0];
} GRUB_PACKED;
struct grub_net_dhcp6_option_iana {
grub_uint32_t iaid;
grub_uint32_t t1;
grub_uint32_t t2;
grub_uint8_t data[0];
} GRUB_PACKED;
struct grub_net_dhcp6_option_iaaddr {
grub_uint8_t addr[16];
grub_uint32_t preferred_lifetime;
grub_uint32_t valid_lifetime;
grub_uint8_t data[0];
} GRUB_PACKED;
struct grub_net_dhcp6_option_duid_ll
{
grub_uint16_t type;
grub_uint16_t hw_type;
grub_uint8_t hwaddr[6];
} GRUB_PACKED;
enum
{
GRUB_NET_DHCP6_SOLICIT = 1,
GRUB_NET_DHCP6_ADVERTISE = 2,
GRUB_NET_DHCP6_REQUEST = 3,
GRUB_NET_DHCP6_REPLY = 7
};
enum
{
DHCP6_CLIENT_PORT = 546,
DHCP6_SERVER_PORT = 547
};
enum
{
GRUB_NET_DHCP6_OPTION_CLIENTID = 1,
GRUB_NET_DHCP6_OPTION_SERVERID = 2,
GRUB_NET_DHCP6_OPTION_IA_NA = 3,
GRUB_NET_DHCP6_OPTION_IAADDR = 5,
GRUB_NET_DHCP6_OPTION_ORO = 6,
GRUB_NET_DHCP6_OPTION_ELAPSED_TIME = 8,
GRUB_NET_DHCP6_OPTION_DNS_SERVERS = 23,
GRUB_NET_DHCP6_OPTION_BOOTFILE_URL = 59
};
#define GRUB_NET_BOOTP_RFC1048_MAGIC_0 0x63 #define GRUB_NET_BOOTP_RFC1048_MAGIC_0 0x63
#define GRUB_NET_BOOTP_RFC1048_MAGIC_1 0x82 #define GRUB_NET_BOOTP_RFC1048_MAGIC_1 0x82
#define GRUB_NET_BOOTP_RFC1048_MAGIC_2 0x53 #define GRUB_NET_BOOTP_RFC1048_MAGIC_2 0x53
@ -483,6 +543,14 @@ grub_net_configure_by_dhcp_ack (const char *name,
grub_size_t size, grub_size_t size,
int is_def, char **device, char **path); int is_def, char **device, char **path);
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 *v6,
grub_size_t size,
int is_def, char **device, char **path);
grub_err_t grub_err_t
grub_net_add_ipv4_local (struct grub_net_network_level_interface *inf, grub_net_add_ipv4_local (struct grub_net_network_level_interface *inf,
int mask); int mask);
@ -491,6 +559,10 @@ void
grub_net_process_dhcp (struct grub_net_buff *nb, grub_net_process_dhcp (struct grub_net_buff *nb,
struct grub_net_network_level_interface *iface); struct grub_net_network_level_interface *iface);
grub_err_t
grub_net_process_dhcp6 (struct grub_net_buff *nb,
struct grub_net_card *card);
int int
grub_net_hwaddr_cmp (const grub_net_link_level_address_t *a, grub_net_hwaddr_cmp (const grub_net_link_level_address_t *a,
const grub_net_link_level_address_t *b); const grub_net_link_level_address_t *b);