2017-11-18 17:09:20 +01:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1+ */
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-05-09 02:33:45 +02:00
|
|
|
#include <netinet/in.h>
|
2020-03-02 21:44:01 +01:00
|
|
|
#include <netinet/ip.h>
|
2014-08-08 12:12:17 +02:00
|
|
|
#include <linux/if.h>
|
2019-07-24 11:22:43 +02:00
|
|
|
#include <linux/if_arp.h>
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2020-03-30 16:43:28 +02:00
|
|
|
#include "escape.h"
|
2015-10-27 03:01:06 +01:00
|
|
|
#include "alloc-util.h"
|
2019-09-26 20:06:02 +02:00
|
|
|
#include "dhcp-client-internal.h"
|
2015-05-18 17:10:07 +02:00
|
|
|
#include "hostname-util.h"
|
2017-11-24 21:03:05 +01:00
|
|
|
#include "parse-util.h"
|
2014-08-08 12:12:17 +02:00
|
|
|
#include "network-internal.h"
|
2019-06-29 20:57:47 +02:00
|
|
|
#include "networkd-dhcp4.h"
|
2016-11-13 04:59:06 +01:00
|
|
|
#include "networkd-link.h"
|
|
|
|
#include "networkd-manager.h"
|
|
|
|
#include "networkd-network.h"
|
2019-06-29 20:57:47 +02:00
|
|
|
#include "string-table.h"
|
2017-11-24 21:03:05 +01:00
|
|
|
#include "string-util.h"
|
|
|
|
#include "sysctl-util.h"
|
2020-03-30 16:43:28 +02:00
|
|
|
#include "web-util.h"
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-07-16 19:14:27 +02:00
|
|
|
static int dhcp_remove_routes(Link *link, sd_dhcp_lease *lease, const struct in_addr *address, bool remove_all);
|
|
|
|
static int dhcp_remove_router(Link *link, sd_dhcp_lease *lease, const struct in_addr *address, bool remove_all);
|
2019-07-16 19:30:56 +02:00
|
|
|
static int dhcp_remove_dns_routes(Link *link, sd_dhcp_lease *lease, const struct in_addr *address, bool remove_all);
|
2019-07-22 04:25:31 +02:00
|
|
|
static int dhcp_remove_address(Link *link, sd_dhcp_lease *lease, const struct in_addr *address, link_netlink_message_handler_t callback);
|
|
|
|
static int dhcp_remove_address_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link);
|
|
|
|
static int dhcp_lease_renew(sd_dhcp_client *client, Link *link);
|
2019-06-07 08:31:07 +02:00
|
|
|
|
|
|
|
void dhcp4_release_old_lease(Link *link) {
|
2019-07-16 19:14:27 +02:00
|
|
|
struct in_addr address = {}, address_old = {};
|
2019-06-07 08:31:07 +02:00
|
|
|
|
|
|
|
assert(link);
|
|
|
|
|
|
|
|
if (!link->dhcp_lease_old)
|
|
|
|
return;
|
|
|
|
|
|
|
|
assert(link->dhcp_lease);
|
|
|
|
|
2019-07-16 19:14:27 +02:00
|
|
|
(void) sd_dhcp_lease_get_address(link->dhcp_lease_old, &address_old);
|
|
|
|
(void) sd_dhcp_lease_get_address(link->dhcp_lease, &address);
|
2019-06-07 08:31:07 +02:00
|
|
|
|
2019-07-16 19:14:27 +02:00
|
|
|
(void) dhcp_remove_routes(link, link->dhcp_lease_old, &address_old, false);
|
|
|
|
(void) dhcp_remove_router(link, link->dhcp_lease_old, &address_old, false);
|
2019-07-16 19:30:56 +02:00
|
|
|
(void) dhcp_remove_dns_routes(link, link->dhcp_lease_old, &address_old, false);
|
2019-06-07 08:31:07 +02:00
|
|
|
|
2019-07-16 19:14:27 +02:00
|
|
|
if (!in4_addr_equal(&address_old, &address))
|
2019-07-22 04:25:31 +02:00
|
|
|
(void) dhcp_remove_address(link, link->dhcp_lease_old, &address_old, NULL);
|
2019-06-07 08:31:07 +02:00
|
|
|
|
|
|
|
link->dhcp_lease_old = sd_dhcp_lease_unref(link->dhcp_lease_old);
|
|
|
|
link_dirty(link);
|
|
|
|
}
|
|
|
|
|
2019-12-20 16:19:25 +01:00
|
|
|
static void dhcp4_check_ready(Link *link) {
|
|
|
|
if (link->dhcp4_messages == 0) {
|
|
|
|
link->dhcp4_configured = true;
|
|
|
|
/* New address and routes are configured now. Let's release old lease. */
|
|
|
|
dhcp4_release_old_lease(link);
|
|
|
|
link_check_ready(link);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-28 21:06:52 +01:00
|
|
|
static int dhcp4_route_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
|
2014-08-08 12:12:17 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
2015-11-03 13:01:43 +01:00
|
|
|
assert(link->dhcp4_messages > 0);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2016-02-23 05:32:04 +01:00
|
|
|
link->dhcp4_messages--;
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-06-07 08:04:11 +02:00
|
|
|
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
|
|
|
return 1;
|
|
|
|
|
2015-06-12 16:31:33 +02:00
|
|
|
r = sd_netlink_message_get_errno(m);
|
2019-07-22 04:25:31 +02:00
|
|
|
if (r == -ENETUNREACH && !link->dhcp4_route_retrying) {
|
|
|
|
|
|
|
|
/* It seems kernel does not support that the prefix route cannot be configured with
|
|
|
|
* route table. Let's once drop the config and reconfigure them later. */
|
|
|
|
|
2020-02-09 15:44:11 +01:00
|
|
|
log_link_message_debug_errno(link, m, r, "Could not set DHCPv4 route, retrying later");
|
2019-07-22 04:25:31 +02:00
|
|
|
link->dhcp4_route_failed = true;
|
|
|
|
link->manager->dhcp4_prefix_root_cannot_set_table = true;
|
|
|
|
} else if (r < 0 && r != -EEXIST) {
|
2020-02-09 15:44:11 +01:00
|
|
|
log_link_message_warning_errno(link, m, r, "Could not set DHCPv4 route");
|
2014-08-08 12:12:17 +02:00
|
|
|
link_enter_failed(link);
|
2019-06-07 08:04:11 +02:00
|
|
|
return 1;
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
2015-11-03 13:01:43 +01:00
|
|
|
if (link->dhcp4_messages == 0) {
|
2019-07-22 04:25:31 +02:00
|
|
|
if (link->dhcp4_route_failed) {
|
|
|
|
struct in_addr address = {};
|
|
|
|
|
|
|
|
link->dhcp4_route_failed = false;
|
|
|
|
link->dhcp4_route_retrying = true;
|
|
|
|
|
|
|
|
(void) sd_dhcp_lease_get_address(link->dhcp_lease, &address);
|
|
|
|
(void) dhcp_remove_routes(link, link->dhcp_lease, &address, true);
|
|
|
|
(void) dhcp_remove_router(link, link->dhcp_lease, &address, true);
|
|
|
|
(void) dhcp_remove_dns_routes(link, link->dhcp_lease, &address, true);
|
|
|
|
(void) dhcp_remove_address(link, link->dhcp_lease, &address, dhcp_remove_address_handler);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2019-12-20 16:19:25 +01:00
|
|
|
if (!link->network->dhcp_send_decline)
|
|
|
|
dhcp4_check_ready(link);
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-05-20 13:05:18 +02:00
|
|
|
static int route_scope_from_address(const Route *route, const struct in_addr *self_addr) {
|
|
|
|
assert(route);
|
|
|
|
assert(self_addr);
|
|
|
|
|
2019-07-06 04:17:48 +02:00
|
|
|
if (in4_addr_is_localhost(&route->dst.in) ||
|
|
|
|
(!in4_addr_is_null(self_addr) && in4_addr_equal(&route->dst.in, self_addr)))
|
2017-05-20 13:05:18 +02:00
|
|
|
return RT_SCOPE_HOST;
|
|
|
|
else if (in4_addr_is_null(&route->gw.in))
|
|
|
|
return RT_SCOPE_LINK;
|
|
|
|
else
|
|
|
|
return RT_SCOPE_UNIVERSE;
|
|
|
|
}
|
|
|
|
|
2019-12-07 16:32:36 +01:00
|
|
|
static bool link_prefixroute(Link *link) {
|
|
|
|
return !link->network->dhcp_route_table_set ||
|
|
|
|
link->network->dhcp_route_table == RT_TABLE_MAIN ||
|
|
|
|
link->manager->dhcp4_prefix_root_cannot_set_table;
|
2019-07-22 04:22:28 +02:00
|
|
|
}
|
|
|
|
|
2019-07-16 19:14:27 +02:00
|
|
|
static int dhcp_route_configure(Route **route, Link *link) {
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(route);
|
|
|
|
assert(*route);
|
|
|
|
assert(link);
|
|
|
|
|
|
|
|
if (set_contains(link->dhcp_routes, *route))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
r = route_configure(*route, link, dhcp4_route_handler);
|
|
|
|
if (r <= 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
link->dhcp4_messages++;
|
|
|
|
|
|
|
|
r = set_put(link->dhcp_routes, *route);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
TAKE_PTR(*route);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-16 19:30:56 +02:00
|
|
|
static int link_set_dns_routes(Link *link, const struct in_addr *address) {
|
|
|
|
const struct in_addr *dns;
|
|
|
|
uint32_t table;
|
|
|
|
int i, n, r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
assert(link->dhcp_lease);
|
|
|
|
assert(link->network);
|
|
|
|
|
2019-07-16 19:47:20 +02:00
|
|
|
if (!link->network->dhcp_use_dns ||
|
|
|
|
!link->network->dhcp_routes_to_dns)
|
2019-07-16 19:30:56 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
n = sd_dhcp_lease_get_dns(link->dhcp_lease, &dns);
|
|
|
|
if (IN_SET(n, 0, -ENODATA))
|
|
|
|
return 0;
|
|
|
|
if (n < 0)
|
|
|
|
return log_link_warning_errno(link, n, "DHCP error: could not get DNS servers: %m");
|
|
|
|
|
|
|
|
table = link_get_dhcp_route_table(link);
|
|
|
|
|
|
|
|
for (i = 0; i < n; i ++) {
|
|
|
|
_cleanup_(route_freep) Route *route = NULL;
|
|
|
|
|
|
|
|
r = route_new(&route);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "Could not allocate route: %m");
|
|
|
|
|
|
|
|
/* Set routes to DNS servers. */
|
|
|
|
|
|
|
|
route->family = AF_INET;
|
|
|
|
route->dst.in = dns[i];
|
|
|
|
route->dst_prefixlen = 32;
|
|
|
|
route->prefsrc.in = *address;
|
|
|
|
route->scope = RT_SCOPE_LINK;
|
|
|
|
route->protocol = RTPROT_DHCP;
|
|
|
|
route->priority = link->network->dhcp_route_metric;
|
|
|
|
route->table = table;
|
|
|
|
|
|
|
|
r = dhcp_route_configure(&route, link);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "Could not set route to DNS server: %m");
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-10-03 15:46:44 +02:00
|
|
|
static int dhcp_prefix_route_from_lease(
|
|
|
|
const sd_dhcp_lease *lease,
|
|
|
|
uint32_t table,
|
|
|
|
const struct in_addr *address,
|
|
|
|
Route **ret_route) {
|
|
|
|
|
|
|
|
Route *route;
|
|
|
|
struct in_addr netmask;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
r = sd_dhcp_lease_get_netmask((sd_dhcp_lease*) lease, &netmask);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = route_new(&route);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
route->family = AF_INET;
|
|
|
|
route->dst.in.s_addr = address->s_addr & netmask.s_addr;
|
|
|
|
route->dst_prefixlen = in4_addr_netmask_to_prefixlen(&netmask);
|
|
|
|
route->prefsrc.in = *address;
|
|
|
|
route->scope = RT_SCOPE_LINK;
|
|
|
|
route->protocol = RTPROT_DHCP;
|
|
|
|
route->table = table;
|
|
|
|
*ret_route = route;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-08 12:12:17 +02:00
|
|
|
static int link_set_dhcp_routes(Link *link) {
|
2016-01-20 14:44:14 +01:00
|
|
|
_cleanup_free_ sd_dhcp_route **static_routes = NULL;
|
2018-01-20 00:42:45 +01:00
|
|
|
bool classless_route = false, static_route = false;
|
2018-12-14 11:10:57 +01:00
|
|
|
const struct in_addr *router;
|
|
|
|
struct in_addr address;
|
2014-08-08 12:12:17 +02:00
|
|
|
int r, n, i;
|
2017-09-07 11:08:39 +02:00
|
|
|
uint32_t table;
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
assert(link);
|
2017-08-31 10:58:39 +02:00
|
|
|
|
|
|
|
if (!link->dhcp_lease) /* link went down while we configured the IP addresses? */
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!link->network) /* link went down while we configured the IP addresses? */
|
|
|
|
return 0;
|
2016-04-21 02:36:33 +02:00
|
|
|
|
2019-07-16 06:02:38 +02:00
|
|
|
if (!link_has_carrier(link) && !link->network->configure_without_carrier)
|
|
|
|
/* During configuring addresses, the link lost its carrier. As networkd is dropping
|
|
|
|
* the addresses now, let's not configure the routes either. */
|
|
|
|
return 0;
|
|
|
|
|
2019-09-09 17:17:28 +02:00
|
|
|
r = set_ensure_allocated(&link->dhcp_routes, &route_hash_ops);
|
2019-07-16 19:14:27 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
/* Clear old entries in case the set was already allocated */
|
|
|
|
set_clear(link->dhcp_routes);
|
|
|
|
|
2019-02-12 04:49:45 +01:00
|
|
|
table = link_get_dhcp_route_table(link);
|
2017-09-07 11:08:39 +02:00
|
|
|
|
2017-05-24 14:05:49 +02:00
|
|
|
r = sd_dhcp_lease_get_address(link->dhcp_lease, &address);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_warning_errno(link, r, "DHCP error: could not get address: %m");
|
|
|
|
|
2019-12-07 16:32:36 +01:00
|
|
|
if (!link_prefixroute(link)) {
|
2019-07-22 04:22:28 +02:00
|
|
|
_cleanup_(route_freep) Route *prefix_route = NULL;
|
|
|
|
|
2019-10-03 15:46:44 +02:00
|
|
|
r = dhcp_prefix_route_from_lease(link->dhcp_lease, table, &address, &prefix_route);
|
2019-07-22 04:22:28 +02:00
|
|
|
if (r < 0)
|
2019-10-03 15:46:44 +02:00
|
|
|
return log_link_error_errno(link, r, "Could not create prefix route: %m");
|
2019-07-22 04:22:28 +02:00
|
|
|
|
|
|
|
r = dhcp_route_configure(&prefix_route, link);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "Could not set prefix route: %m");
|
|
|
|
}
|
|
|
|
|
2017-11-22 07:43:55 +01:00
|
|
|
n = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes);
|
2018-06-25 14:04:22 +02:00
|
|
|
if (n == -ENODATA)
|
|
|
|
log_link_debug_errno(link, n, "DHCP: No routes received from DHCP server: %m");
|
|
|
|
else if (n < 0)
|
2019-09-16 20:46:39 +02:00
|
|
|
log_link_debug_errno(link, n, "DHCP: could not get routes: %m");
|
2017-11-22 07:43:55 +01:00
|
|
|
|
2018-01-20 00:42:45 +01:00
|
|
|
for (i = 0; i < n; i++) {
|
2018-11-27 12:18:29 +01:00
|
|
|
switch (sd_dhcp_route_get_option(static_routes[i])) {
|
|
|
|
case SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE:
|
2018-01-20 00:42:45 +01:00
|
|
|
classless_route = true;
|
2018-11-27 12:18:29 +01:00
|
|
|
break;
|
|
|
|
case SD_DHCP_OPTION_STATIC_ROUTE:
|
2018-01-20 00:42:45 +01:00
|
|
|
static_route = true;
|
2018-11-27 12:18:29 +01:00
|
|
|
break;
|
|
|
|
}
|
2018-01-20 00:42:45 +01:00
|
|
|
}
|
|
|
|
|
2020-03-01 05:12:39 +01:00
|
|
|
if (link->network->dhcp_use_routes) {
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
_cleanup_(route_freep) Route *route = NULL;
|
|
|
|
|
|
|
|
/* if the DHCP server returns both a Classless Static Routes option and a Static Routes option,
|
|
|
|
the DHCP client MUST ignore the Static Routes option. */
|
|
|
|
if (classless_route &&
|
|
|
|
sd_dhcp_route_get_option(static_routes[i]) != SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
r = route_new(&route);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "Could not allocate route: %m");
|
|
|
|
|
|
|
|
route->family = AF_INET;
|
|
|
|
route->protocol = RTPROT_DHCP;
|
|
|
|
assert_se(sd_dhcp_route_get_gateway(static_routes[i], &route->gw.in) >= 0);
|
|
|
|
assert_se(sd_dhcp_route_get_destination(static_routes[i], &route->dst.in) >= 0);
|
|
|
|
assert_se(sd_dhcp_route_get_destination_prefix_length(static_routes[i], &route->dst_prefixlen) >= 0);
|
|
|
|
route->priority = link->network->dhcp_route_metric;
|
|
|
|
route->table = table;
|
|
|
|
route->mtu = link->network->dhcp_route_mtu;
|
|
|
|
route->scope = route_scope_from_address(route, &address);
|
|
|
|
if (IN_SET(route->scope, RT_SCOPE_LINK, RT_SCOPE_UNIVERSE))
|
|
|
|
route->prefsrc.in = address;
|
|
|
|
|
|
|
|
if (set_contains(link->dhcp_routes, route))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
r = dhcp_route_configure(&route, link);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "Could not set route: %m");
|
|
|
|
}
|
2017-11-22 07:43:55 +01:00
|
|
|
}
|
|
|
|
|
2020-04-16 00:05:14 +02:00
|
|
|
if (link->network->dhcp_use_gateway) {
|
|
|
|
r = sd_dhcp_lease_get_router(link->dhcp_lease, &router);
|
|
|
|
if (IN_SET(r, 0, -ENODATA))
|
|
|
|
log_link_info(link, "DHCP: No gateway received from DHCP server.");
|
|
|
|
else if (r < 0)
|
|
|
|
log_link_warning_errno(link, r, "DHCP error: could not get gateway: %m");
|
|
|
|
else if (in4_addr_is_null(&router[0]))
|
|
|
|
log_link_info(link, "DHCP: Received gateway is null.");
|
|
|
|
|
|
|
|
/* According to RFC 3442: If the DHCP server returns both a Classless Static Routes option and
|
|
|
|
a Router option, the DHCP client MUST ignore the Router option. */
|
|
|
|
if (classless_route && static_route)
|
|
|
|
log_link_warning(link, "Classless static routes received from DHCP server: ignoring static-route option and router option");
|
|
|
|
|
|
|
|
if (r > 0 && !classless_route && !in4_addr_is_null(&router[0])) {
|
|
|
|
_cleanup_(route_freep) Route *route = NULL, *route_gw = NULL;
|
|
|
|
|
|
|
|
r = route_new(&route_gw);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "Could not allocate route: %m");
|
|
|
|
|
|
|
|
/* The dhcp netmask may mask out the gateway. Add an explicit
|
|
|
|
* route for the gw host so that we can route no matter the
|
|
|
|
* netmask or existing kernel route tables. */
|
|
|
|
route_gw->family = AF_INET;
|
|
|
|
route_gw->dst.in = router[0];
|
|
|
|
route_gw->dst_prefixlen = 32;
|
|
|
|
route_gw->prefsrc.in = address;
|
|
|
|
route_gw->scope = RT_SCOPE_LINK;
|
|
|
|
route_gw->protocol = RTPROT_DHCP;
|
|
|
|
route_gw->priority = link->network->dhcp_route_metric;
|
|
|
|
route_gw->table = table;
|
|
|
|
route_gw->mtu = link->network->dhcp_route_mtu;
|
|
|
|
|
|
|
|
r = dhcp_route_configure(&route_gw, link);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "Could not set host route: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2020-04-16 00:05:14 +02:00
|
|
|
r = route_new(&route);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "Could not allocate route: %m");
|
2019-02-11 13:25:13 +01:00
|
|
|
|
2020-04-16 00:05:14 +02:00
|
|
|
route->family = AF_INET;
|
|
|
|
route->gw.in = router[0];
|
|
|
|
route->prefsrc.in = address;
|
|
|
|
route->protocol = RTPROT_DHCP;
|
|
|
|
route->priority = link->network->dhcp_route_metric;
|
|
|
|
route->table = table;
|
|
|
|
route->mtu = link->network->dhcp_route_mtu;
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2020-04-16 00:05:14 +02:00
|
|
|
r = dhcp_route_configure(&route, link);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "Could not set router: %m");
|
|
|
|
}
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2020-04-16 00:05:14 +02:00
|
|
|
Route *rt;
|
|
|
|
LIST_FOREACH(routes, rt, link->network->static_routes) {
|
|
|
|
if (!rt->gateway_from_dhcp)
|
|
|
|
continue;
|
2020-01-07 06:43:09 +01:00
|
|
|
|
2020-04-16 00:05:14 +02:00
|
|
|
if (rt->family != AF_INET)
|
|
|
|
continue;
|
2020-01-07 06:43:09 +01:00
|
|
|
|
2020-04-16 00:05:14 +02:00
|
|
|
rt->gw.in = router[0];
|
2020-01-07 06:43:09 +01:00
|
|
|
|
2020-04-16 00:05:14 +02:00
|
|
|
r = route_configure(rt, link, dhcp4_route_handler);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "Could not set gateway: %m");
|
|
|
|
if (r > 0)
|
|
|
|
link->dhcp4_messages++;
|
|
|
|
}
|
2020-01-07 06:43:09 +01:00
|
|
|
}
|
|
|
|
|
2019-07-16 19:30:56 +02:00
|
|
|
return link_set_dns_routes(link, &address);
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
2019-07-16 19:14:27 +02:00
|
|
|
static int dhcp_remove_routes(Link *link, sd_dhcp_lease *lease, const struct in_addr *address, bool remove_all) {
|
|
|
|
_cleanup_free_ sd_dhcp_route **routes = NULL;
|
2019-05-24 09:47:47 +02:00
|
|
|
uint32_t table;
|
2019-07-16 19:14:27 +02:00
|
|
|
int n, i, r;
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
assert(link);
|
2019-05-24 09:47:47 +02:00
|
|
|
assert(address);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
if (!link->network->dhcp_use_routes)
|
|
|
|
return 0;
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-06-07 08:31:07 +02:00
|
|
|
n = sd_dhcp_lease_get_routes(lease, &routes);
|
|
|
|
if (IN_SET(n, 0, -ENODATA))
|
2019-05-24 09:47:47 +02:00
|
|
|
return 0;
|
2019-06-07 08:31:07 +02:00
|
|
|
else if (n < 0)
|
|
|
|
return log_link_error_errno(link, n, "DHCP error: Failed to get routes: %m");
|
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
table = link_get_dhcp_route_table(link);
|
2019-05-15 07:55:31 +02:00
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
_cleanup_(route_freep) Route *route = NULL;
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
r = route_new(&route);
|
|
|
|
if (r < 0)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
route->family = AF_INET;
|
|
|
|
assert_se(sd_dhcp_route_get_gateway(routes[i], &route->gw.in) >= 0);
|
|
|
|
assert_se(sd_dhcp_route_get_destination(routes[i], &route->dst.in) >= 0);
|
|
|
|
assert_se(sd_dhcp_route_get_destination_prefix_length(routes[i], &route->dst_prefixlen) >= 0);
|
|
|
|
route->priority = link->network->dhcp_route_metric;
|
|
|
|
route->table = table;
|
|
|
|
route->scope = route_scope_from_address(route, address);
|
src/network/networkd-dhcp4.c: set prefsrc for classless or static routes
When a DHCP server provides only a gateway, the networkd-dhcp4 code adds a
default route using that gateway, and sets the just-provided address as
the route's prefsrc; this was added in commit
46b0c76e2c355c0d0cc4792abb98cde07b28bc53
However, if the DHCP server has also provided classless route(s), these
are used instead of a default route using the provided gateway; the
networkd-dhcp4 code sets up the classless routes, but does not use the
just-provided dhcp address as the prefsrc of the route(s). Note that
it also doesn't set the prefsrc for static routes, though it should.
If the interface has only the dhcp-provided address, this is not usually
a problem, but if it has another address (e.g. a static address), then
traffic sent through the dhcp-provided gateway might not use the
dhcp-provided source address. If the gateway router only will route
traffic from the dhcp-provided address, then the dhcp client system's
networking through the router will not work.
Fixes: #12969
2019-07-05 22:42:38 +02:00
|
|
|
if (IN_SET(route->scope, RT_SCOPE_LINK, RT_SCOPE_UNIVERSE))
|
|
|
|
route->prefsrc.in = *address;
|
2019-05-24 09:47:47 +02:00
|
|
|
|
2019-07-16 19:14:27 +02:00
|
|
|
if (!remove_all && set_contains(link->dhcp_routes, route))
|
2019-06-07 08:31:07 +02:00
|
|
|
continue;
|
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
(void) route_remove(route, link, NULL);
|
2019-04-29 07:02:34 +02:00
|
|
|
}
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
return n;
|
|
|
|
}
|
2019-05-15 07:55:31 +02:00
|
|
|
|
2019-07-16 19:14:27 +02:00
|
|
|
static int dhcp_remove_router(Link *link, sd_dhcp_lease *lease, const struct in_addr *address, bool remove_all) {
|
2019-05-24 09:47:47 +02:00
|
|
|
_cleanup_(route_freep) Route *route_gw = NULL, *route = NULL;
|
|
|
|
const struct in_addr *router;
|
|
|
|
uint32_t table;
|
|
|
|
int r;
|
2019-05-15 07:55:31 +02:00
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
assert(link);
|
|
|
|
assert(address);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2020-03-16 10:55:10 +01:00
|
|
|
if (!link->network->dhcp_use_gateway)
|
2019-05-24 09:47:47 +02:00
|
|
|
return 0;
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-06-07 08:31:07 +02:00
|
|
|
r = sd_dhcp_lease_get_router(lease, &router);
|
2019-05-24 09:47:47 +02:00
|
|
|
if (IN_SET(r, 0, -ENODATA)) {
|
|
|
|
log_link_debug(link, "DHCP: No gateway received from DHCP server.");
|
|
|
|
return 0;
|
|
|
|
} else if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP error: could not get gateway: %m");
|
|
|
|
else if (in4_addr_is_null(&router[0])) {
|
|
|
|
log_link_info(link, "DHCP: Received gateway is null, ignoring.");
|
|
|
|
return 0;
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
table = link_get_dhcp_route_table(link);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
r = route_new(&route_gw);
|
|
|
|
if (r < 0)
|
|
|
|
return log_oom();
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
route_gw->family = AF_INET;
|
|
|
|
route_gw->dst.in = router[0];
|
|
|
|
route_gw->dst_prefixlen = 32;
|
|
|
|
route_gw->prefsrc.in = *address;
|
|
|
|
route_gw->scope = RT_SCOPE_LINK;
|
|
|
|
route_gw->protocol = RTPROT_DHCP;
|
|
|
|
route_gw->priority = link->network->dhcp_route_metric;
|
|
|
|
route_gw->table = table;
|
2015-07-10 12:12:27 +02:00
|
|
|
|
2019-07-16 19:14:27 +02:00
|
|
|
if (remove_all || !set_contains(link->dhcp_routes, route_gw))
|
|
|
|
(void) route_remove(route_gw, link, NULL);
|
2019-05-24 09:47:47 +02:00
|
|
|
|
|
|
|
r = route_new(&route);
|
|
|
|
if (r < 0)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
route->family = AF_INET;
|
|
|
|
route->gw.in = router[0];
|
|
|
|
route->prefsrc.in = *address;
|
|
|
|
route->protocol = RTPROT_DHCP;
|
|
|
|
route->priority = link->network->dhcp_route_metric;
|
|
|
|
route->table = table;
|
|
|
|
|
2019-07-16 19:14:27 +02:00
|
|
|
if (remove_all || !set_contains(link->dhcp_routes, route))
|
|
|
|
(void) route_remove(route, link, NULL);
|
2019-05-24 09:47:47 +02:00
|
|
|
|
2020-01-07 06:43:09 +01:00
|
|
|
Route *rt;
|
|
|
|
LIST_FOREACH(routes, rt, link->network->static_routes) {
|
|
|
|
if (!rt->gateway_from_dhcp)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (rt->family != AF_INET)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!remove_all && in4_addr_equal(router, &rt->gw.in))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
(void) route_remove(rt, link, NULL);
|
|
|
|
}
|
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-16 19:30:56 +02:00
|
|
|
static int dhcp_remove_dns_routes(Link *link, sd_dhcp_lease *lease, const struct in_addr *address, bool remove_all) {
|
|
|
|
const struct in_addr *dns;
|
|
|
|
uint32_t table;
|
|
|
|
int i, n, r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
assert(lease);
|
|
|
|
assert(link->network);
|
|
|
|
|
2019-07-16 19:47:20 +02:00
|
|
|
if (!link->network->dhcp_use_dns ||
|
|
|
|
!link->network->dhcp_routes_to_dns)
|
2019-07-16 19:30:56 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
n = sd_dhcp_lease_get_dns(lease, &dns);
|
|
|
|
if (IN_SET(n, 0, -ENODATA))
|
|
|
|
return 0;
|
|
|
|
if (n < 0)
|
|
|
|
return log_link_warning_errno(link, n, "DHCP error: could not get DNS servers: %m");
|
|
|
|
|
|
|
|
table = link_get_dhcp_route_table(link);
|
|
|
|
|
|
|
|
for (i = 0; i < n; i ++) {
|
|
|
|
_cleanup_(route_freep) Route *route = NULL;
|
|
|
|
|
|
|
|
r = route_new(&route);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "Could not allocate route: %m");
|
|
|
|
|
|
|
|
route->family = AF_INET;
|
|
|
|
route->dst.in = dns[i];
|
|
|
|
route->dst_prefixlen = 32;
|
|
|
|
route->prefsrc.in = *address;
|
|
|
|
route->scope = RT_SCOPE_LINK;
|
|
|
|
route->protocol = RTPROT_DHCP;
|
|
|
|
route->priority = link->network->dhcp_route_metric;
|
|
|
|
route->table = table;
|
|
|
|
|
|
|
|
if (!remove_all && set_contains(link->dhcp_routes, route))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
(void) route_remove(route, link, NULL);
|
|
|
|
}
|
|
|
|
|
2019-12-07 16:32:36 +01:00
|
|
|
if (!link_prefixroute(link)) {
|
2019-07-22 04:22:28 +02:00
|
|
|
_cleanup_(route_freep) Route *prefix_route = NULL;
|
|
|
|
|
2019-10-03 15:46:44 +02:00
|
|
|
r = dhcp_prefix_route_from_lease(lease, table, address, &prefix_route);
|
2019-07-22 04:22:28 +02:00
|
|
|
if (r < 0)
|
2019-10-03 15:46:44 +02:00
|
|
|
return log_link_warning_errno(link, r, "Could not delete prefix route: %m");
|
2019-07-22 04:22:28 +02:00
|
|
|
|
|
|
|
if (remove_all || !set_contains(link->dhcp_routes, prefix_route))
|
|
|
|
(void) route_remove(prefix_route, link, NULL);
|
|
|
|
}
|
|
|
|
|
2019-07-16 19:30:56 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-22 04:25:31 +02:00
|
|
|
static int dhcp_remove_address_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
|
|
|
|
/* This is only used when retrying to assign the address received from DHCPv4 server.
|
|
|
|
* See dhcp4_route_handler(). */
|
|
|
|
|
|
|
|
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
r = sd_netlink_message_get_errno(m);
|
|
|
|
if (r < 0)
|
2019-11-30 07:54:07 +01:00
|
|
|
log_link_message_warning_errno(link, m, r, "Failed to remove DHCPv4 address, ignoring");
|
2019-07-22 04:25:31 +02:00
|
|
|
else
|
|
|
|
(void) manager_rtnl_process_address(rtnl, m, link->manager);
|
|
|
|
|
|
|
|
(void) dhcp_lease_renew(link->dhcp_client, link);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dhcp_remove_address(
|
|
|
|
Link *link, sd_dhcp_lease *lease,
|
|
|
|
const struct in_addr *address,
|
|
|
|
link_netlink_message_handler_t callback) {
|
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
_cleanup_(address_freep) Address *a = NULL;
|
|
|
|
struct in_addr netmask;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
assert(address);
|
|
|
|
|
|
|
|
if (in4_addr_is_null(address))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
r = address_new(&a);
|
|
|
|
if (r < 0)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
a->family = AF_INET;
|
|
|
|
a->in_addr.in = *address;
|
|
|
|
|
2019-06-07 08:31:07 +02:00
|
|
|
if (sd_dhcp_lease_get_netmask(lease, &netmask) >= 0)
|
2019-05-24 09:47:47 +02:00
|
|
|
a->prefixlen = in4_addr_netmask_to_prefixlen(&netmask);
|
|
|
|
|
2019-07-22 04:25:31 +02:00
|
|
|
(void) address_remove(a, link, callback);
|
2019-05-24 09:47:47 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dhcp_reset_mtu(Link *link) {
|
|
|
|
uint16_t mtu;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
|
|
|
|
if (!link->network->dhcp_use_mtu)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (link->original_mtu == mtu)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
r = link_set_mtu(link, link->original_mtu);
|
|
|
|
if (r < 0) {
|
|
|
|
log_link_error_errno(link, r, "DHCP error: could not reset MTU: %m");
|
|
|
|
link_enter_failed(link);
|
|
|
|
return r;
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
2019-05-24 09:47:47 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dhcp_reset_hostname(Link *link) {
|
|
|
|
const char *hostname;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
|
|
|
|
if (!link->network->dhcp_use_hostname)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
hostname = link->network->dhcp_hostname;
|
|
|
|
if (!hostname)
|
|
|
|
(void) sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
|
|
|
|
|
|
|
|
if (!hostname)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* If a hostname was set due to the lease, then unset it now. */
|
|
|
|
r = manager_set_hostname(link->manager, NULL);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP error: Failed to reset transient hostname: %m");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dhcp_lease_lost(Link *link) {
|
|
|
|
struct in_addr address = {};
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
assert(link->dhcp_lease);
|
|
|
|
|
2019-08-31 20:49:17 +02:00
|
|
|
log_link_info(link, "DHCP lease lost");
|
2019-05-24 09:47:47 +02:00
|
|
|
|
|
|
|
link->dhcp4_configured = false;
|
|
|
|
|
|
|
|
(void) sd_dhcp_lease_get_address(link->dhcp_lease, &address);
|
2019-07-16 19:14:27 +02:00
|
|
|
(void) dhcp_remove_routes(link, link->dhcp_lease, &address, true);
|
|
|
|
(void) dhcp_remove_router(link, link->dhcp_lease, &address, true);
|
2019-07-16 19:30:56 +02:00
|
|
|
(void) dhcp_remove_dns_routes(link, link->dhcp_lease, &address, true);
|
2019-07-22 04:25:31 +02:00
|
|
|
(void) dhcp_remove_address(link, link->dhcp_lease, &address, NULL);
|
2019-05-24 09:47:47 +02:00
|
|
|
(void) dhcp_reset_mtu(link);
|
|
|
|
(void) dhcp_reset_hostname(link);
|
|
|
|
|
2014-08-08 12:12:17 +02:00
|
|
|
link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
|
2015-11-18 14:21:06 +01:00
|
|
|
link_dirty(link);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-12-20 14:13:18 +01:00
|
|
|
static void dhcp_address_on_acd(sd_ipv4acd *acd, int event, void *userdata) {
|
|
|
|
_cleanup_free_ char *pretty = NULL;
|
|
|
|
union in_addr_union address = {};
|
|
|
|
Link *link;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(acd);
|
|
|
|
assert(userdata);
|
|
|
|
|
|
|
|
link = userdata;
|
|
|
|
|
|
|
|
switch (event) {
|
|
|
|
case SD_IPV4ACD_EVENT_STOP:
|
|
|
|
log_link_debug(link, "Stopping ACD client for DHCP4...");
|
|
|
|
return;
|
|
|
|
|
|
|
|
case SD_IPV4ACD_EVENT_BIND:
|
|
|
|
if (DEBUG_LOGGING) {
|
|
|
|
(void) sd_dhcp_lease_get_address(link->dhcp_lease, &address.in);
|
|
|
|
(void) in_addr_to_string(AF_INET, &address, &pretty);
|
|
|
|
log_link_debug(link, "Successfully claimed DHCP4 address %s", strna(pretty));
|
|
|
|
}
|
2019-12-20 16:19:25 +01:00
|
|
|
dhcp4_check_ready(link);
|
2019-12-20 14:13:18 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SD_IPV4ACD_EVENT_CONFLICT:
|
|
|
|
(void) sd_dhcp_lease_get_address(link->dhcp_lease, &address.in);
|
|
|
|
(void) in_addr_to_string(AF_INET, &address, &pretty);
|
|
|
|
log_link_warning(link, "DAD conflict. Dropping DHCP4 address %s", strna(pretty));
|
|
|
|
|
|
|
|
(void) sd_dhcp_client_send_decline(link->dhcp_client);
|
|
|
|
|
|
|
|
if (link->dhcp_lease) {
|
|
|
|
r = dhcp_lease_lost(link);
|
|
|
|
if (r < 0)
|
|
|
|
link_enter_failed(link);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
assert_not_reached("Invalid IPv4ACD event.");
|
|
|
|
}
|
|
|
|
|
|
|
|
sd_ipv4acd_stop(acd);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int configure_dhcpv4_duplicate_address_detection(Link *link) {
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
|
|
|
|
r = sd_ipv4acd_new(&link->network->dhcp_acd);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = sd_ipv4acd_attach_event(link->network->dhcp_acd, NULL, 0);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = sd_ipv4acd_set_ifindex(link->network->dhcp_acd, link->ifindex);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = sd_ipv4acd_set_mac(link->network->dhcp_acd, &link->mac);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-11-28 21:06:52 +01:00
|
|
|
static int dhcp4_address_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
|
2014-08-08 12:12:17 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
|
2019-06-07 08:04:11 +02:00
|
|
|
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
|
|
|
return 1;
|
|
|
|
|
2015-06-12 16:31:33 +02:00
|
|
|
r = sd_netlink_message_get_errno(m);
|
2014-08-08 12:12:17 +02:00
|
|
|
if (r < 0 && r != -EEXIST) {
|
2019-11-30 07:54:07 +01:00
|
|
|
log_link_message_warning_errno(link, m, r, "Could not set DHCPv4 address");
|
2014-08-08 12:12:17 +02:00
|
|
|
link_enter_failed(link);
|
2019-06-07 08:04:11 +02:00
|
|
|
return 1;
|
2019-07-14 17:35:49 +02:00
|
|
|
} else if (r >= 0)
|
|
|
|
(void) manager_rtnl_process_address(rtnl, m, link->manager);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-06-07 07:18:55 +02:00
|
|
|
r = link_set_dhcp_routes(link);
|
|
|
|
if (r < 0) {
|
|
|
|
link_enter_failed(link);
|
|
|
|
return 1;
|
|
|
|
}
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-04-29 07:02:34 +02:00
|
|
|
/* Add back static routes since kernel removes while DHCPv4 address is removed from when lease expires */
|
2019-07-14 17:35:49 +02:00
|
|
|
r = link_request_set_routes(link);
|
|
|
|
if (r < 0) {
|
|
|
|
link_enter_failed(link);
|
|
|
|
return 1;
|
|
|
|
}
|
2019-04-29 07:02:34 +02:00
|
|
|
|
2019-12-20 14:13:18 +01:00
|
|
|
if (link->network->dhcp_send_decline) {
|
|
|
|
union in_addr_union addr;
|
|
|
|
|
|
|
|
(void) sd_dhcp_lease_get_address(link->dhcp_lease, &addr.in);
|
|
|
|
|
|
|
|
r = sd_ipv4acd_set_address(link->network->dhcp_acd, &addr.in);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = sd_ipv4acd_set_callback(link->network->dhcp_acd, dhcp_address_on_acd, link);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (DEBUG_LOGGING) {
|
|
|
|
_cleanup_free_ char *pretty = NULL;
|
|
|
|
|
|
|
|
(void) in_addr_to_string(AF_INET, &addr, &pretty);
|
2020-01-07 04:53:19 +01:00
|
|
|
log_link_debug(link, "Starting IPv4ACD client. Probing DHCPv4 address %s", strna(pretty));
|
2019-12-20 14:13:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
r = sd_ipv4acd_start(link->network->dhcp_acd, true);
|
|
|
|
if (r < 0)
|
|
|
|
log_link_warning_errno(link, r, "Failed to start IPv4ACD client, ignoring: %m");
|
2019-12-20 16:19:25 +01:00
|
|
|
} else
|
|
|
|
dhcp4_check_ready(link);
|
2019-12-20 14:13:18 +01:00
|
|
|
|
2014-08-08 12:12:17 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dhcp4_update_address(Link *link,
|
|
|
|
struct in_addr *address,
|
|
|
|
struct in_addr *netmask,
|
|
|
|
uint32_t lifetime) {
|
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;
|
2014-08-08 12:12:17 +02:00
|
|
|
unsigned prefixlen;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(address);
|
|
|
|
assert(netmask);
|
|
|
|
assert(lifetime);
|
|
|
|
|
2017-09-01 14:40:02 +02:00
|
|
|
prefixlen = in4_addr_netmask_to_prefixlen(netmask);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2015-09-21 15:53:40 +02:00
|
|
|
r = address_new(&addr);
|
2014-08-08 12:12:17 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
addr->family = AF_INET;
|
|
|
|
addr->in_addr.in.s_addr = address->s_addr;
|
|
|
|
addr->cinfo.ifa_prefered = lifetime;
|
|
|
|
addr->cinfo.ifa_valid = lifetime;
|
|
|
|
addr->prefixlen = prefixlen;
|
|
|
|
addr->broadcast.s_addr = address->s_addr | ~netmask->s_addr;
|
2019-12-07 16:32:36 +01:00
|
|
|
addr->prefix_route = link_prefixroute(link);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2015-10-01 17:31:14 +02:00
|
|
|
/* allow reusing an existing address and simply update its lifetime
|
|
|
|
* in case it already exists */
|
2016-05-15 16:22:40 +02:00
|
|
|
r = address_configure(addr, link, dhcp4_address_handler, true);
|
2014-08-08 12:12:17 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
|
|
|
|
sd_dhcp_lease *lease;
|
|
|
|
struct in_addr address;
|
|
|
|
struct in_addr netmask;
|
|
|
|
uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
assert(client);
|
|
|
|
assert(link->network);
|
|
|
|
|
|
|
|
r = sd_dhcp_client_get_lease(client, &lease);
|
2015-08-27 13:04:33 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_link_warning_errno(link, r, "DHCP error: no lease: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
sd_dhcp_lease_unref(link->dhcp_lease);
|
|
|
|
link->dhcp4_configured = false;
|
2015-08-26 12:30:56 +02:00
|
|
|
link->dhcp_lease = sd_dhcp_lease_ref(lease);
|
2015-11-18 14:21:06 +01:00
|
|
|
link_dirty(link);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
r = sd_dhcp_lease_get_address(lease, &address);
|
2015-08-27 13:04:33 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_link_warning_errno(link, r, "DHCP error: no address: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
r = sd_dhcp_lease_get_netmask(lease, &netmask);
|
2015-08-27 13:04:33 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_link_warning_errno(link, r, "DHCP error: no netmask: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-06-03 05:31:13 +02:00
|
|
|
if (!FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
|
2015-08-27 13:04:33 +02:00
|
|
|
r = sd_dhcp_lease_get_lifetime(link->dhcp_lease, &lifetime);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_warning_errno(link, r, "DHCP error: no lifetime: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
r = dhcp4_update_address(link, &address, &netmask, lifetime);
|
2019-06-07 07:28:09 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_link_warning_errno(link, r, "Could not update IP address: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
|
2018-12-14 11:10:57 +01:00
|
|
|
const struct in_addr *router;
|
2014-08-08 12:12:17 +02:00
|
|
|
sd_dhcp_lease *lease;
|
|
|
|
struct in_addr address;
|
|
|
|
struct in_addr netmask;
|
|
|
|
unsigned prefixlen;
|
|
|
|
uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(client);
|
|
|
|
assert(link);
|
|
|
|
|
2019-05-28 15:14:13 +02:00
|
|
|
link->dhcp4_configured = false;
|
|
|
|
|
2014-08-08 12:12:17 +02:00
|
|
|
r = sd_dhcp_client_get_lease(client, &lease);
|
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
|
|
|
if (r < 0)
|
2015-08-27 13:04:33 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP error: No lease: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
r = sd_dhcp_lease_get_address(lease, &address);
|
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
|
|
|
if (r < 0)
|
2015-08-27 13:04:33 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP error: No address: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
r = sd_dhcp_lease_get_netmask(lease, &netmask);
|
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
|
|
|
if (r < 0)
|
2015-08-27 13:04:33 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP error: No netmask: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2017-09-01 14:40:02 +02:00
|
|
|
prefixlen = in4_addr_netmask_to_prefixlen(&netmask);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2019-06-07 07:22:13 +02:00
|
|
|
if (!FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
|
|
|
|
r = sd_dhcp_lease_get_lifetime(lease, &lifetime);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_warning_errno(link, r, "DHCP error: no lifetime: %m");
|
|
|
|
}
|
|
|
|
|
2018-12-14 11:10:57 +01:00
|
|
|
r = sd_dhcp_lease_get_router(lease, &router);
|
2015-09-04 21:16:35 +02:00
|
|
|
if (r < 0 && r != -ENODATA)
|
2015-08-27 13:04:33 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP error: Could not get gateway: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2018-12-14 11:10:57 +01:00
|
|
|
if (r > 0 && !in4_addr_is_null(&router[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_struct(LOG_INFO,
|
|
|
|
LOG_LINK_INTERFACE(link),
|
|
|
|
LOG_LINK_MESSAGE(link, "DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
|
|
|
|
ADDRESS_FMT_VAL(address),
|
|
|
|
prefixlen,
|
2018-12-14 11:10:57 +01:00
|
|
|
ADDRESS_FMT_VAL(router[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
|
|
|
"ADDRESS=%u.%u.%u.%u", ADDRESS_FMT_VAL(address),
|
|
|
|
"PREFIXLEN=%u", prefixlen,
|
2018-12-14 11:10:57 +01:00
|
|
|
"GATEWAY=%u.%u.%u.%u", ADDRESS_FMT_VAL(router[0]));
|
2014-08-08 12:12:17 +02:00
|
|
|
else
|
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_struct(LOG_INFO,
|
|
|
|
LOG_LINK_INTERFACE(link),
|
|
|
|
LOG_LINK_MESSAGE(link, "DHCPv4 address %u.%u.%u.%u/%u",
|
|
|
|
ADDRESS_FMT_VAL(address),
|
|
|
|
prefixlen),
|
|
|
|
"ADDRESS=%u.%u.%u.%u", ADDRESS_FMT_VAL(address),
|
2018-06-04 12:59:22 +02:00
|
|
|
"PREFIXLEN=%u", prefixlen);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2015-08-26 12:30:56 +02:00
|
|
|
link->dhcp_lease = sd_dhcp_lease_ref(lease);
|
2015-11-18 14:21:06 +01:00
|
|
|
link_dirty(link);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2016-01-25 21:47:02 +01:00
|
|
|
if (link->network->dhcp_use_mtu) {
|
2014-08-08 12:12:17 +02:00
|
|
|
uint16_t mtu;
|
|
|
|
|
|
|
|
r = sd_dhcp_lease_get_mtu(lease, &mtu);
|
|
|
|
if (r >= 0) {
|
2019-05-15 09:02:06 +02:00
|
|
|
r = link_set_mtu(link, mtu);
|
2014-08-08 12:12:17 +02: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_error_errno(link, r, "Failed to set MTU to %" PRIu16 ": %m", mtu);
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-25 21:47:02 +01:00
|
|
|
if (link->network->dhcp_use_hostname) {
|
2017-12-13 18:00:46 +01:00
|
|
|
const char *dhcpname = NULL;
|
|
|
|
_cleanup_free_ char *hostname = NULL;
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2016-01-25 21:47:02 +01:00
|
|
|
if (link->network->dhcp_hostname)
|
2017-12-13 18:00:46 +01:00
|
|
|
dhcpname = link->network->dhcp_hostname;
|
2015-08-27 12:53:43 +02:00
|
|
|
else
|
2017-12-13 18:00:46 +01:00
|
|
|
(void) sd_dhcp_lease_get_hostname(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)
|
2019-04-27 02:22:40 +02:00
|
|
|
log_link_notice(link, "Overlong DHCP hostname received, shortened from '%s' to '%s'", dhcpname, hostname);
|
2017-12-13 18:00:46 +01:00
|
|
|
}
|
2015-07-10 12:12:27 +02:00
|
|
|
|
2015-08-27 12:53:43 +02:00
|
|
|
if (hostname) {
|
2016-11-21 23:15:41 +01:00
|
|
|
r = manager_set_hostname(link->manager, hostname);
|
2014-08-08 12:12:17 +02: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_error_errno(link, r, "Failed to set transient hostname to '%s': %m", hostname);
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-25 21:47:02 +01:00
|
|
|
if (link->network->dhcp_use_timezone) {
|
2015-08-27 02:12:27 +02:00
|
|
|
const char *tz = NULL;
|
|
|
|
|
|
|
|
(void) sd_dhcp_lease_get_timezone(link->dhcp_lease, &tz);
|
|
|
|
|
|
|
|
if (tz) {
|
2016-11-21 23:15:41 +01:00
|
|
|
r = manager_set_timezone(link->manager, tz);
|
2015-08-27 02:12:27 +02:00
|
|
|
if (r < 0)
|
|
|
|
log_link_error_errno(link, r, "Failed to set timezone to '%s': %m", tz);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-08 12:12:17 +02:00
|
|
|
r = dhcp4_update_address(link, &address, &netmask, lifetime);
|
2019-06-07 07:28:09 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_link_warning_errno(link, r, "Could not update IP address: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2019-05-01 08:43:23 +02:00
|
|
|
|
2019-06-07 08:31:07 +02:00
|
|
|
static int dhcp_lease_ip_change(sd_dhcp_client *client, Link *link) {
|
|
|
|
int r;
|
|
|
|
|
|
|
|
link->dhcp_lease_old = TAKE_PTR(link->dhcp_lease);
|
|
|
|
|
|
|
|
/* On ip address change, to keep the connectability, we would like to assign new address and
|
|
|
|
* routes, and then release old lease. There are two possible success paths:
|
|
|
|
*
|
|
|
|
* 1. new address and routes are configured.
|
|
|
|
* -> handled by dhcp_release_old_lease() in dhcp4_route_handler().
|
|
|
|
* 2. new address is configured and no route is requested.
|
|
|
|
* -> handled by dhcp_release_old_lease() in dhcp4_address_handler().
|
|
|
|
*
|
|
|
|
* On error in assigning new address and routes, then the link always enters to the failed
|
|
|
|
* state. And link_enter_failed() leads to the DHCP client to be stopped. So,
|
|
|
|
* dhcp_release_old_lease() will be also called by link_stop_clients().
|
|
|
|
*/
|
|
|
|
|
|
|
|
r = dhcp_lease_acquired(client, link);
|
|
|
|
if (r < 0) {
|
|
|
|
/* If it fails, then the new address is not configured yet.
|
|
|
|
* So, let's simply drop the old lease. */
|
|
|
|
sd_dhcp_lease_unref(link->dhcp_lease);
|
|
|
|
link->dhcp_lease = TAKE_PTR(link->dhcp_lease_old);
|
|
|
|
(void) dhcp_lease_lost(link);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-05-01 00:47:41 +02:00
|
|
|
static int dhcp_server_is_black_listed(Link *link, sd_dhcp_client *client) {
|
|
|
|
sd_dhcp_lease *lease;
|
|
|
|
struct in_addr addr;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
assert(link->network);
|
|
|
|
assert(client);
|
|
|
|
|
|
|
|
r = sd_dhcp_client_get_lease(client, &lease);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "Failed to get DHCP lease: %m");
|
|
|
|
|
|
|
|
r = sd_dhcp_lease_get_server_identifier(lease, &addr);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_debug_errno(link, r, "Failed to get DHCP server ip address: %m");
|
|
|
|
|
|
|
|
if (set_contains(link->network->dhcp_black_listed_ip, UINT32_TO_PTR(addr.s_addr))) {
|
|
|
|
log_struct(LOG_DEBUG,
|
|
|
|
LOG_LINK_INTERFACE(link),
|
|
|
|
LOG_LINK_MESSAGE(link, "DHCPv4 ip '%u.%u.%u.%u' found in black listed ip addresses, ignoring offer",
|
|
|
|
ADDRESS_FMT_VAL(addr)));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dhcp4_handler(sd_dhcp_client *client, int event, void *userdata) {
|
2014-08-08 12:12:17 +02:00
|
|
|
Link *link = userdata;
|
2019-05-10 16:31:20 +02:00
|
|
|
int r;
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
assert(link);
|
|
|
|
assert(link->network);
|
|
|
|
assert(link->manager);
|
|
|
|
|
|
|
|
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
2019-05-01 00:47:41 +02:00
|
|
|
return 0;
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
switch (event) {
|
2015-09-22 14:46:21 +02:00
|
|
|
case SD_DHCP_CLIENT_EVENT_STOP:
|
2019-05-01 08:43:23 +02:00
|
|
|
|
2019-05-22 07:49:46 +02:00
|
|
|
if (link_ipv4ll_enabled(link, ADDRESS_FAMILY_FALLBACK_IPV4)) {
|
2019-05-01 08:43:23 +02:00
|
|
|
assert(link->ipv4ll);
|
|
|
|
|
|
|
|
log_link_debug(link, "DHCP client is stopped. Acquiring IPv4 link-local address");
|
|
|
|
|
|
|
|
r = sd_ipv4ll_start(link->ipv4ll);
|
2019-05-01 00:47:41 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
|
2019-05-01 08:43:23 +02:00
|
|
|
}
|
|
|
|
|
2019-06-03 05:31:13 +02:00
|
|
|
if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
|
2019-05-27 22:45:10 +02:00
|
|
|
log_link_notice(link, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (link->dhcp_lease) {
|
2019-10-02 10:29:41 +02:00
|
|
|
if (link->network->dhcp_send_release)
|
|
|
|
(void) sd_dhcp_client_send_release(client);
|
|
|
|
|
2019-05-27 22:45:10 +02:00
|
|
|
r = dhcp_lease_lost(link);
|
|
|
|
if (r < 0) {
|
|
|
|
link_enter_failed(link);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
2019-05-01 08:43:23 +02:00
|
|
|
case SD_DHCP_CLIENT_EVENT_EXPIRED:
|
2019-06-03 05:31:13 +02:00
|
|
|
if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
|
2019-05-27 22:45:10 +02:00
|
|
|
log_link_notice(link, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
|
2019-05-01 00:47:41 +02:00
|
|
|
return 0;
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (link->dhcp_lease) {
|
|
|
|
r = dhcp_lease_lost(link);
|
|
|
|
if (r < 0) {
|
|
|
|
link_enter_failed(link);
|
2019-05-01 00:47:41 +02:00
|
|
|
return r;
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-07 08:31:07 +02:00
|
|
|
break;
|
|
|
|
case SD_DHCP_CLIENT_EVENT_IP_CHANGE:
|
|
|
|
if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
|
|
|
|
log_link_notice(link, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = dhcp_lease_ip_change(client, link);
|
|
|
|
if (r < 0) {
|
|
|
|
link_enter_failed(link);
|
|
|
|
return r;
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
2015-09-22 14:46:21 +02:00
|
|
|
case SD_DHCP_CLIENT_EVENT_RENEW:
|
2014-08-08 12:12:17 +02:00
|
|
|
r = dhcp_lease_renew(client, link);
|
|
|
|
if (r < 0) {
|
|
|
|
link_enter_failed(link);
|
2019-05-01 00:47:41 +02:00
|
|
|
return r;
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
break;
|
2015-09-22 14:46:21 +02:00
|
|
|
case SD_DHCP_CLIENT_EVENT_IP_ACQUIRE:
|
2014-08-08 12:12:17 +02:00
|
|
|
r = dhcp_lease_acquired(client, link);
|
|
|
|
if (r < 0) {
|
|
|
|
link_enter_failed(link);
|
2019-05-01 00:47:41 +02:00
|
|
|
return r;
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
break;
|
2019-05-01 00:47:41 +02:00
|
|
|
case SD_DHCP_CLIENT_EVENT_SELECTING:
|
|
|
|
r = dhcp_server_is_black_listed(link, client);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
if (r != 0)
|
|
|
|
return -ENOMSG;
|
2019-12-20 14:13:18 +01:00
|
|
|
|
2019-05-01 00:47:41 +02:00
|
|
|
break;
|
2014-08-08 12:12:17 +02:00
|
|
|
default:
|
|
|
|
if (event < 0)
|
2015-08-27 13:04:33 +02:00
|
|
|
log_link_warning_errno(link, event, "DHCP error: Client failed: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
else
|
2015-08-27 13:04:33 +02:00
|
|
|
log_link_warning(link, "DHCP unknown event: %i", event);
|
2014-08-08 12:12:17 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2019-05-01 00:47:41 +02:00
|
|
|
return 0;
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
2016-11-18 13:02:57 +01:00
|
|
|
static int dhcp4_set_hostname(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_dhcp_client_set_hostname(link->dhcp_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, "DHCP4 CLIENT: Failed to set hostname from kernel hostname, ignoring: %m");
|
|
|
|
else if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set hostname: %m");
|
|
|
|
|
|
|
|
return 0;
|
2016-11-18 13:02:57 +01:00
|
|
|
}
|
|
|
|
|
2017-11-24 21:03:05 +01:00
|
|
|
static bool promote_secondaries_enabled(const char *ifname) {
|
2017-12-05 15:51:23 +01:00
|
|
|
_cleanup_free_ char *promote_secondaries_sysctl = NULL;
|
|
|
|
char *promote_secondaries_path;
|
2017-11-24 21:03:05 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
promote_secondaries_path = strjoina("net/ipv4/conf/", ifname, "/promote_secondaries");
|
|
|
|
r = sysctl_read(promote_secondaries_path, &promote_secondaries_sysctl);
|
|
|
|
if (r < 0) {
|
|
|
|
log_debug_errno(r, "Cannot read sysctl %s", promote_secondaries_path);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
truncate_nl(promote_secondaries_sysctl);
|
|
|
|
r = parse_boolean(promote_secondaries_sysctl);
|
|
|
|
if (r < 0)
|
|
|
|
log_warning_errno(r, "Cannot parse sysctl %s with content %s as boolean", promote_secondaries_path, promote_secondaries_sysctl);
|
|
|
|
return r > 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* dhcp4_set_promote_secondaries will ensure this interface has
|
|
|
|
* the "promote_secondaries" option in the kernel set. If this sysctl
|
|
|
|
* is not set DHCP will work only as long as the IP address does not
|
|
|
|
* changes between leases. The kernel will remove all secondary IP
|
|
|
|
* addresses of an interface otherwise. The way systemd-network works
|
|
|
|
* is that the new IP of a lease is added as a secondary IP and when
|
|
|
|
* the primary one expires it relies on the kernel to promote the
|
|
|
|
* secondary IP. See also https://github.com/systemd/systemd/issues/7163
|
|
|
|
*/
|
|
|
|
int dhcp4_set_promote_secondaries(Link *link) {
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
assert(link->network);
|
|
|
|
assert(link->network->dhcp & ADDRESS_FAMILY_IPV4);
|
|
|
|
|
|
|
|
/* check if the kernel has promote_secondaries enabled for our
|
|
|
|
* interface. If it is not globally enabled or enabled for the
|
|
|
|
* specific interface we must either enable it.
|
|
|
|
*/
|
2017-12-05 15:49:00 +01:00
|
|
|
if (!(promote_secondaries_enabled("all") || promote_secondaries_enabled(link->ifname))) {
|
2017-11-24 21:03:05 +01:00
|
|
|
char *promote_secondaries_path = NULL;
|
|
|
|
|
|
|
|
log_link_debug(link, "promote_secondaries is unset, setting it");
|
|
|
|
promote_secondaries_path = strjoina("net/ipv4/conf/", link->ifname, "/promote_secondaries");
|
|
|
|
r = sysctl_write(promote_secondaries_path, "1");
|
|
|
|
if (r < 0)
|
|
|
|
log_link_warning_errno(link, r, "cannot set sysctl %s to 1", promote_secondaries_path);
|
|
|
|
return r > 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-08-06 10:33:12 +02:00
|
|
|
int dhcp4_set_client_identifier(Link *link) {
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
assert(link->network);
|
|
|
|
assert(link->dhcp_client);
|
|
|
|
|
|
|
|
switch (link->network->dhcp_client_identifier) {
|
|
|
|
case DHCP_CLIENT_ID_DUID: {
|
2018-08-07 06:57:48 +02:00
|
|
|
/* If configured, apply user specified DUID and IAID */
|
2018-08-06 10:33:12 +02:00
|
|
|
const DUID *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_dhcp_client_set_iaid_duid_llt(link->dhcp_client,
|
2018-11-23 22:19:26 +01:00
|
|
|
link->network->iaid_set,
|
2018-08-07 06:57:48 +02:00
|
|
|
link->network->iaid,
|
|
|
|
duid->llt_time);
|
|
|
|
else
|
|
|
|
r = sd_dhcp_client_set_iaid_duid(link->dhcp_client,
|
2018-11-23 22:19:26 +01:00
|
|
|
link->network->iaid_set,
|
2018-08-07 06:57:48 +02:00
|
|
|
link->network->iaid,
|
|
|
|
duid->type,
|
|
|
|
duid->raw_data_len > 0 ? duid->raw_data : NULL,
|
|
|
|
duid->raw_data_len);
|
2018-08-06 10:33:12 +02:00
|
|
|
if (r < 0)
|
2018-08-07 06:57:48 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set IAID+DUID: %m");
|
2018-08-06 10:33:12 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case DHCP_CLIENT_ID_DUID_ONLY: {
|
|
|
|
/* If configured, apply user specified DUID */
|
|
|
|
const DUID *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_dhcp_client_set_duid_llt(link->dhcp_client,
|
2018-12-22 23:59:54 +01:00
|
|
|
duid->llt_time);
|
2018-08-07 06:57:48 +02:00
|
|
|
else
|
|
|
|
r = sd_dhcp_client_set_duid(link->dhcp_client,
|
|
|
|
duid->type,
|
|
|
|
duid->raw_data_len > 0 ? duid->raw_data : NULL,
|
|
|
|
duid->raw_data_len);
|
2018-08-06 10:33:12 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set DUID: %m");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case DHCP_CLIENT_ID_MAC:
|
|
|
|
r = sd_dhcp_client_set_client_id(link->dhcp_client,
|
|
|
|
ARPHRD_ETHER,
|
|
|
|
(const uint8_t *) &link->mac,
|
|
|
|
sizeof(link->mac));
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set client ID: %m");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert_not_reached("Unknown client identifier type.");
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-08 12:12:17 +02:00
|
|
|
int dhcp4_configure(Link *link) {
|
2019-09-26 20:06:02 +02:00
|
|
|
sd_dhcp_option *send_option;
|
2019-09-17 14:49:22 +02:00
|
|
|
void *request_options;
|
|
|
|
Iterator i;
|
2014-08-08 12:12:17 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(link);
|
|
|
|
assert(link->network);
|
2015-06-09 01:05:34 +02:00
|
|
|
assert(link->network->dhcp & ADDRESS_FAMILY_IPV4);
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2015-10-01 22:29:50 +02:00
|
|
|
if (!link->dhcp_client) {
|
2017-08-03 03:32:46 +02:00
|
|
|
r = sd_dhcp_client_new(&link->dhcp_client, link->network->dhcp_anonymize);
|
2018-08-01 03:35:17 +02:00
|
|
|
if (r == -ENOMEM)
|
|
|
|
return log_oom();
|
2015-10-01 22:29:50 +02:00
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to create DHCP4 client: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2020-03-16 08:17:04 +01:00
|
|
|
r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to attach event: %m");
|
|
|
|
}
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2014-10-08 21:15:45 +02:00
|
|
|
r = sd_dhcp_client_set_mac(link->dhcp_client,
|
|
|
|
(const uint8_t *) &link->mac,
|
|
|
|
sizeof (link->mac), ARPHRD_ETHER);
|
2014-08-08 12:12:17 +02:00
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set MAC address: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
2016-05-23 16:13:18 +02:00
|
|
|
r = sd_dhcp_client_set_ifindex(link->dhcp_client, link->ifindex);
|
2014-08-08 12:12:17 +02:00
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set ifindex: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp4_handler, link);
|
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set callback: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
r = sd_dhcp_client_set_request_broadcast(link->dhcp_client,
|
|
|
|
link->network->dhcp_broadcast);
|
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for broadcast: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
if (link->mtu) {
|
|
|
|
r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
|
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set MTU: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
2016-01-25 21:47:02 +01:00
|
|
|
if (link->network->dhcp_use_mtu) {
|
2015-08-27 01:18:10 +02:00
|
|
|
r = sd_dhcp_client_set_request_option(link->dhcp_client,
|
2016-01-20 14:44:24 +01:00
|
|
|
SD_DHCP_OPTION_INTERFACE_MTU);
|
2015-08-27 01:18:10 +02:00
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for MTU: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
2017-08-03 19:19:51 +02:00
|
|
|
/* NOTE: even if this variable is called "use", it also "sends" PRL
|
|
|
|
* options, maybe there should be a different configuration variable
|
|
|
|
* to send or not route options?. */
|
2017-11-10 16:03:43 +01:00
|
|
|
/* NOTE: when using Anonymize=yes, routes PRL options are sent
|
|
|
|
* by default, so they don't need to be added here. */
|
2017-08-03 19:19:51 +02:00
|
|
|
if (link->network->dhcp_use_routes && !link->network->dhcp_anonymize) {
|
2014-08-08 12:12:17 +02:00
|
|
|
r = sd_dhcp_client_set_request_option(link->dhcp_client,
|
2016-01-20 14:44:24 +01:00
|
|
|
SD_DHCP_OPTION_STATIC_ROUTE);
|
2014-08-08 12:12:17 +02:00
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for static route: %m");
|
|
|
|
|
2014-08-08 12:12:17 +02:00
|
|
|
r = sd_dhcp_client_set_request_option(link->dhcp_client,
|
2016-01-20 14:44:24 +01:00
|
|
|
SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
|
2015-08-06 00:31:09 +02:00
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for classless static route: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
2019-07-14 03:29:40 +02:00
|
|
|
if (link->network->dhcp_use_domains != DHCP_USE_DOMAINS_NO && !link->network->dhcp_anonymize) {
|
|
|
|
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_DOMAIN_SEARCH_LIST);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for domain search list: %m");
|
|
|
|
}
|
|
|
|
|
2017-09-05 12:26:32 +02:00
|
|
|
if (link->network->dhcp_use_ntp) {
|
|
|
|
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_NTP_SERVER);
|
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for NTP server: %m");
|
2017-09-05 12:26:32 +02:00
|
|
|
}
|
2015-08-27 01:14:20 +02:00
|
|
|
|
2019-09-18 15:22:47 +02:00
|
|
|
if (link->network->dhcp_use_sip) {
|
|
|
|
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_SIP_SERVER);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for SIP server: %m");
|
|
|
|
}
|
|
|
|
|
2017-09-06 10:10:50 +02:00
|
|
|
if (link->network->dhcp_use_timezone) {
|
|
|
|
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_NEW_TZDB_TIMEZONE);
|
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for timezone: %m");
|
2017-09-06 10:10:50 +02:00
|
|
|
}
|
2015-08-26 19:19:32 +02:00
|
|
|
|
2019-09-17 14:49:22 +02:00
|
|
|
SET_FOREACH(request_options, link->network->dhcp_request_options, i) {
|
|
|
|
uint32_t option = PTR_TO_UINT32(request_options);
|
|
|
|
|
|
|
|
r = sd_dhcp_client_set_request_option(link->dhcp_client, option);
|
|
|
|
if (r == -EEXIST) {
|
|
|
|
log_link_debug(link, "DHCP4 CLIENT: Failed to set request flag for '%u' already exists, ignoring.", option);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for '%u': %m", option);
|
|
|
|
}
|
|
|
|
|
2019-11-18 10:29:29 +01:00
|
|
|
ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp_client_send_options, i) {
|
2020-02-28 19:28:49 +01:00
|
|
|
r = sd_dhcp_client_add_option(link->dhcp_client, send_option);
|
|
|
|
if (r == -EEXIST)
|
|
|
|
continue;
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set send option: %m");
|
|
|
|
}
|
|
|
|
|
|
|
|
ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp_client_send_vendor_options, i) {
|
|
|
|
r = sd_dhcp_client_add_vendor_option(link->dhcp_client, send_option);
|
|
|
|
if (r == -EEXIST)
|
|
|
|
continue;
|
2019-09-26 20:06:02 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set send option: %m");
|
|
|
|
}
|
|
|
|
|
2016-11-18 13:02:57 +01:00
|
|
|
r = dhcp4_set_hostname(link);
|
|
|
|
if (r < 0)
|
2018-08-02 09:31:10 +02:00
|
|
|
return r;
|
2014-08-08 12:12:17 +02:00
|
|
|
|
|
|
|
if (link->network->dhcp_vendor_class_identifier) {
|
|
|
|
r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
|
|
|
|
link->network->dhcp_vendor_class_identifier);
|
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set vendor class identifier: %m");
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
|
|
|
|
2020-03-30 16:43:28 +02:00
|
|
|
if (link->network->dhcp_mudurl) {
|
|
|
|
r = sd_dhcp_client_set_mud_url(link->dhcp_client,
|
|
|
|
link->network->dhcp_mudurl);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set MUD URL: %m");
|
|
|
|
}
|
|
|
|
|
2018-05-07 14:21:02 +02:00
|
|
|
if (link->network->dhcp_user_class) {
|
|
|
|
r = sd_dhcp_client_set_user_class(link->dhcp_client, (const char **) link->network->dhcp_user_class);
|
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set user class: %m");
|
2018-05-07 14:21:02 +02:00
|
|
|
}
|
|
|
|
|
2016-11-11 00:34:19 +01:00
|
|
|
if (link->network->dhcp_client_port) {
|
|
|
|
r = sd_dhcp_client_set_client_port(link->dhcp_client, link->network->dhcp_client_port);
|
|
|
|
if (r < 0)
|
2018-08-01 03:35:17 +02:00
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set listen port: %m");
|
2016-11-11 00:34:19 +01:00
|
|
|
}
|
|
|
|
|
2019-05-04 13:40:54 +02:00
|
|
|
if (link->network->dhcp_max_attempts > 0) {
|
|
|
|
r = sd_dhcp_client_set_max_attempts(link->dhcp_client, link->network->dhcp_max_attempts);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set max attempts: %m");
|
|
|
|
}
|
|
|
|
|
2019-09-23 13:25:21 +02:00
|
|
|
if (link->network->ip_service_type > 0) {
|
|
|
|
r = sd_dhcp_client_set_service_type(link->dhcp_client, link->network->ip_service_type);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set ip service type: %m");
|
|
|
|
}
|
2019-12-20 14:13:18 +01:00
|
|
|
|
2020-05-20 06:23:36 +02:00
|
|
|
if (link->network->dhcp_fallback_lease_lifetime > 0) {
|
|
|
|
r = sd_dhcp_client_set_fallback_lease_lifetime(link->dhcp_client, link->network->dhcp_fallback_lease_lifetime);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed set to lease lifetime: %m");
|
|
|
|
}
|
|
|
|
|
2019-12-20 14:13:18 +01:00
|
|
|
if (link->network->dhcp_send_decline) {
|
|
|
|
r = configure_dhcpv4_duplicate_address_detection(link);
|
|
|
|
if (r < 0)
|
|
|
|
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to configure service type: %m");
|
|
|
|
}
|
|
|
|
|
|
|
|
return dhcp4_set_client_identifier(link);
|
2014-08-08 12:12:17 +02:00
|
|
|
}
|
2019-06-29 20:57:47 +02:00
|
|
|
|
|
|
|
int config_parse_dhcp_max_attempts(
|
|
|
|
const char *unit,
|
|
|
|
const char *filename,
|
|
|
|
unsigned line,
|
|
|
|
const char *section,
|
|
|
|
unsigned section_line,
|
|
|
|
const char *lvalue,
|
|
|
|
int ltype,
|
|
|
|
const char *rvalue,
|
|
|
|
void *data,
|
|
|
|
void *userdata) {
|
|
|
|
|
|
|
|
Network *network = data;
|
|
|
|
uint64_t a;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(network);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
|
|
|
|
if (isempty(rvalue)) {
|
|
|
|
network->dhcp_max_attempts = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (streq(rvalue, "infinity")) {
|
|
|
|
network->dhcp_max_attempts = (uint64_t) -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = safe_atou64(rvalue, &a);
|
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"Failed to parse DHCP maximum attempts, ignoring: %s", rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (a == 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, 0,
|
|
|
|
"%s= must be positive integer or 'infinity', ignoring: %s", lvalue, rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
network->dhcp_max_attempts = a;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int config_parse_dhcp_black_listed_ip_address(
|
|
|
|
const char *unit,
|
|
|
|
const char *filename,
|
|
|
|
unsigned line,
|
|
|
|
const char *section,
|
|
|
|
unsigned section_line,
|
|
|
|
const char *lvalue,
|
|
|
|
int ltype,
|
|
|
|
const char *rvalue,
|
|
|
|
void *data,
|
|
|
|
void *userdata) {
|
|
|
|
|
|
|
|
Network *network = data;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(filename);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
assert(data);
|
|
|
|
|
|
|
|
if (isempty(rvalue)) {
|
|
|
|
network->dhcp_black_listed_ip = set_free(network->dhcp_black_listed_ip);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-05 15:12:29 +02:00
|
|
|
for (const char *p = rvalue;;) {
|
2019-06-29 20:57:47 +02:00
|
|
|
_cleanup_free_ char *n = NULL;
|
|
|
|
union in_addr_union ip;
|
|
|
|
|
|
|
|
r = extract_first_word(&p, &n, NULL, 0);
|
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"Failed to parse DHCP black listed ip address, ignoring assignment: %s",
|
|
|
|
rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (r == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
r = in_addr_from_string(AF_INET, n, &ip);
|
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"DHCP black listed ip address is invalid, ignoring assignment: %s", n);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2020-06-05 15:12:29 +02:00
|
|
|
r = set_ensure_put(&network->dhcp_black_listed_ip, NULL, UINT32_TO_PTR(ip.in.s_addr));
|
2019-06-29 20:57:47 +02:00
|
|
|
if (r < 0)
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"Failed to store DHCP black listed ip address '%s', ignoring assignment: %m", n);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-03-02 21:44:01 +01:00
|
|
|
int config_parse_dhcp_ip_service_type(
|
|
|
|
const char *unit,
|
|
|
|
const char *filename,
|
|
|
|
unsigned line,
|
|
|
|
const char *section,
|
|
|
|
unsigned section_line,
|
|
|
|
const char *lvalue,
|
|
|
|
int ltype,
|
|
|
|
const char *rvalue,
|
|
|
|
void *data,
|
|
|
|
void *userdata) {
|
|
|
|
|
|
|
|
assert(filename);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
|
|
|
|
if (streq(rvalue, "CS4"))
|
|
|
|
*((int *)data) = IPTOS_CLASS_CS4;
|
|
|
|
else if (streq(rvalue, "CS6"))
|
|
|
|
*((int *)data) = IPTOS_CLASS_CS6;
|
|
|
|
else
|
|
|
|
log_syntax(unit, LOG_WARNING, filename, line, 0,
|
|
|
|
"Failed to parse IPServiceType type '%s', ignoring.", rvalue);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-03-30 16:43:28 +02:00
|
|
|
int config_parse_dhcp_mud_url(
|
|
|
|
const char *unit,
|
|
|
|
const char *filename,
|
|
|
|
unsigned line,
|
|
|
|
const char *section,
|
|
|
|
unsigned section_line,
|
|
|
|
const char *lvalue,
|
|
|
|
int ltype,
|
|
|
|
const char *rvalue,
|
|
|
|
void *data,
|
|
|
|
void *userdata) {
|
|
|
|
|
|
|
|
_cleanup_free_ char *unescaped = NULL;
|
|
|
|
Network *network = data;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(filename);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
|
|
|
|
if (isempty(rvalue)) {
|
|
|
|
network->dhcp_mudurl = mfree(network->dhcp_mudurl);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = cunescape(rvalue, 0, &unescaped);
|
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"Failed to Failed to unescape MUD URL, ignoring: %s", rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!http_url_is_valid(unescaped) || strlen(unescaped) > 255) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, 0,
|
|
|
|
"Failed to parse MUD URL '%s', ignoring: %m", rvalue);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return free_and_strdup_warn(&network->dhcp_mudurl, unescaped);
|
|
|
|
}
|
|
|
|
|
2020-05-20 06:23:36 +02:00
|
|
|
int config_parse_dhcp_fallback_lease_lifetime(const char *unit,
|
|
|
|
const char *filename,
|
|
|
|
unsigned line,
|
|
|
|
const char *section,
|
|
|
|
unsigned section_line,
|
|
|
|
const char *lvalue,
|
|
|
|
int ltype,
|
|
|
|
const char *rvalue,
|
|
|
|
void *data,
|
|
|
|
void *userdata) {
|
|
|
|
Network *network = userdata;
|
2020-05-21 08:17:45 +02:00
|
|
|
uint32_t k;
|
2020-05-20 06:23:36 +02:00
|
|
|
|
|
|
|
assert(filename);
|
|
|
|
assert(section);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
assert(data);
|
|
|
|
|
|
|
|
if (isempty(rvalue)) {
|
|
|
|
network->dhcp_fallback_lease_lifetime = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We accept only "forever" or "infinity". */
|
|
|
|
if (STR_IN_SET(rvalue, "forever", "infinity"))
|
|
|
|
k = CACHE_INFO_INFINITY_LIFE_TIME;
|
|
|
|
else {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, 0,
|
|
|
|
"Invalid LeaseLifetime= value, ignoring: %s", rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
network->dhcp_fallback_lease_lifetime = k;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-06-29 20:57:47 +02:00
|
|
|
static const char* const dhcp_client_identifier_table[_DHCP_CLIENT_ID_MAX] = {
|
|
|
|
[DHCP_CLIENT_ID_MAC] = "mac",
|
|
|
|
[DHCP_CLIENT_ID_DUID] = "duid",
|
|
|
|
[DHCP_CLIENT_ID_DUID_ONLY] = "duid-only",
|
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(dhcp_client_identifier, DHCPClientIdentifier);
|
|
|
|
DEFINE_CONFIG_PARSE_ENUM(config_parse_dhcp_client_identifier, dhcp_client_identifier, DHCPClientIdentifier,
|
|
|
|
"Failed to parse client identifier type");
|