#include "sd-dhcp6-client.h"

#include "hashmap.h"

#include "hostname-setup.h"

#include "hostname-util.h"

#include "networkd-address.h"

#include "networkd-dhcp-prefix-delegation.h"

#include "networkd-dhcp6.h"

#include "networkd-link.h"

#include "networkd-manager.h"

#include "networkd-queue.h"

#include "networkd-route.h"

#include "string-table.h"

#include "string-util.h"

bool link_dhcp6_with_address_enabled(Link *link) {

if (!link_dhcp6_enabled(link))

return false;

return link->network->dhcp6_use_address;

}

static DHCP6ClientStartMode link_get_dhcp6_client_start_mode(Link *link) {

assert(link);

if (!link->network)

return DHCP6_CLIENT_START_MODE_NO;

/* When WithoutRA= is explicitly specified, then honor it. */

if (link->network->dhcp6_client_start_mode >= 0)

return link->network->dhcp6_client_start_mode;

/* When this interface itself is an uplink interface, then start dhcp6 client in managed mode. */

if (dhcp_pd_is_uplink(link, link, /* accept_auto = */ false))

return DHCP6_CLIENT_START_MODE_SOLICIT;

/* Otherwise, start dhcp6 client when RA is received. */

return DHCP6_CLIENT_START_MODE_NO;

}

static int dhcp6_remove(Link *link, bool only_marked) {

Address *address;

Route *route;

int k, r = 0;

assert(link);

if (!only_marked)

link->dhcp6_configured = false;

SET_FOREACH(route, link->routes) {

if (route->source != NETWORK_CONFIG_SOURCE_DHCP6)

continue;

if (only_marked && !route_is_marked(route))

continue;

k = route_remove(route);

if (k < 0)

r = k;

route_cancel_request(route, link);

}

SET_FOREACH(address, link->addresses) {

if (address->source != NETWORK_CONFIG_SOURCE_DHCP6)

continue;

if (only_marked && !address_is_marked(address))

continue;

k = address_remove(address);

if (k < 0)

r = k;

address_cancel_request(address);

}

return r;

}

static int dhcp6_address_ready_callback(Address *address) {

Address *a;

assert(address);

assert(address->link);

SET_FOREACH(a, address->link->addresses)

if (a->source == NETWORK_CONFIG_SOURCE_DHCP6)

a->callback = NULL;

return dhcp6_check_ready(address->link);

}

int dhcp6_check_ready(Link *link) {

bool has_ready = false;

Address *address;

int r;

assert(link);

if (link->dhcp6_messages > 0) {

log_link_debug(link, "%s(): DHCPv6 addresses and routes are not set.", __func__);

return 0;

}

SET_FOREACH(address, link->addresses) {

if (address->source != NETWORK_CONFIG_SOURCE_DHCP6)

continue;

if (address_is_ready(address)) {

has_ready = true;

break;

}

}

if (!has_ready) {

SET_FOREACH(address, link->addresses)

if (address->source == NETWORK_CONFIG_SOURCE_DHCP6)

address->callback = dhcp6_address_ready_callback;

log_link_debug(link, "%s(): no DHCPv6 address is ready.", __func__);

return 0;

}

link->dhcp6_configured = true;

log_link_debug(link, "DHCPv6 addresses and routes set.");

r = dhcp6_remove(link, /* only_marked = */ true);

if (r < 0)

return r;

link_check_ready(link);

return 0;

}

static int dhcp6_address_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, Address *address) {

int r;

assert(link);

r = address_configure_handler_internal(rtnl, m, link, "Could not set DHCPv6 address");

if (r <= 0)

return r;

r = dhcp6_check_ready(link);

if (r < 0)

link_enter_failed(link);

return 1;

}

static int verify_dhcp6_address(Link *link, const Address *address) {

_cleanup_free_ char *buffer = NULL;

bool by_ndisc = false;

Address *existing;

int log_level;

assert(link);

assert(address);

assert(address->family == AF_INET6);

(void) in6_addr_to_string(&address->in_addr.in6, &buffer);

if (address_get(link, address, &existing) < 0 &&

link_get_address(link, AF_INET6, &address->in_addr, 0, &existing) < 0) {

/* New address. */

log_level = LOG_INFO;

goto simple_log;

} else

log_level = LOG_DEBUG;

if (address->prefixlen == existing->prefixlen)

/* Currently, only conflict in prefix length is reported. */

goto simple_log;

if (existing->source == NETWORK_CONFIG_SOURCE_NDISC)

by_ndisc = true;

log_link_warning(link, "Ignoring DHCPv6 address %s/%u (valid %s, preferred %s) which conflicts with %s/%u%s.",

strna(buffer), address->prefixlen,

FORMAT_LIFETIME(address->lifetime_valid_usec),

FORMAT_LIFETIME(address->lifetime_preferred_usec),

strna(buffer), existing->prefixlen,

by_ndisc ? " assigned by NDisc" : "");

if (by_ndisc)

log_link_warning(link, "Hint: use IPv6Token= setting to change the address generated by NDisc or set UseAutonomousPrefix=no.");

return -EEXIST;

simple_log:

log_link_full(link, log_level, "DHCPv6 address %s/%u (valid %s, preferred %s)",

strna(buffer), address->prefixlen,

FORMAT_LIFETIME(address->lifetime_valid_usec),

FORMAT_LIFETIME(address->lifetime_preferred_usec));

return 0;

}

static int dhcp6_request_address(

usec_t lifetime_valid_usec) {

_cleanup_(address_freep) Address *addr = NULL;

Address *existing;

int r;

r = address_new(&addr);

if (r < 0)

return log_oom();

addr->source = NETWORK_CONFIG_SOURCE_DHCP6;

addr->provider.in6 = *server_address;

addr->family = AF_INET6;

addr->in_addr.in6 = *ip6_addr;

addr->flags = IFA_F_NOPREFIXROUTE;

addr->prefixlen = 128;

addr->lifetime_preferred_usec = lifetime_preferred_usec;

addr->lifetime_valid_usec = lifetime_valid_usec;

if (verify_dhcp6_address(link, addr) < 0)

return 0;

if (address_get(link, addr, &existing) < 0)

link->dhcp6_configured = false;

else

address_unmark(existing);

r = link_request_address(link, TAKE_PTR(addr), true, &link->dhcp6_messages,

dhcp6_address_handler, NULL);

if (r < 0) {

_cleanup_free_ char *buffer = NULL;

(void) in6_addr_to_string(ip6_addr, &buffer);

return log_link_error_errno(link, r, "Failed to request DHCPv6 address %s/128: %m", strna(buffer));

}

return 0;

}

static int dhcp6_address_acquired(Link *link) {

struct in6_addr server_address;

usec_t timestamp_usec;

int r;

assert(link);

assert(link->network);

assert(link->dhcp6_lease);

if (!link->network->dhcp6_use_address)

return 0;

r = sd_dhcp6_lease_get_server_address(link->dhcp6_lease, &server_address);

if (r < 0)

return log_link_warning_errno(link, r, "Failed to get server address of DHCPv6 lease: %m");

r = sd_dhcp6_lease_get_timestamp(link->dhcp6_lease, CLOCK_BOOTTIME, &timestamp_usec);

if (r < 0)

return log_link_warning_errno(link, r, "Failed to get timestamp of DHCPv6 lease: %m");

for (sd_dhcp6_lease_reset_address_iter(link->dhcp6_lease);;) {

uint32_t lifetime_preferred_sec, lifetime_valid_sec;

struct in6_addr ip6_addr;

r = sd_dhcp6_lease_get_address(link->dhcp6_lease, &ip6_addr, &lifetime_preferred_sec, &lifetime_valid_sec);

if (r < 0)

break;

r = dhcp6_request_address(link, &server_address, &ip6_addr,

usec_add(lifetime_preferred_sec * USEC_PER_SEC, timestamp_usec),

usec_add(lifetime_valid_sec * USEC_PER_SEC, timestamp_usec));

if (r < 0)

return r;

}

if (link->network->dhcp6_use_hostname) {

const char *dhcpname = NULL;

_cleanup_free_ char *hostname = NULL;

(void) sd_dhcp6_lease_get_fqdn(link->dhcp6_lease, &dhcpname);

if (dhcpname) {

r = shorten_overlong(dhcpname, &hostname);

if (r < 0)

log_link_warning_errno(link, r, "Unable to shorten overlong DHCP hostname '%s', ignoring: %m", dhcpname);

if (r == 1)

log_link_notice(link, "Overlong DHCP hostname received, shortened from '%s' to '%s'", dhcpname, hostname);

}

if (hostname) {

r = manager_set_hostname(link->manager, hostname);

if (r < 0)

log_link_error_errno(link, r, "Failed to set transient hostname to '%s': %m", hostname);

}

}

return 0;

}

static int dhcp6_lease_ip_acquired(sd_dhcp6_client *client, Link *link) {

_cleanup_(sd_dhcp6_lease_unrefp) sd_dhcp6_lease *lease_old = NULL;

sd_dhcp6_lease *lease;

int r;

link_mark_addresses(link, NETWORK_CONFIG_SOURCE_DHCP6, NULL);

link_mark_routes(link, NETWORK_CONFIG_SOURCE_DHCP6, NULL);

r = sd_dhcp6_client_get_lease(client, &lease);

if (r < 0)

return log_link_error_errno(link, r, "Failed to get DHCPv6 lease: %m");

lease_old = TAKE_PTR(link->dhcp6_lease);

link->dhcp6_lease = sd_dhcp6_lease_ref(lease);

r = dhcp6_address_acquired(link);

if (r < 0)

return r;

if (dhcp6_lease_has_pd_prefix(lease)) {

r = dhcp6_pd_prefix_acquired(link);

if (r < 0)

return r;

} else if (dhcp6_lease_has_pd_prefix(lease_old))

/* When we had PD prefixes but not now, we need to remove them. */

dhcp_pd_prefix_lost(link);

if (link->dhcp6_messages == 0) {

link->dhcp6_configured = true;

r = dhcp6_remove(link, /* only_marked = */ true);

if (r < 0)

return r;

} else

log_link_debug(link, "Setting DHCPv6 addresses and routes");

if (!link->dhcp6_configured)

link_set_state(link, LINK_STATE_CONFIGURING);

link_check_ready(link);

return 0;

}

static int dhcp6_lease_information_acquired(sd_dhcp6_client *client, Link *link) {

return 0;

}

static int dhcp6_lease_lost(Link *link) {

int r;

assert(link);

assert(link->manager);

log_link_info(link, "DHCPv6 lease lost");

if (dhcp6_lease_has_pd_prefix(link->dhcp6_lease))

dhcp_pd_prefix_lost(link);

link->dhcp6_lease = sd_dhcp6_lease_unref(link->dhcp6_lease);

r = dhcp6_remove(link, /* only_marked = */ false);

if (r < 0)

return r;

return 0;

}

static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {

Link *link = userdata;

int r;

assert(link);

assert(link->network);

if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))

return;

switch (event) {

case SD_DHCP6_CLIENT_EVENT_STOP:

case SD_DHCP6_CLIENT_EVENT_RESEND_EXPIRE:

case SD_DHCP6_CLIENT_EVENT_RETRANS_MAX:

r = dhcp6_lease_lost(link);

if (r < 0)

link_enter_failed(link);

break;

case SD_DHCP6_CLIENT_EVENT_IP_ACQUIRE:

r = dhcp6_lease_ip_acquired(client, link);

if (r < 0) {

link_enter_failed(link);

return;

}

_fallthrough_;

case SD_DHCP6_CLIENT_EVENT_INFORMATION_REQUEST:

r = dhcp6_lease_information_acquired(client, link);

if (r < 0)

link_enter_failed(link);

break;

default:

if (event < 0)

log_link_warning_errno(link, event, "DHCPv6 error: %m");

else

log_link_warning(link, "DHCPv6 unknown event: %d", event);

return;

}

}

int dhcp6_start_on_ra(Link *link, bool information_request) {

int r;

assert(link);

assert(link->dhcp6_client);

assert(link->network);

assert(in6_addr_is_link_local(&link->ipv6ll_address));

if (link_get_dhcp6_client_start_mode(link) != DHCP6_CLIENT_START_MODE_NO)

/* When WithoutRA= is specified, then the DHCPv6 client should be already running in

return 0;

r = sd_dhcp6_client_is_running(link->dhcp6_client);

if (r < 0)

return r;

if (r > 0) {

int inf_req;

r = sd_dhcp6_client_get_information_request(link->dhcp6_client, &inf_req);

if (r < 0)

return r;

if (inf_req == information_request)

/* The client is already running in the requested mode. */

return 0;

if (!inf_req) {

log_link_debug(link,

"The DHCPv6 client is already running in the managed mode, "

"refusing to start the client in the information requesting mode.");

return 0;

}

log_link_debug(link,

"The DHCPv6 client is running in the information requesting mode. "

"Restarting the client in the managed mode.");

r = sd_dhcp6_client_stop(link->dhcp6_client);

if (r < 0)

return r;

} else {

r = sd_dhcp6_client_set_local_address(link->dhcp6_client, &link->ipv6ll_address);

if (r < 0)

return r;

}

r = sd_dhcp6_client_set_information_request(link->dhcp6_client, information_request);

if (r < 0)

return r;

r = sd_dhcp6_client_start(link->dhcp6_client);

if (r < 0)

return r;

return 0;

}

int dhcp6_start(Link *link) {

DHCP6ClientStartMode start_mode;

int r;

assert(link);

assert(link->network);

if (!link->dhcp6_client)

return 0;

if (!link_dhcp6_enabled(link))

return 0;

if (!link_has_carrier(link))

return 0;

if (sd_dhcp6_client_is_running(link->dhcp6_client) > 0)

return 0;

if (!in6_addr_is_link_local(&link->ipv6ll_address)) {

log_link_debug(link, "IPv6 link-local address is not set, delaying to start DHCPv6 client.");

return 0;

}

r = sd_dhcp6_client_set_local_address(link->dhcp6_client, &link->ipv6ll_address);

if (r < 0)

return r;

start_mode = link_get_dhcp6_client_start_mode(link);

if (start_mode == DHCP6_CLIENT_START_MODE_NO)

return 0;

r = sd_dhcp6_client_set_information_request(link->dhcp6_client,

start_mode == DHCP6_CLIENT_START_MODE_INFORMATION_REQUEST);

if (r < 0)

return r;

r = sd_dhcp6_client_start(link->dhcp6_client);

if (r < 0)

return r;

return 1;

}

static int dhcp6_set_hostname(sd_dhcp6_client *client, Link *link) {

_cleanup_free_ char *hostname = NULL;

const char *hn;

int r;

assert(link);

if (!link->network->dhcp_send_hostname)

hn = NULL;

else if (link->network->dhcp_hostname)

hn = link->network->dhcp_hostname;

else {

r = gethostname_strict(&hostname);

if (r < 0 && r != -ENXIO) /* ENXIO: no hostname set or hostname is "localhost" */

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to get hostname: %m");

hn = hostname;

}

r = sd_dhcp6_client_set_fqdn(client, hn);

if (r == -EINVAL && hostname)

/* Ignore error when the machine's hostname is not suitable to send in DHCP packet. */

log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set hostname from kernel hostname, ignoring: %m");

else if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set hostname: %m");

return 0;

}

static int dhcp6_set_identifier(Link *link, sd_dhcp6_client *client) {

const DUID *duid;

int r;

assert(link);

assert(link->network);

assert(client);

r = sd_dhcp6_client_set_mac(client, link->hw_addr.bytes, link->hw_addr.length, link->iftype);

if (r < 0)

return r;

if (link->network->dhcp6_iaid_set) {

r = sd_dhcp6_client_set_iaid(client, link->network->dhcp6_iaid);

if (r < 0)

return r;

}

duid = link_get_dhcp6_duid(link);

if (duid->type == DUID_TYPE_LLT && duid->raw_data_len == 0)

r = sd_dhcp6_client_set_duid_llt(client, duid->llt_time);

else

r = sd_dhcp6_client_set_duid(client,

duid->type,

duid->raw_data_len > 0 ? duid->raw_data : NULL,

duid->raw_data_len);

if (r < 0)

return r;

return 0;

}

static int dhcp6_configure(Link *link) {

_cleanup_(sd_dhcp6_client_unrefp) sd_dhcp6_client *client = NULL;

sd_dhcp6_option *vendor_option;

sd_dhcp6_option *send_option;

void *request_options;

int r;

assert(link);

assert(link->network);

if (link->dhcp6_client)

return log_link_debug_errno(link, SYNTHETIC_ERRNO(EBUSY), "DHCPv6 client is already configured.");

r = sd_dhcp6_client_new(&client);

if (r == -ENOMEM)

return log_oom_debug();

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to create DHCPv6 client: %m");

r = sd_dhcp6_client_attach_event(client, link->manager->event, 0);

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to attach event: %m");

r = dhcp6_set_identifier(link, client);

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set identifier: %m");

ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp6_client_send_options) {

r = sd_dhcp6_client_add_option(client, send_option);

if (r == -EEXIST)

continue;

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set option: %m");

}

r = dhcp6_set_hostname(client, link);

if (r < 0)

return r;

r = sd_dhcp6_client_set_ifindex(client, link->ifindex);

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set ifindex: %m");

if (link->network->dhcp6_mudurl) {

r = sd_dhcp6_client_set_request_mud_url(client, link->network->dhcp6_mudurl);

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set MUD URL: %m");

}

SET_FOREACH(request_options, link->network->dhcp6_request_options) {

uint32_t option = PTR_TO_UINT32(request_options);

r = sd_dhcp6_client_set_request_option(client, option);

if (r == -EEXIST) {

log_link_debug(link, "DHCPv6 CLIENT: Failed to set request flag for '%u' already exists, ignoring.", option);

continue;

}

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set request flag for '%u': %m", option);

}

if (link->network->dhcp6_user_class) {

r = sd_dhcp6_client_set_request_user_class(client, link->network->dhcp6_user_class);

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set user class: %m");

}

if (link->network->dhcp6_vendor_class) {

r = sd_dhcp6_client_set_request_vendor_class(client, link->network->dhcp6_vendor_class);

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set vendor class: %m");

}

ORDERED_HASHMAP_FOREACH(vendor_option, link->network->dhcp6_client_send_vendor_options) {

r = sd_dhcp6_client_add_vendor_option(client, vendor_option);

if (r == -EEXIST)

continue;

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set vendor option: %m");

}

r = sd_dhcp6_client_set_callback(client, dhcp6_handler, link);

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set callback: %m");

r = sd_dhcp6_client_set_prefix_delegation(client, link->network->dhcp6_use_pd_prefix);

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to %s requesting prefixes to be delegated: %m",

enable_disable(link->network->dhcp6_use_pd_prefix));

/* Even if UseAddress=no, we need to request IA_NA, as the dhcp6 client may be started in managed mode. */

r = sd_dhcp6_client_set_address_request(client, link->network->dhcp6_use_pd_prefix ? link->network->dhcp6_use_address : true);

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to %s requesting address: %m",

enable_disable(link->network->dhcp6_use_address));

if (link->network->dhcp6_pd_prefix_length > 0) {

r = sd_dhcp6_client_set_prefix_delegation_hint(client,

link->network->dhcp6_pd_prefix_length,

&link->network->dhcp6_pd_prefix_hint);

if (r < 0)

return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set prefix delegation hint: %m");

}

link->dhcp6_client = TAKE_PTR(client);

return 0;

}

int dhcp6_update_mac(Link *link) {

bool restart;

int r;

assert(link);

if (!link->dhcp6_client)

return 0;

restart = sd_dhcp6_client_is_running(link->dhcp6_client) > 0;

if (restart) {

r = sd_dhcp6_client_stop(link->dhcp6_client);

if (r < 0)

return r;

}

r = dhcp6_set_identifier(link, link->dhcp6_client);

if (r < 0)

return r;

if (restart) {

r = sd_dhcp6_client_start(link->dhcp6_client);

if (r < 0)

return log_link_warning_errno(link, r, "Could not restart DHCPv6 client: %m");

}

return 0;

}

static int dhcp6_process_request(Request *req, Link *link, void *userdata) {

int r;

assert(link);

if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))

return 0;

if (!IN_SET(link->hw_addr.length, ETH_ALEN, INFINIBAND_ALEN) ||

hw_addr_is_null(&link->hw_addr))

/* No MAC address is assigned to the hardware, or non-supported MAC address length. */

return 0;

r = dhcp_configure_duid(link, link_get_dhcp6_duid(link));

if (r <= 0)

return r;

r = dhcp6_configure(link);

if (r < 0)

return log_link_warning_errno(link, r, "Failed to configure DHCPv6 client: %m");

r = ndisc_start(link);

if (r < 0)

return log_link_warning_errno(link, r, "Failed to start IPv6 Router Discovery: %m");

r = dhcp6_start(link);

if (r < 0)

return log_link_warning_errno(link, r, "Failed to start DHCPv6 client: %m");

log_link_debug(link, "DHCPv6 client is configured%s.",

r > 0 ? ", acquiring DHCPv6 lease" : "");

return 1;

}

int link_request_dhcp6_client(Link *link) {

int r;

assert(link);

if (!link_dhcp6_enabled(link) && !link_ipv6_accept_ra_enabled(link))

return 0;

if (link->dhcp6_client)

return 0;

r = link_queue_request(link, REQUEST_TYPE_DHCP6_CLIENT, dhcp6_process_request, NULL);

if (r < 0)

return log_link_warning_errno(link, r, "Failed to request configuring of the DHCPv6 client: %m");

log_link_debug(link, "Requested configuring of the DHCPv6 client.");

return 0;

}

int link_serialize_dhcp6_client(Link *link, FILE *f) {

_cleanup_free_ char *duid = NULL;

uint32_t iaid;

int r;

assert(link);

if (!link->dhcp6_client)

return 0;

r = sd_dhcp6_client_get_iaid(link->dhcp6_client, &iaid);

if (r >= 0)

fprintf(f, "DHCP6_CLIENT_IAID=0x%x\n", iaid);

r = sd_dhcp6_client_duid_as_string(link->dhcp6_client, &duid);

if (r >= 0)

fprintf(f, "DHCP6_CLIENT_DUID=%s\n", duid);

return 0;

}

int config_parse_dhcp6_pd_prefix_hint(

void *userdata) {

Network *network = userdata;

union in_addr_union u;

unsigned char prefixlen;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(userdata);

r = in_addr_prefix_from_string(rvalue, AF_INET6, &u, &prefixlen);

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r,

"Failed to parse %s=%s, ignoring assignment.", lvalue, rvalue);

return 0;

}

if (prefixlen < 1 || prefixlen > 128) {

log_syntax(unit, LOG_WARNING, filename, line, 0,

"Invalid prefix length in %s=%s, ignoring assignment.", lvalue, rvalue);

return 0;

}

network->dhcp6_pd_prefix_hint = u.in6;

network->dhcp6_pd_prefix_length = prefixlen;

return 0;

}

DEFINE_CONFIG_PARSE_ENUM(config_parse_dhcp6_client_start_mode, dhcp6_client_start_mode, DHCP6ClientStartMode,

"Failed to parse WithoutRA= setting");

static const char* const dhcp6_client_start_mode_table[_DHCP6_CLIENT_START_MODE_MAX] = {

[DHCP6_CLIENT_START_MODE_NO] = "no",

[DHCP6_CLIENT_START_MODE_INFORMATION_REQUEST] = "information-request",

[DHCP6_CLIENT_START_MODE_SOLICIT] = "solicit",

};

DEFINE_STRING_TABLE_LOOKUP(dhcp6_client_start_mode, DHCP6ClientStartMode);