2017-11-18 17:09:20 +01:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1+ */
|
2014-12-10 15:17:34 +01:00
|
|
|
/***
|
2018-06-12 17:15:23 +02:00
|
|
|
Copyright © 2014 Intel Corporation. All rights reserved.
|
2014-12-10 15:17:34 +01:00
|
|
|
***/
|
|
|
|
|
|
|
|
#include <netinet/ether.h>
|
|
|
|
#include <linux/if.h>
|
2018-01-04 14:11:59 +01:00
|
|
|
#include "sd-radv.h"
|
2014-12-10 15:17:34 +01:00
|
|
|
|
|
|
|
#include "sd-dhcp6-client.h"
|
|
|
|
|
2018-01-04 14:11:59 +01:00
|
|
|
#include "hashmap.h"
|
2017-11-16 10:07:07 +01:00
|
|
|
#include "hostname-util.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "network-internal.h"
|
2016-11-13 04:59:06 +01:00
|
|
|
#include "networkd-link.h"
|
|
|
|
#include "networkd-manager.h"
|
2018-01-04 14:11:59 +01:00
|
|
|
#include "siphash24.h"
|
|
|
|
#include "string-util.h"
|
|
|
|
#include "radv-internal.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
|
2015-04-10 13:03:18 +02:00
|
|
|
static int dhcp6_lease_address_acquired(sd_dhcp6_client *client, Link *link);
|
|
|
|
|
2018-10-02 20:29:06 +02:00
|
|
|
static bool dhcp6_get_prefix_delegation(Link *link) {
|
|
|
|
if (!link->network)
|
2018-01-04 14:11:51 +01:00
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!IN_SET(link->network->router_prefix_delegation,
|
|
|
|
RADV_PREFIX_DELEGATION_DHCP6,
|
|
|
|
RADV_PREFIX_DELEGATION_BOTH)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool dhcp6_enable_prefix_delegation(Link *dhcp6_link) {
|
|
|
|
Manager *manager;
|
|
|
|
Link *l;
|
|
|
|
Iterator i;
|
|
|
|
|
|
|
|
assert(dhcp6_link);
|
|
|
|
|
|
|
|
manager = dhcp6_link->manager;
|
|
|
|
assert(manager);
|
|
|
|
|
|
|
|
HASHMAP_FOREACH(l, manager->links, i) {
|
|
|
|
if (l == dhcp6_link)
|
|
|
|
continue;
|
|
|
|
|
2018-10-02 20:29:06 +02:00
|
|
|
if (!dhcp6_get_prefix_delegation(l))
|
2018-01-04 14:11:51 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-01-20 18:36:04 +01:00
|
|
|
static int dhcp6_lease_information_acquired(sd_dhcp6_client *client,
|
|
|
|
Link *link) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-01-04 14:11:59 +01:00
|
|
|
static int dhcp6_pd_prefix_assign(Link *link, struct in6_addr *prefix,
|
|
|
|
uint8_t prefix_len,
|
|
|
|
uint32_t lifetime_preferred,
|
|
|
|
uint32_t lifetime_valid) {
|
|
|
|
sd_radv *radv = link->radv;
|
|
|
|
int r;
|
|
|
|
_cleanup_(sd_radv_prefix_unrefp) sd_radv_prefix *p = NULL;
|
|
|
|
|
|
|
|
r = sd_radv_prefix_new(&p);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = sd_radv_prefix_set_prefix(p, prefix, prefix_len);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = sd_radv_prefix_set_preferred_lifetime(p, lifetime_preferred);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = sd_radv_prefix_set_valid_lifetime(p, lifetime_valid);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = sd_radv_stop(radv);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = sd_radv_add_prefix(radv, p, true);
|
|
|
|
if (r < 0 && r != -EEXIST)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = manager_dhcp6_prefix_add(link->manager, &p->opt.in6_addr, link);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return sd_radv_start(radv);
|
|
|
|
}
|
|
|
|
|
2018-10-10 07:38:57 +02:00
|
|
|
static int dhcp6_route_remove_handler(sd_netlink *nl, sd_netlink_message *m, void *userdata) {
|
2018-10-06 06:55:19 +02:00
|
|
|
Link *link = userdata;
|
2018-09-19 02:32:19 +02:00
|
|
|
int r;
|
|
|
|
|
2018-10-06 06:55:19 +02:00
|
|
|
assert(link);
|
|
|
|
|
2018-09-19 02:32:19 +02:00
|
|
|
r = sd_netlink_message_get_errno(m);
|
|
|
|
if (r < 0)
|
2018-10-06 06:55:19 +02:00
|
|
|
log_link_debug_errno(link, r, "Received error on unreachable route removal for DHCPv6 delegated subnetl: %m");
|
2018-09-19 02:32:19 +02:00
|
|
|
|
2018-10-10 07:39:35 +02:00
|
|
|
return 1;
|
2018-09-19 02:32:19 +02:00
|
|
|
}
|
|
|
|
|
2018-09-19 02:32:30 +02:00
|
|
|
int dhcp6_lease_pd_prefix_lost(sd_dhcp6_client *client, Link* link) {
|
2018-09-19 02:32:19 +02:00
|
|
|
int r;
|
|
|
|
sd_dhcp6_lease *lease;
|
|
|
|
union in_addr_union pd_prefix;
|
|
|
|
uint8_t pd_prefix_len;
|
|
|
|
uint32_t lifetime_preferred, lifetime_valid;
|
|
|
|
|
|
|
|
r = sd_dhcp6_client_get_lease(client, &lease);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
sd_dhcp6_lease_reset_pd_prefix_iter(lease);
|
|
|
|
|
|
|
|
while (sd_dhcp6_lease_get_pd(lease, &pd_prefix.in6, &pd_prefix_len,
|
|
|
|
&lifetime_preferred,
|
|
|
|
&lifetime_valid) >= 0) {
|
|
|
|
_cleanup_free_ char *buf = NULL;
|
2018-09-26 02:09:17 +02:00
|
|
|
_cleanup_free_ Route *route = NULL;
|
2018-09-19 02:32:19 +02:00
|
|
|
|
|
|
|
if (pd_prefix_len > 64)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
(void) in_addr_to_string(AF_INET6, &pd_prefix, &buf);
|
|
|
|
|
|
|
|
if (pd_prefix_len < 64) {
|
|
|
|
r = route_new(&route);
|
|
|
|
if (r < 0) {
|
|
|
|
log_link_warning_errno(link, r, "Cannot create unreachable route to delete for DHCPv6 delegated subnet %s/%u: %m",
|
|
|
|
strnull(buf),
|
|
|
|
pd_prefix_len);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
route_add(link, AF_INET6, &pd_prefix, pd_prefix_len,
|
|
|
|
0, 0, 0, &route);
|
|
|
|
route_update(route, NULL, 0, NULL, NULL, 0, 0,
|
|
|
|
RTN_UNREACHABLE);
|
|
|
|
|
2018-10-10 07:38:57 +02:00
|
|
|
r = route_remove(route, link, dhcp6_route_remove_handler);
|
2018-09-19 02:32:19 +02:00
|
|
|
if (r < 0) {
|
|
|
|
(void) in_addr_to_string(AF_INET6,
|
|
|
|
&pd_prefix, &buf);
|
|
|
|
|
|
|
|
log_link_warning_errno(link, r, "Cannot delete unreachable route for DHCPv6 delegated subnet %s/%u: %m",
|
|
|
|
strnull(buf),
|
|
|
|
pd_prefix_len);
|
2018-09-26 02:09:17 +02:00
|
|
|
|
2018-09-19 02:32:19 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
log_link_debug(link, "Removing unreachable route %s/%u",
|
|
|
|
strnull(buf), pd_prefix_len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-01-04 14:11:59 +01:00
|
|
|
static int dhcp6_pd_prefix_distribute(Link *dhcp6_link, Iterator *i,
|
|
|
|
struct in6_addr *pd_prefix,
|
|
|
|
uint8_t pd_prefix_len,
|
|
|
|
uint32_t lifetime_preferred,
|
|
|
|
uint32_t lifetime_valid) {
|
|
|
|
Link *link;
|
|
|
|
Manager *manager = dhcp6_link->manager;
|
|
|
|
union in_addr_union prefix;
|
2018-07-16 12:31:50 +02:00
|
|
|
uint64_t n_prefixes, n_used = 0;
|
2018-01-04 14:11:59 +01:00
|
|
|
_cleanup_free_ char *buf = NULL;
|
2018-08-24 17:49:22 +02:00
|
|
|
_cleanup_free_ char *assigned_buf = NULL;
|
2018-01-04 14:11:59 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(manager);
|
|
|
|
assert(pd_prefix_len <= 64);
|
|
|
|
|
|
|
|
prefix.in6 = *pd_prefix;
|
|
|
|
|
|
|
|
r = in_addr_mask(AF_INET6, &prefix, pd_prefix_len);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2018-07-16 12:31:50 +02:00
|
|
|
n_prefixes = UINT64_C(1) << (64 - pd_prefix_len);
|
2018-01-04 14:11:59 +01:00
|
|
|
|
|
|
|
(void) in_addr_to_string(AF_INET6, &prefix, &buf);
|
2018-07-16 12:31:50 +02:00
|
|
|
log_link_debug(dhcp6_link, "Assigning up to %" PRIu64 " prefixes from %s/%u",
|
2018-01-04 14:11:59 +01:00
|
|
|
n_prefixes, strnull(buf), pd_prefix_len);
|
|
|
|
|
|
|
|
while (hashmap_iterate(manager->links, i, (void **)&link, NULL)) {
|
|
|
|
Link *assigned_link;
|
|
|
|
|
|
|
|
if (n_used == n_prefixes) {
|
2018-07-16 12:31:50 +02:00
|
|
|
log_link_debug(dhcp6_link, "Assigned %" PRIu64 "/%" PRIu64 " prefixes from %s/%u",
|
2018-01-04 14:11:59 +01:00
|
|
|
n_used, n_prefixes, strnull(buf), pd_prefix_len);
|
|
|
|
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (link == dhcp6_link)
|
|
|
|
continue;
|
|
|
|
|
2018-10-02 20:29:06 +02:00
|
|
|
if (!dhcp6_get_prefix_delegation(link))
|
2018-01-04 14:11:59 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
assigned_link = manager_dhcp6_prefix_get(manager, &prefix.in6);
|
|
|
|
if (assigned_link != NULL && assigned_link != link)
|
|
|
|
continue;
|
|
|
|
|
2018-08-24 17:49:22 +02:00
|
|
|
(void) in_addr_to_string(AF_INET6, &prefix, &assigned_buf);
|
2018-01-04 14:11:59 +01:00
|
|
|
r = dhcp6_pd_prefix_assign(link, &prefix.in6, 64,
|
|
|
|
lifetime_preferred, lifetime_valid);
|
|
|
|
if (r < 0) {
|
2018-08-24 17:49:22 +02:00
|
|
|
log_link_error_errno(link, r, "Unable to %s prefix %s/64 from %s/%u for link: %m",
|
2018-01-04 14:11:59 +01:00
|
|
|
assigned_link ? "update": "assign",
|
2018-08-24 17:49:22 +02:00
|
|
|
strnull(assigned_buf),
|
2018-01-04 14:11:59 +01:00
|
|
|
strnull(buf), pd_prefix_len);
|
|
|
|
|
|
|
|
if (assigned_link == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
} else
|
2018-08-24 17:49:22 +02:00
|
|
|
log_link_debug(link, "Assigned prefix %" PRIu64 "/%" PRIu64 " %s/64 from %s/%u to link",
|
|
|
|
n_used + 1, n_prefixes,
|
|
|
|
strnull(assigned_buf),
|
|
|
|
strnull(buf), pd_prefix_len);
|
2018-01-04 14:11:59 +01:00
|
|
|
|
|
|
|
n_used++;
|
|
|
|
|
2018-08-24 17:49:18 +02:00
|
|
|
r = in_addr_prefix_next(AF_INET6, &prefix, 64);
|
2018-01-04 14:11:59 +01:00
|
|
|
if (r < 0 && n_used < n_prefixes)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2018-09-19 02:32:19 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2018-05-11 08:43:04 +02:00
|
|
|
|
2018-10-10 07:38:57 +02:00
|
|
|
static int dhcp6_route_handler(sd_netlink *nl, sd_netlink_message *m, void *userdata) {
|
2018-10-06 06:55:19 +02:00
|
|
|
Link *link = userdata;
|
2018-09-19 02:32:19 +02:00
|
|
|
int r;
|
2018-01-04 14:12:01 +01:00
|
|
|
|
2018-10-06 06:55:19 +02:00
|
|
|
assert(link);
|
|
|
|
|
2018-09-19 02:32:19 +02:00
|
|
|
r = sd_netlink_message_get_errno(m);
|
|
|
|
if (r < 0 && r != -EEXIST)
|
2018-10-06 06:55:19 +02:00
|
|
|
log_link_debug_errno(link, r, "Received error when adding unreachable route for DHCPv6 delegated subnet: %m");
|
2018-01-04 14:12:01 +01:00
|
|
|
|
2018-10-10 07:39:35 +02:00
|
|
|
return 1;
|
2018-01-04 14:11:59 +01:00
|
|
|
}
|
|
|
|
|
2018-09-19 02:32:19 +02:00
|
|
|
|
2018-01-04 14:11:59 +01:00
|
|
|
static int dhcp6_lease_pd_prefix_acquired(sd_dhcp6_client *client, Link *link) {
|
|
|
|
int r;
|
|
|
|
sd_dhcp6_lease *lease;
|
2018-09-19 02:32:19 +02:00
|
|
|
union in_addr_union pd_prefix;
|
2018-01-04 14:11:59 +01:00
|
|
|
uint8_t pd_prefix_len;
|
|
|
|
uint32_t lifetime_preferred, lifetime_valid;
|
|
|
|
_cleanup_free_ char *buf = NULL;
|
|
|
|
Iterator i = ITERATOR_FIRST;
|
|
|
|
|
|
|
|
r = sd_dhcp6_client_get_lease(client, &lease);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
sd_dhcp6_lease_reset_pd_prefix_iter(lease);
|
|
|
|
|
2018-09-19 02:32:19 +02:00
|
|
|
while (sd_dhcp6_lease_get_pd(lease, &pd_prefix.in6, &pd_prefix_len,
|
2018-01-04 14:11:59 +01:00
|
|
|
&lifetime_preferred,
|
|
|
|
&lifetime_valid) >= 0) {
|
|
|
|
|
|
|
|
if (pd_prefix_len > 64) {
|
2018-09-19 02:32:19 +02:00
|
|
|
(void) in_addr_to_string(AF_INET6, &pd_prefix, &buf);
|
2018-01-04 14:11:59 +01:00
|
|
|
log_link_debug(link, "PD Prefix length > 64, ignoring prefix %s/%u",
|
|
|
|
strnull(buf), pd_prefix_len);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-08-24 17:49:14 +02:00
|
|
|
if (pd_prefix_len < 48) {
|
2018-09-19 02:32:19 +02:00
|
|
|
(void) in_addr_to_string(AF_INET6, &pd_prefix, &buf);
|
2018-08-24 17:49:14 +02:00
|
|
|
log_link_warning(link, "PD Prefix length < 48, looks unusual %s/%u",
|
|
|
|
strnull(buf), pd_prefix_len);
|
|
|
|
}
|
|
|
|
|
2018-09-19 02:32:19 +02:00
|
|
|
if (pd_prefix_len < 64) {
|
|
|
|
Route *route = NULL;
|
|
|
|
|
|
|
|
(void) in_addr_to_string(AF_INET6, &pd_prefix, &buf);
|
|
|
|
|
|
|
|
r = route_new(&route);
|
|
|
|
if (r < 0) {
|
|
|
|
log_link_warning_errno(link, r, "Cannot create unreachable route for DHCPv6 delegated subnet %s/%u: %m",
|
|
|
|
strnull(buf),
|
|
|
|
pd_prefix_len);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
route_add(link, AF_INET6, &pd_prefix, pd_prefix_len,
|
|
|
|
0, 0, 0, &route);
|
|
|
|
route_update(route, NULL, 0, NULL, NULL, 0, 0,
|
|
|
|
RTN_UNREACHABLE);
|
|
|
|
|
2018-10-10 07:38:57 +02:00
|
|
|
r = route_configure(route, link, dhcp6_route_handler);
|
2018-09-19 02:32:19 +02:00
|
|
|
if (r < 0) {
|
|
|
|
log_link_warning_errno(link, r, "Cannot configure unreachable route for delegated subnet %s/%u: %m",
|
|
|
|
strnull(buf),
|
|
|
|
pd_prefix_len);
|
|
|
|
route_free(route);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
route_free(route);
|
|
|
|
|
|
|
|
log_link_debug(link, "Configuring unreachable route for %s/%u",
|
|
|
|
strnull(buf), pd_prefix_len);
|
|
|
|
|
|
|
|
} else
|
|
|
|
log_link_debug(link, "Not adding a blocking route since distributed prefix is /64");
|
|
|
|
|
|
|
|
r = dhcp6_pd_prefix_distribute(link, &i, &pd_prefix.in6,
|
2018-01-04 14:11:59 +01:00
|
|
|
pd_prefix_len,
|
|
|
|
lifetime_preferred,
|
|
|
|
lifetime_valid);
|
|
|
|
if (r < 0 && r != -EAGAIN)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (r >= 0)
|
|
|
|
i = ITERATOR_FIRST;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-10-02 20:29:09 +02:00
|
|
|
int dhcp6_request_prefix_delegation(Link *link) {
|
|
|
|
Link *l;
|
|
|
|
Iterator i;
|
|
|
|
|
|
|
|
assert_return(link, -EINVAL);
|
|
|
|
assert_return(link->manager, -EOPNOTSUPP);
|
|
|
|
|
|
|
|
if (dhcp6_get_prefix_delegation(link) <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
log_link_debug(link, "Requesting DHCPv6 prefixes to be delegated for new link");
|
|
|
|
|
|
|
|
HASHMAP_FOREACH(l, link->manager->links, i) {
|
|
|
|
int r, enabled;
|
|
|
|
|
|
|
|
if (l == link)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!l->dhcp6_client)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
r = sd_dhcp6_client_get_prefix_delegation(l->dhcp6_client, &enabled);
|
|
|
|
if (r < 0) {
|
|
|
|
log_link_warning_errno(l, r, "Cannot get prefix delegation when adding new link");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (enabled == 0) {
|
|
|
|
r = sd_dhcp6_client_set_prefix_delegation(l->dhcp6_client, 1);
|
|
|
|
if (r < 0) {
|
|
|
|
log_link_warning_errno(l, r, "Cannot enable prefix delegation when adding new link");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
r = sd_dhcp6_client_is_running(l->dhcp6_client);
|
|
|
|
if (r <= 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (enabled != 0) {
|
|
|
|
log_link_debug(l, "Requesting re-assignment of delegated prefixes after adding new link");
|
|
|
|
(void) dhcp6_lease_pd_prefix_acquired(l->dhcp6_client, l);
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = sd_dhcp6_client_stop(l->dhcp6_client);
|
|
|
|
if (r < 0) {
|
|
|
|
log_link_warning_errno(l, r, "Cannot stop DHCPv6 prefix delegation client after adding new link");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = sd_dhcp6_client_start(l->dhcp6_client);
|
|
|
|
if (r < 0) {
|
|
|
|
log_link_warning_errno(l, r, "Cannot restart DHCPv6 prefix delegation client after adding new link");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
log_link_debug(l, "Restarted DHCPv6 client to acquire prefix delegations after adding new link");
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-06-12 16:31:33 +02:00
|
|
|
static int dhcp6_address_handler(sd_netlink *rtnl, sd_netlink_message *m,
|
2015-01-20 18:36:04 +01:00
|
|
|
void *userdata) {
|
2018-10-06 06:55:19 +02:00
|
|
|
Link *link = userdata;
|
2015-01-20 18:36:04 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
|
2015-06-12 16:31:33 +02:00
|
|
|
r = sd_netlink_message_get_errno(m);
|
2015-01-20 18:36:04 +01:00
|
|
|
if (r < 0 && r != -EEXIST) {
|
2015-04-10 13:03:18 +02:00
|
|
|
if (link->rtnl_extended_attrs) {
|
|
|
|
log_link_warning(link, "Could not set extended netlink attributes, reverting to fallback mechanism");
|
|
|
|
|
|
|
|
link->rtnl_extended_attrs = false;
|
|
|
|
dhcp6_lease_address_acquired(link->dhcp6_client, link);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-09-30 22:16:17 +02:00
|
|
|
log_link_error_errno(link, r, "Could not set DHCPv6 address: %m");
|
2015-01-20 18:36:04 +01:00
|
|
|
|
|
|
|
link_enter_failed(link);
|
|
|
|
|
|
|
|
} else if (r >= 0)
|
2015-09-22 17:18:20 +02:00
|
|
|
manager_rtnl_process_address(rtnl, m, link->manager);
|
2015-01-20 18:36:04 +01:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
network: beef up ipv6 RA support considerably
This reworks sd-ndisc and networkd substantially to support IPv6 RA much more
comprehensively. Since the API is extended quite a bit networkd has been ported
over too, and the patch is not as straight-forward as one could wish. The
rework includes:
- Support for DNSSL, RDNSS and RA routing options in sd-ndisc and networkd. Two
new configuration options have been added to networkd to make this
configurable.
- sd-ndisc now exposes an sd_ndisc_router object that encapsulates a full RA
message, and has direct, friendly acessor functions for the singleton RA
properties, as well as an iterative interface to iterate through known and
unsupported options. The router object may either be retrieved from the wire,
or generated from raw data. In many ways the sd-ndisc API now matches the
sd-lldp API, except that no implicit database of seen data is kept. (Note
that sd-ndisc actually had a half-written, but unused implementaiton of such
a store, which is removed now.)
- sd-ndisc will now collect the reception timestamps of RA, which is useful to
make sd_ndisc_router fully descriptive of what it covers.
Fixes: #1079
2016-06-02 20:38:12 +02:00
|
|
|
static int dhcp6_address_change(
|
|
|
|
Link *link,
|
|
|
|
struct in6_addr *ip6_addr,
|
|
|
|
uint32_t lifetime_preferred,
|
|
|
|
uint32_t lifetime_valid) {
|
|
|
|
|
tree-wide: drop redundant _cleanup_ macros (#8810)
This drops a good number of type-specific _cleanup_ macros, and patches
all users to just use the generic ones.
In most recent code we abstained from defining type-specific macros, and
this basically removes all those added already, with the exception of
the really low-level ones.
Having explicit macros for this is not too useful, as the expression
without the extra macro is generally just 2ch wider. We should generally
emphesize generic code, unless there are really good reasons for
specific code, hence let's follow this in this case too.
Note that _cleanup_free_ and similar really low-level, libc'ish, Linux
API'ish macros continue to be defined, only the really high-level OO
ones are dropped. From now on this should really be the rule: for really
low-level stuff, such as memory allocation, fd handling and so one, go
ahead and define explicit per-type macros, but for high-level, specific
program code, just use the generic _cleanup_() macro directly, in order
to keep things simple and as readable as possible for the uninitiated.
Note that before this patch some of the APIs (notable libudev ones) were
already used with the high-level macros at some places and with the
generic _cleanup_ macro at others. With this patch we hence unify on the
latter.
2018-04-25 12:31:45 +02:00
|
|
|
_cleanup_(address_freep) Address *addr = NULL;
|
network: beef up ipv6 RA support considerably
This reworks sd-ndisc and networkd substantially to support IPv6 RA much more
comprehensively. Since the API is extended quite a bit networkd has been ported
over too, and the patch is not as straight-forward as one could wish. The
rework includes:
- Support for DNSSL, RDNSS and RA routing options in sd-ndisc and networkd. Two
new configuration options have been added to networkd to make this
configurable.
- sd-ndisc now exposes an sd_ndisc_router object that encapsulates a full RA
message, and has direct, friendly acessor functions for the singleton RA
properties, as well as an iterative interface to iterate through known and
unsupported options. The router object may either be retrieved from the wire,
or generated from raw data. In many ways the sd-ndisc API now matches the
sd-lldp API, except that no implicit database of seen data is kept. (Note
that sd-ndisc actually had a half-written, but unused implementaiton of such
a store, which is removed now.)
- sd-ndisc will now collect the reception timestamps of RA, which is useful to
make sd_ndisc_router fully descriptive of what it covers.
Fixes: #1079
2016-06-02 20:38:12 +02:00
|
|
|
char buffer[INET6_ADDRSTRLEN];
|
|
|
|
int r;
|
2015-01-20 18:36:04 +01:00
|
|
|
|
2015-09-21 15:53:40 +02:00
|
|
|
r = address_new(&addr);
|
2015-01-20 18:36:04 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
addr->family = AF_INET6;
|
|
|
|
memcpy(&addr->in_addr.in6, ip6_addr, sizeof(*ip6_addr));
|
2015-02-02 12:13:17 +01:00
|
|
|
|
|
|
|
addr->flags = IFA_F_NOPREFIXROUTE;
|
2015-10-18 16:59:21 +02:00
|
|
|
addr->prefixlen = 128;
|
2015-01-20 18:36:04 +01:00
|
|
|
|
|
|
|
addr->cinfo.ifa_prefered = lifetime_preferred;
|
|
|
|
addr->cinfo.ifa_valid = lifetime_valid;
|
|
|
|
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_link_info(link,
|
network: beef up ipv6 RA support considerably
This reworks sd-ndisc and networkd substantially to support IPv6 RA much more
comprehensively. Since the API is extended quite a bit networkd has been ported
over too, and the patch is not as straight-forward as one could wish. The
rework includes:
- Support for DNSSL, RDNSS and RA routing options in sd-ndisc and networkd. Two
new configuration options have been added to networkd to make this
configurable.
- sd-ndisc now exposes an sd_ndisc_router object that encapsulates a full RA
message, and has direct, friendly acessor functions for the singleton RA
properties, as well as an iterative interface to iterate through known and
unsupported options. The router object may either be retrieved from the wire,
or generated from raw data. In many ways the sd-ndisc API now matches the
sd-lldp API, except that no implicit database of seen data is kept. (Note
that sd-ndisc actually had a half-written, but unused implementaiton of such
a store, which is removed now.)
- sd-ndisc will now collect the reception timestamps of RA, which is useful to
make sd_ndisc_router fully descriptive of what it covers.
Fixes: #1079
2016-06-02 20:38:12 +02:00
|
|
|
"DHCPv6 address %s/%d timeout preferred %d valid %d",
|
|
|
|
inet_ntop(AF_INET6, &addr->in_addr.in6, buffer, sizeof(buffer)),
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
addr->prefixlen, lifetime_preferred, lifetime_valid);
|
2015-01-20 18:36:04 +01:00
|
|
|
|
2015-10-01 17:31:14 +02:00
|
|
|
r = address_configure(addr, link, dhcp6_address_handler, true);
|
2015-01-20 18:36:04 +01:00
|
|
|
if (r < 0)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_link_warning_errno(link, r, "Could not assign DHCPv6 address: %m");
|
2015-01-20 18:36:04 +01:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dhcp6_lease_address_acquired(sd_dhcp6_client *client, Link *link) {
|
|
|
|
int r;
|
|
|
|
sd_dhcp6_lease *lease;
|
|
|
|
struct in6_addr ip6_addr;
|
|
|
|
uint32_t lifetime_preferred, lifetime_valid;
|
|
|
|
|
|
|
|
r = sd_dhcp6_client_get_lease(client, &lease);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
sd_dhcp6_lease_reset_address_iter(lease);
|
|
|
|
|
|
|
|
while (sd_dhcp6_lease_get_address(lease, &ip6_addr,
|
2016-05-15 16:22:40 +02:00
|
|
|
&lifetime_preferred,
|
|
|
|
&lifetime_valid) >= 0) {
|
2015-01-20 18:36:04 +01:00
|
|
|
|
2015-10-18 16:59:21 +02:00
|
|
|
r = dhcp6_address_change(link, &ip6_addr, lifetime_preferred, lifetime_valid);
|
2015-01-20 18:36:04 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-10 15:17:34 +01:00
|
|
|
static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
|
2015-01-20 18:36:04 +01:00
|
|
|
int r;
|
2014-12-10 15:17:34 +01:00
|
|
|
Link *link = userdata;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
assert(link->network);
|
|
|
|
|
|
|
|
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch(event) {
|
2015-09-22 14:52:23 +02:00
|
|
|
case SD_DHCP6_CLIENT_EVENT_STOP:
|
|
|
|
case SD_DHCP6_CLIENT_EVENT_RESEND_EXPIRE:
|
|
|
|
case SD_DHCP6_CLIENT_EVENT_RETRANS_MAX:
|
2015-11-13 14:35:39 +01:00
|
|
|
if (sd_dhcp6_client_get_lease(client, NULL) >= 0)
|
|
|
|
log_link_warning(link, "DHCPv6 lease lost");
|
2015-09-23 13:52:03 +02:00
|
|
|
|
2018-09-19 02:32:19 +02:00
|
|
|
(void) dhcp6_lease_pd_prefix_lost(client, link);
|
2018-01-04 14:11:59 +01:00
|
|
|
(void) manager_dhcp6_prefix_remove_all(link->manager, link);
|
|
|
|
|
2015-09-23 13:52:03 +02:00
|
|
|
link->dhcp6_configured = false;
|
2015-01-20 18:36:04 +01:00
|
|
|
break;
|
|
|
|
|
2015-09-22 14:52:23 +02:00
|
|
|
case SD_DHCP6_CLIENT_EVENT_IP_ACQUIRE:
|
2015-01-20 18:36:04 +01:00
|
|
|
r = dhcp6_lease_address_acquired(client, link);
|
|
|
|
if (r < 0) {
|
|
|
|
link_enter_failed(link);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-01-04 14:11:59 +01:00
|
|
|
r = dhcp6_lease_pd_prefix_acquired(client, link);
|
|
|
|
if (r < 0)
|
|
|
|
log_link_debug(link, "DHCPv6 did not receive prefixes to delegate");
|
|
|
|
|
2017-11-19 19:06:10 +01:00
|
|
|
_fallthrough_;
|
2015-09-22 14:52:23 +02:00
|
|
|
case SD_DHCP6_CLIENT_EVENT_INFORMATION_REQUEST:
|
2015-01-20 18:36:04 +01:00
|
|
|
r = dhcp6_lease_information_acquired(client, link);
|
|
|
|
if (r < 0) {
|
|
|
|
link_enter_failed(link);
|
|
|
|
return;
|
|
|
|
}
|
2014-12-10 15:17:34 +01:00
|
|
|
|
2015-09-23 13:52:03 +02:00
|
|
|
link->dhcp6_configured = true;
|
2014-12-10 15:17:34 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
if (event < 0)
|
2015-09-30 22:16:17 +02:00
|
|
|
log_link_warning_errno(link, event, "DHCPv6 error: %m");
|
2014-12-10 15:17:34 +01:00
|
|
|
else
|
2015-09-30 22:16:17 +02:00
|
|
|
log_link_warning(link, "DHCPv6 unknown event: %d", event);
|
2014-12-10 15:17:34 +01:00
|
|
|
return;
|
|
|
|
}
|
2015-09-23 13:52:03 +02:00
|
|
|
|
2015-09-28 13:38:43 +02:00
|
|
|
link_check_ready(link);
|
2014-12-10 15:17:34 +01:00
|
|
|
}
|
|
|
|
|
2016-06-01 08:54:46 +02:00
|
|
|
int dhcp6_request_address(Link *link, int ir) {
|
2018-09-07 22:15:55 +02:00
|
|
|
int r, inf_req, pd;
|
2015-11-10 15:43:52 +01:00
|
|
|
bool running;
|
2014-12-10 15:17:34 +01:00
|
|
|
|
2015-11-10 15:43:52 +01:00
|
|
|
assert(link);
|
|
|
|
assert(link->dhcp6_client);
|
2018-09-07 22:15:55 +02:00
|
|
|
assert(link->network);
|
2016-06-01 08:54:46 +02:00
|
|
|
assert(in_addr_is_link_local(AF_INET6, (const union in_addr_union*)&link->ipv6ll_address) > 0);
|
2014-12-10 15:17:35 +01:00
|
|
|
|
2015-11-10 15:43:52 +01:00
|
|
|
r = sd_dhcp6_client_is_running(link->dhcp6_client);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
else
|
2018-06-11 16:02:03 +02:00
|
|
|
running = r;
|
2015-09-23 13:10:26 +02:00
|
|
|
|
2018-09-07 22:15:55 +02:00
|
|
|
r = sd_dhcp6_client_get_prefix_delegation(link->dhcp6_client, &pd);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (pd && ir && link->network->dhcp6_force_pd_other_information) {
|
|
|
|
log_link_debug(link, "Enabling managed mode to request DHCPv6 PD with 'Other Information' set");
|
|
|
|
|
|
|
|
r = sd_dhcp6_client_set_address_request(link->dhcp6_client,
|
|
|
|
false);
|
|
|
|
if (r < 0 )
|
|
|
|
return r;
|
|
|
|
|
|
|
|
ir = false;
|
|
|
|
}
|
|
|
|
|
2015-11-10 15:43:52 +01:00
|
|
|
if (running) {
|
2016-06-01 08:54:46 +02:00
|
|
|
r = sd_dhcp6_client_get_information_request(link->dhcp6_client, &inf_req);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (inf_req == ir)
|
|
|
|
return 0;
|
|
|
|
|
2015-11-10 15:43:52 +01:00
|
|
|
r = sd_dhcp6_client_stop(link->dhcp6_client);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2016-06-01 08:54:46 +02:00
|
|
|
} else {
|
|
|
|
r = sd_dhcp6_client_set_local_address(link->dhcp6_client, &link->ipv6ll_address);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2015-11-10 15:43:52 +01:00
|
|
|
}
|
2014-12-10 15:17:35 +01:00
|
|
|
|
2016-06-01 08:54:46 +02:00
|
|
|
r = sd_dhcp6_client_set_information_request(link->dhcp6_client, ir);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = sd_dhcp6_client_start(link->dhcp6_client);
|
2015-11-10 15:43:52 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2014-12-10 15:17:35 +01:00
|
|
|
|
2015-11-10 15:43:52 +01:00
|
|
|
return 0;
|
|
|
|
}
|
2015-09-23 13:52:03 +02:00
|
|
|
|
2017-11-16 10:07:07 +01:00
|
|
|
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 r;
|
|
|
|
|
|
|
|
hn = hostname;
|
|
|
|
}
|
|
|
|
|
2018-08-02 09:31:10 +02:00
|
|
|
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_warning_errno(link, r, "DHCP6 CLIENT: Failed to set hostname from kernel hostname, ignoring: %m");
|
|
|
|
else if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to set hostname: %m");
|
|
|
|
|
|
|
|
return 0;
|
2017-11-16 10:07:07 +01:00
|
|
|
}
|
|
|
|
|
2015-11-10 15:43:52 +01:00
|
|
|
int dhcp6_configure(Link *link) {
|
2018-08-01 03:42:49 +02:00
|
|
|
_cleanup_(sd_dhcp6_client_unrefp) sd_dhcp6_client *client = NULL;
|
networkd: rework duid_{type,duid_type,duid,duid_len} setting
Separate fields are replaced with a struct.
Second second duid type field is removed. The first field was used to carry
the result of DUIDType= configuration, and the second was either a copy of
this, or contained the type extracted from DuidRawData. The semantics are changed
so that the type specified in DUIDType is always used. DUIDRawData= no longer
overrides the type setting.
The networkd code is now more constrained than the sd-dhcp code:
DUIDRawData cannot have 0 length, length 0 is treated the same as unsetting.
Likewise, it is not possible to set a DUIDType=0. If it ever becomes necessary
to set type=0 or a zero-length duid, the code can be changed to support that.
Nevertheless, I think that's unlikely.
This addresses #3127 § 1 and 3.
v2:
- rename DUID.duid, DUID.duid_len to DUID.raw_data, DUID.raw_data_len
2016-04-29 05:23:45 +02:00
|
|
|
const DUID *duid;
|
2018-01-22 09:09:18 +01:00
|
|
|
int r;
|
2015-11-10 15:43:52 +01:00
|
|
|
|
|
|
|
assert(link);
|
2018-01-22 09:09:18 +01:00
|
|
|
assert(link->network);
|
2015-11-10 15:43:52 +01:00
|
|
|
|
2015-11-16 16:47:18 +01:00
|
|
|
if (link->dhcp6_client)
|
|
|
|
return 0;
|
|
|
|
|
2015-11-10 15:43:52 +01:00
|
|
|
r = sd_dhcp6_client_new(&client);
|
2018-08-01 03:42:49 +02:00
|
|
|
if (r == -ENOMEM)
|
|
|
|
return log_oom();
|
2015-11-10 15:43:52 +01:00
|
|
|
if (r < 0)
|
2018-08-01 03:42:49 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to create DHCP6 client: %m");
|
2014-12-10 15:17:34 +01:00
|
|
|
|
2015-11-10 15:43:52 +01:00
|
|
|
r = sd_dhcp6_client_attach_event(client, NULL, 0);
|
2014-12-10 15:17:34 +01:00
|
|
|
if (r < 0)
|
2018-08-01 03:42:49 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to attach event: %m");
|
2014-12-10 15:17:34 +01:00
|
|
|
|
2015-11-10 15:43:52 +01:00
|
|
|
r = sd_dhcp6_client_set_mac(client,
|
2014-12-10 15:17:34 +01:00
|
|
|
(const uint8_t *) &link->mac,
|
|
|
|
sizeof (link->mac), ARPHRD_ETHER);
|
2015-09-23 13:10:26 +02:00
|
|
|
if (r < 0)
|
2018-08-01 03:42:49 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to set MAC address: %m");
|
2014-12-10 15:17:34 +01:00
|
|
|
|
2016-03-31 01:33:55 +02:00
|
|
|
r = sd_dhcp6_client_set_iaid(client, link->network->iaid);
|
|
|
|
if (r < 0)
|
2018-08-01 03:42:49 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to set IAID: %m");
|
2016-03-31 01:33:55 +02:00
|
|
|
|
2018-08-06 10:28:27 +02:00
|
|
|
duid = link_get_duid(link);
|
2018-08-07 06:57:48 +02:00
|
|
|
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);
|
2016-03-31 01:33:55 +02:00
|
|
|
if (r < 0)
|
2018-08-01 03:42:49 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to set DUID: %m");
|
2016-03-31 01:33:55 +02:00
|
|
|
|
2017-11-16 10:07:07 +01:00
|
|
|
r = dhcp6_set_hostname(client, link);
|
|
|
|
if (r < 0)
|
2018-08-02 09:31:10 +02:00
|
|
|
return r;
|
2017-11-16 10:07:07 +01:00
|
|
|
|
2016-05-23 16:13:18 +02:00
|
|
|
r = sd_dhcp6_client_set_ifindex(client, link->ifindex);
|
2015-09-23 13:10:26 +02:00
|
|
|
if (r < 0)
|
2018-08-01 03:42:49 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to set ifindex: %m");
|
2014-12-10 15:17:34 +01:00
|
|
|
|
2018-01-22 09:09:18 +01:00
|
|
|
if (link->network->rapid_commit) {
|
|
|
|
r = sd_dhcp6_client_set_request_option(client, SD_DHCP6_OPTION_RAPID_COMMIT);
|
|
|
|
if (r < 0)
|
2018-08-01 03:42:49 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to set request flag for rapid commit: %m");
|
2018-01-22 09:09:18 +01:00
|
|
|
}
|
|
|
|
|
2015-11-10 15:43:52 +01:00
|
|
|
r = sd_dhcp6_client_set_callback(client, dhcp6_handler, link);
|
2015-09-23 13:10:26 +02:00
|
|
|
if (r < 0)
|
2018-08-01 03:42:49 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to set callback: %m");
|
2014-12-10 15:17:34 +01:00
|
|
|
|
2018-01-04 14:11:51 +01:00
|
|
|
if (dhcp6_enable_prefix_delegation(link)) {
|
|
|
|
r = sd_dhcp6_client_set_prefix_delegation(client, true);
|
|
|
|
if (r < 0)
|
2018-08-01 03:42:49 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to set prefix delegation: %m");
|
2018-01-04 14:11:51 +01:00
|
|
|
}
|
|
|
|
|
2018-08-01 03:42:49 +02:00
|
|
|
link->dhcp6_client = TAKE_PTR(client);
|
2015-09-23 13:10:26 +02:00
|
|
|
|
2015-11-10 15:43:52 +01:00
|
|
|
return 0;
|
2014-12-10 15:17:34 +01:00
|
|
|
}
|