HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/network/networkd-dhcp4.c
Git blob: abf81103405ac09577598bbb04aa7dc856bbe8e1
Lines 1001–2000 of 2,118
return log_link_warning_errno(link, r, "DHCP: failed to get broadcast address: %m");
SET_FLAG(addr->flags, IFA_F_NOPREFIXROUTE, !prefixroute_by_kernel(link));
addr->route_metric = link->network->dhcp_route_metric;
addr->duplicate_address_detection = link->network->dhcp_send_decline ? ADDRESS_FAMILY_IPV4 : ADDRESS_FAMILY_NO;
r = free_and_strdup_warn(&addr->label, link->network->dhcp_label);
if (r < 0)
return r;
r = free_and_strdup_warn(&addr->netlabel, link->network->dhcp_netlabel);
if (r < 0)
return r;
if (address_get(link, addr, &existing) < 0) /* The address is new. */
link->dhcp4_configured = false;
else
address_unmark(existing);
r = link_request_address(link, addr, &link->dhcp4_messages,
dhcp4_address_handler, NULL);
if (r < 0)
return log_link_error_errno(link, r, "Failed to request DHCPv4 address: %m");
return 0;
}
static int dhcp4_request_address_and_routes(Link *link, bool announce) {
int r;
assert(link);
link_mark_addresses(link, NETWORK_CONFIG_SOURCE_DHCP4);
manager_mark_routes(link->manager, link, NETWORK_CONFIG_SOURCE_DHCP4);
r = dhcp4_request_address(link, announce);
if (r < 0)
return r;
r = dhcp4_request_routes(link);
if (r < 0)
return r;
if (!link->dhcp4_configured) {
link_set_state(link, LINK_STATE_CONFIGURING);
link_check_ready(link);
}
return 0;
}
static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
_cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *old_lease = NULL;
sd_dhcp_lease *lease;
int r;
assert(link);
assert(link->network);
assert(client);
r = sd_dhcp_client_get_lease(client, &lease);
if (r < 0)
return log_link_warning_errno(link, r, "DHCP error: no lease: %m");
old_lease = TAKE_PTR(link->dhcp_lease);
link->dhcp_lease = sd_dhcp_lease_ref(lease);
link_dirty(link);
if (link->network->dhcp_use_6rd) {
if (sd_dhcp_lease_has_6rd(link->dhcp_lease)) {
r = dhcp4_pd_prefix_acquired(link);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to process 6rd option: %m");
} else if (sd_dhcp_lease_has_6rd(old_lease))
dhcp4_pd_prefix_lost(link);
}
return dhcp4_request_address_and_routes(link, false);
}
static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
sd_dhcp_lease *lease;
int r;
assert(client);
assert(link);
r = sd_dhcp_client_get_lease(client, &lease);
if (r < 0)
return log_link_error_errno(link, r, "DHCP error: No lease: %m");
sd_dhcp_lease_unref(link->dhcp_lease);
link->dhcp_lease = sd_dhcp_lease_ref(lease);
link_dirty(link);
if (link->network->dhcp_use_mtu) {
uint16_t mtu;
r = sd_dhcp_lease_get_mtu(lease, &mtu);
if (r >= 0) {
r = link_request_to_set_mtu(link, mtu);
if (r < 0)
log_link_error_errno(link, r, "Failed to set MTU to %" PRIu16 ": %m", mtu);
}
}
if (link->network->dhcp_use_hostname) {
const char *dhcpname = NULL;
_cleanup_free_ char *hostname = NULL;
if (link->network->dhcp_hostname)
dhcpname = link->network->dhcp_hostname;
else
(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)
log_link_notice(link, "Overlong DHCP hostname received, shortened from '%s' to '%s'", dhcpname, hostname);
}
if (hostname) {
r = manager_set_hostname(link->manager, hostname);
if (r < 0)
log_link_error_errno(link, r, "Failed to set transient hostname to '%s': %m", hostname);
}
}
if (link->network->dhcp_use_timezone) {
const char *tz = NULL;
(void) sd_dhcp_lease_get_timezone(link->dhcp_lease, &tz);
if (tz) {
r = manager_set_timezone(link->manager, tz);
if (r < 0)
log_link_error_errno(link, r, "Failed to set timezone to '%s': %m", tz);
}
}
if (link->network->dhcp_use_6rd &&
sd_dhcp_lease_has_6rd(link->dhcp_lease)) {
r = dhcp4_pd_prefix_acquired(link);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to process 6rd option: %m");
}
return dhcp4_request_address_and_routes(link, true);
}
static int dhcp_lease_ip_change(sd_dhcp_client *client, Link *link) {
int r;
r = dhcp_lease_acquired(client, link);
if (r < 0)
(void) dhcp4_lease_lost(link);
return r;
}
static int dhcp_server_is_filtered(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 (in4_address_is_filtered(&addr, link->network->dhcp_allow_listed_ip, link->network->dhcp_deny_listed_ip)) {
if (link->network->dhcp_allow_listed_ip)
log_link_debug(link, "DHCPv4 server IP address "IPV4_ADDRESS_FMT_STR" not found in allow-list, ignoring offer.",
IPV4_ADDRESS_FMT_VAL(addr));
else
log_link_debug(link, "DHCPv4 server IP address "IPV4_ADDRESS_FMT_STR" found in deny-list, ignoring offer.",
IPV4_ADDRESS_FMT_VAL(addr));
return true;
}
return false;
}
static int dhcp4_handler(sd_dhcp_client *client, int event, void *userdata) {
Link *link = ASSERT_PTR(userdata);
int r;
assert(link->network);
assert(link->manager);
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
return 0;
switch (event) {
case SD_DHCP_CLIENT_EVENT_STOP:
if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DYNAMIC)) {
log_link_notice(link, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
return 0;
}
r = ipv4ll_start(link);
if (r < 0)
return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
if (r > 0)
log_link_debug(link, "DHCP client is stopped. Acquiring IPv4 link-local address.");
if (link->dhcp_lease) {
r = dhcp4_lease_lost(link);
if (r < 0) {
link_enter_failed(link);
return r;
}
}
break;
case SD_DHCP_CLIENT_EVENT_EXPIRED:
if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DYNAMIC)) {
log_link_notice(link, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
return 0;
}
if (link->dhcp_lease) {
r = dhcp4_lease_lost(link);
if (r < 0) {
link_enter_failed(link);
return r;
}
}
break;
case SD_DHCP_CLIENT_EVENT_IP_CHANGE:
if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DYNAMIC)) {
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;
}
break;
case SD_DHCP_CLIENT_EVENT_RENEW:
r = dhcp_lease_renew(client, link);
if (r < 0) {
link_enter_failed(link);
return r;
}
break;
case SD_DHCP_CLIENT_EVENT_IP_ACQUIRE:
r = dhcp_lease_acquired(client, link);
if (r < 0) {
link_enter_failed(link);
return r;
}
break;
case SD_DHCP_CLIENT_EVENT_SELECTING:
r = dhcp_server_is_filtered(link, client);
if (r < 0) {
link_enter_failed(link);
return r;
}
if (r > 0)
return -ENOMSG;
break;
case SD_DHCP_CLIENT_EVENT_TRANSIENT_FAILURE:
r = ipv4ll_start(link);
if (r < 0)
return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
if (r > 0)
log_link_debug(link, "Problems acquiring DHCP lease, acquiring IPv4 link-local address");
break;
default:
if (event < 0)
log_link_warning_errno(link, event, "DHCP error: Client failed: %m");
else
log_link_warning(link, "DHCP unknown event: %i", event);
}
return 0;
}
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 log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to get hostname: %m");
hn = hostname;
}
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_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set hostname from kernel hostname, ignoring: %m");
else if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set hostname: %m");
return 0;
}
static 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: {
/* If configured, apply user specified DUID and IAID */
const DUID *duid = link_get_dhcp4_duid(link);
if (duid->raw_data_len == 0)
switch (duid->type) {
case DUID_TYPE_LLT:
r = sd_dhcp_client_set_iaid_duid_llt(link->dhcp_client,
link->network->dhcp_iaid_set,
link->network->dhcp_iaid,
duid->llt_time);
break;
case DUID_TYPE_LL:
r = sd_dhcp_client_set_iaid_duid_ll(link->dhcp_client,
link->network->dhcp_iaid_set,
link->network->dhcp_iaid);
break;
case DUID_TYPE_EN:
r = sd_dhcp_client_set_iaid_duid_en(link->dhcp_client,
link->network->dhcp_iaid_set,
link->network->dhcp_iaid);
break;
case DUID_TYPE_UUID:
r = sd_dhcp_client_set_iaid_duid_uuid(link->dhcp_client,
link->network->dhcp_iaid_set,
link->network->dhcp_iaid);
break;
default:
r = sd_dhcp_client_set_iaid_duid_raw(link->dhcp_client,
link->network->dhcp_iaid_set,
link->network->dhcp_iaid,
duid->type, NULL, 0);
}
else
r = sd_dhcp_client_set_iaid_duid_raw(link->dhcp_client,
link->network->dhcp_iaid_set,
link->network->dhcp_iaid,
duid->type, duid->raw_data, duid->raw_data_len);
if (r < 0)
return r;
break;
}
case DHCP_CLIENT_ID_MAC: {
const uint8_t *hw_addr = link->hw_addr.bytes;
size_t hw_addr_len = link->hw_addr.length;
if (link->iftype == ARPHRD_INFINIBAND && hw_addr_len == INFINIBAND_ALEN) {
/* set_client_id expects only last 8 bytes of an IB address */
hw_addr += INFINIBAND_ALEN - 8;
hw_addr_len -= INFINIBAND_ALEN - 8;
}
r = sd_dhcp_client_set_client_id(link->dhcp_client,
link->iftype,
hw_addr,
hw_addr_len);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set client ID: %m");
break;
}
default:
assert_not_reached();
}
return 0;
}
static int dhcp4_set_request_address(Link *link) {
assert(link);
assert(link->network);
assert(link->dhcp_client);
/* 1. Use already assigned address. */
Address *a;
SET_FOREACH(a, link->addresses) {
if (a->source != NETWORK_CONFIG_SOURCE_DHCP4)
continue;
assert(a->family == AF_INET);
log_link_debug(link, "DHCPv4 CLIENT: requesting previously acquired address %s.",
IN4_ADDR_TO_STRING(&a->in_addr.in));
return sd_dhcp_client_set_request_address(link->dhcp_client, &a->in_addr.in);
}
/* 2. If no address is assigned yet, use explicitly configured address. */
if (in4_addr_is_set(&link->network->dhcp_request_address)) {
log_link_debug(link, "DHCPv4 CLIENT: requesting address %s specified by RequestAddress=.",
IN4_ADDR_TO_STRING(&link->network->dhcp_request_address));
return sd_dhcp_client_set_request_address(link->dhcp_client, &link->network->dhcp_request_address);
}
/* 3. If KeepConfiguration=dynamic, use a foreign dynamic address. */
if (!FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DYNAMIC))
return 0;
SET_FOREACH(a, link->addresses) {
if (a->source != NETWORK_CONFIG_SOURCE_FOREIGN)
continue;
if (a->family != AF_INET)
continue;
if (!link_address_is_dynamic(link, a))
continue;
log_link_debug(link, "DHCPv4 CLIENT: requesting foreign dynamic address %s.",
IN4_ADDR_TO_STRING(&a->in_addr.in));
return sd_dhcp_client_set_request_address(link->dhcp_client, &a->in_addr.in);
}
return 0;
}
static bool link_needs_dhcp_broadcast(Link *link) {
int r;
assert(link);
assert(link->network);
/* Return the setting in DHCP[4].RequestBroadcast if specified. Otherwise return the device property
* ID_NET_DHCP_BROADCAST setting, which may be set for interfaces requiring that the DHCPOFFER
* message is being broadcast because they can't handle unicast messages while not fully configured.
* If neither is set or a failure occurs, return false, which is the default for this flag. */
r = link->network->dhcp_broadcast;
if (r >= 0)
return r;
if (!link->dev)
return false;
r = device_get_property_bool(link->dev, "ID_NET_DHCP_BROADCAST");
if (r < 0) {
if (r != -ENOENT)
log_link_warning_errno(link, r, "DHCPv4 CLIENT: Failed to get or parse ID_NET_DHCP_BROADCAST, ignoring: %m");
return false;
}
log_link_debug(link, "DHCPv4 CLIENT: Detected ID_NET_DHCP_BROADCAST='%d'.", r);
return r;
}
static bool link_dhcp4_ipv6_only_mode(Link *link) {
assert(link);
assert(link->network);
/* If it is explicitly specified, then honor the setting. */
if (link->network->dhcp_ipv6_only_mode >= 0)
return link->network->dhcp_ipv6_only_mode;
/* Defaults to false, until we support 464XLAT. See issue #30891. */
return false;
}
static int dhcp4_configure(Link *link) {
void *request_options;
int r;
assert(link);
assert(link->network);
if (link->dhcp_client)
return log_link_debug_errno(link, SYNTHETIC_ERRNO(EBUSY), "DHCPv4 client is already configured.");
r = sd_dhcp_client_new(&link->dhcp_client);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to allocate DHCPv4 client: %m");
r = sd_dhcp_client_set_anonymize(link->dhcp_client, link->network->dhcp_anonymize);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to anonymize requests: %m");
r = sd_dhcp_client_set_bootp(link->dhcp_client, link->network->dhcp_use_bootp);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to %s BOOTP: %m",
enable_disable(link->network->dhcp_use_bootp));
r = sd_dhcp_client_set_send_release(link->dhcp_client, link->network->dhcp_send_release);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to %s sending release message on stop: %m",
enable_disable(link->network->dhcp_send_release));
r = sd_dhcp_client_attach_event(link->dhcp_client, link->manager->event, 0);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to attach event to DHCPv4 client: %m");
r = sd_dhcp_client_attach_device(link->dhcp_client, link->dev);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to attach device: %m");
r = sd_dhcp_client_set_rapid_commit(link->dhcp_client, link->network->dhcp_use_rapid_commit);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set rapid commit: %m");
r = sd_dhcp_client_set_mac(link->dhcp_client,
link->hw_addr.bytes,
link->bcast_addr.length > 0 ? link->bcast_addr.bytes : NULL,
link->hw_addr.length, link->iftype);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set MAC address: %m");
r = sd_dhcp_client_set_ifindex(link->dhcp_client, link->ifindex);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set ifindex: %m");
r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp4_handler, link);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set callback: %m");
r = sd_dhcp_client_set_request_broadcast(link->dhcp_client, link_needs_dhcp_broadcast(link));
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for broadcast: %m");
r = dhcp_client_set_state_callback(link->dhcp_client, dhcp_client_callback_bus, link);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set state change callback: %m");
if (link->mtu > 0) {
r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set MTU: %m");
}
if (!link->network->dhcp_anonymize) {
r = dhcp4_set_request_address(link);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set initial DHCPv4 address: %m");
if (link->network->dhcp_use_mtu) {
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_MTU_INTERFACE);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for MTU: %m");
}
if (link->network->dhcp_use_routes) {
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_STATIC_ROUTE);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for static route: %m");
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for classless static route: %m");
}
if (link_get_use_domains(link, NETWORK_CONFIG_SOURCE_DHCP4) > 0) {
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_DOMAIN_SEARCH);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for domain search list: %m");
}
if (link_get_use_ntp(link, NETWORK_CONFIG_SOURCE_DHCP4)) {
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_NTP_SERVER);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for NTP server: %m");
}
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_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for SIP server: %m");
}
if (link_get_use_dnr(link, NETWORK_CONFIG_SOURCE_DHCP4)) {
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_V4_DNR);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for DNR: %m");
}
if (link->network->dhcp_use_captive_portal) {
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_DHCP_CAPTIVE_PORTAL);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for captive portal: %m");
}
if (link->network->dhcp_use_timezone) {
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_TZDB_TIMEZONE);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for timezone: %m");
}
if (link->network->dhcp_use_6rd) {
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_6RD);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for 6rd: %m");
}
if (link_dhcp4_ipv6_only_mode(link)) {
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_IPV6_ONLY_PREFERRED);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for IPv6-only preferred option: %m");
}
SET_FOREACH(request_options, link->network->dhcp_request_options) {
uint32_t option = PTR_TO_UINT32(request_options);
r = sd_dhcp_client_set_request_option(link->dhcp_client, option);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for '%u': %m", option);
}
r = dhcp_client_set_extra_options(link->dhcp_client, &link->network->dhcp_extra_options);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set extra options: %m");
r = dhcp_client_set_vendor_options(link->dhcp_client, &link->network->dhcp_vendor_options);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set vendor options: %m");
r = dhcp4_set_hostname(link);
if (r < 0)
return r;
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)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set vendor class identifier: %m");
}
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_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set MUD URL: %m");
}
r = dhcp_client_set_user_class(link->dhcp_client, &link->network->dhcp_user_class);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set user class: %m");
}
if (link->network->dhcp_client_port > 0) {
r = sd_dhcp_client_set_client_port(link->dhcp_client, link->network->dhcp_client_port);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set listen port: %m");
}
if (link->network->dhcp_port > 0) {
r = sd_dhcp_client_set_port(link->dhcp_client, link->network->dhcp_port);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set server port: %m");
}
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_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set max attempts: %m");
}
if (link->network->dhcp_ip_service_type >= 0) {
assert(link->network->dhcp_ip_service_type <= UINT8_MAX);
r = sd_dhcp_client_set_ip_service_type(link->dhcp_client, link->network->dhcp_ip_service_type);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set IP service type: %m");
}
if (link->network->dhcp_socket_priority >= 0) {
r = sd_dhcp_client_set_socket_priority(link->dhcp_client, link->network->dhcp_socket_priority);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set socket priority: %m");
}
if (link->network->dhcp_fallback_lease_lifetime_usec > 0) {
r = sd_dhcp_client_set_fallback_lease_lifetime(link->dhcp_client, link->network->dhcp_fallback_lease_lifetime_usec);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set fallback lease lifetime: %m");
}
return dhcp4_set_client_identifier(link);
}
int dhcp4_update_mac(Link *link) {
bool restart;
int r;
assert(link);
if (!link->dhcp_client)
return 0;
restart = sd_dhcp_client_is_running(link->dhcp_client);
r = sd_dhcp_client_stop(link->dhcp_client);
if (r < 0)
return r;
r = sd_dhcp_client_set_mac(link->dhcp_client,
link->hw_addr.bytes,
link->bcast_addr.length > 0 ? link->bcast_addr.bytes : NULL,
link->hw_addr.length, link->iftype);
if (r < 0)
return r;
r = dhcp4_set_client_identifier(link);
if (r < 0)
return r;
if (restart) {
r = dhcp4_start(link);
if (r < 0)
return r;
}
return 0;
}
int dhcp4_update_ipv6_connectivity(Link *link) {
int r;
assert(link);
if (!link->network)
return 0;
if (!link->network->dhcp_ipv6_only_mode)
return 0;
if (!link->dhcp_client)
return 0;
bool have = link_has_ipv6_connectivity(link);
r = sd_dhcp_client_set_ipv6_connectivity(link->dhcp_client, have);
if (r < 0)
return r;
/* If we do not have IPv6 connectivity, and the client has been already stopped or not started yet,
* let's start the client if possible. */
if (!have && !sd_dhcp_client_is_running(link->dhcp_client)) {
r = dhcp4_start_full(link, /* set_ipv6_connectivity= */ false);
if (r < 0)
return r;
}
return 0;
}
int dhcp4_start_full(Link *link, bool set_ipv6_connectivity) {
int r;
assert(link);
assert(link->manager);
assert(link->network);
/* On stopping/restarting networkd, we may drop IPv6 connectivity (which depends on KeepConfiguration=
* setting). Do not (re)start DHCPv4 client in that case. See issue #39299. */
if (link->manager->state != MANAGER_RUNNING)
return 0;
if (!link->dhcp_client)
return 0;
if (link_dhcp_enabled_by_bearer(link, AF_INET) == 0)
return 0;
if (!link_has_carrier(link))
return 0;
if (sd_dhcp_client_is_running(link->dhcp_client) > 0)
return 0;
r = sd_dhcp_client_start(link->dhcp_client);
if (r < 0)
return r;
if (set_ipv6_connectivity) {
r = dhcp4_update_ipv6_connectivity(link);
if (r < 0)
return r;
}
return 1;
}
int dhcp4_renew(Link *link) {
assert(link);
if (!link->dhcp_client)
return 0;
/* The DHCPv4 client may have been stopped by the IPv6 only mode. Let's unconditionally restart the
* client if it is not running. */
if (!sd_dhcp_client_is_running(link->dhcp_client))
return dhcp4_start(link);
/* The client may be waiting for IPv6 connectivity. Let's restart the client in that case. */
if (sd_dhcp_client_is_waiting_for_ipv6_connectivity(link->dhcp_client)) {
sd_dhcp_client_stop(link->dhcp_client);
return dhcp4_start(link);
}
/* Otherwise, send a RENEW command. */
return sd_dhcp_client_send_renew(link->dhcp_client);
}
static int dhcp4_configure_duid(Link *link) {
assert(link);
assert(link->network);
if (link->network->dhcp_client_identifier != DHCP_CLIENT_ID_DUID)
return 1;
return dhcp_configure_duid(link, link_get_dhcp4_duid(link));
}
static int dhcp4_process_request(Request *req, Link *link, void *userdata) {
int r;
assert(link);
if (!link_is_ready_to_configure(link, /* allow_unmanaged= */ false))
return 0;
r = dhcp4_configure_duid(link);
if (r <= 0)
return r;
r = dhcp4_configure(link);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to configure DHCPv4 client: %m");
r = dhcp4_start(link);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to start DHCPv4 client: %m");
log_link_debug(link, "DHCPv4 client is configured%s.",
r > 0 ? ", acquiring DHCPv4 lease" : "");
return 1;
}
int link_request_dhcp4_client(Link *link) {
int r;
assert(link);
if (!link_dhcp4_enabled(link))
return 0;
if (link->dhcp_client)
return 0;
r = link_queue_request(link, REQUEST_TYPE_DHCP4_CLIENT, dhcp4_process_request, NULL);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to request configuring of the DHCPv4 client: %m");
log_link_debug(link, "Requested configuring of the DHCPv4 client.");
return 0;
}
static bool link_should_drop_dhcp4_config(Link *link, Network *network) {
assert(link);
assert(link->network);
if (!link_dhcp4_enabled(link))
/* DHCP client is now disabled. */
return true;
if (link->dhcp_client && link->network->dhcp_use_bootp &&
network && !network->dhcp_use_bootp && network->dhcp_send_release)
/* The client was enabled as a DHCP client and sending release message is requested, and now
* the client is enabled as a BOOTP client. In this case, we need to release the previous
* lease, and hence all DHCPv4 configurations (address, routes, DNS servers, and so on) needs
* to be dropped. */
return true;
return false;
}
int link_drop_dhcp4_config(Link *link, Network *network) {
int ret = 0;
assert(link);
assert(link->network);
if (link->network == network)
return 0; /* .network file is unchanged. It is not necessary to reconfigure the client. */
if (link_should_drop_dhcp4_config(link, network)) {
/* Stop the client if it is running and drop the lease. */
ret = sd_dhcp_client_stop(link->dhcp_client);
/* Also explicitly drop DHCPv4 address and routes. Why? This is for the case when the DHCPv4
* client was enabled on the previous invocation of networkd, but when it is restarted, a new
* .network file may match to the interface, and DHCPv4 client may be disabled. In that case,
* the DHCPv4 client is not running, hence sd_dhcp_client_stop() in the above does nothing. */
RET_GATHER(ret, dhcp4_remove_address_and_routes(link, /* only_marked= */ false));
}
/* Even if the client is currently enabled and also enabled in the new .network file, detailed
* settings for the client may be different. Let's unref() the client. But do not unref() the lease.
* it will be unref()ed later when a new lease is acquired. */
link->dhcp_client = sd_dhcp_client_unref(link->dhcp_client);
return ret;
}
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 = ASSERT_PTR(data);
uint64_t a;
int r;
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
network->dhcp_max_attempts = 0;
return 0;
}
if (streq(rvalue, "infinity")) {
network->dhcp_max_attempts = UINT64_MAX;
return 0;
}
r = safe_atou64(rvalue, &a);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse DHCP maximum attempts, ignoring: %s", rvalue);
return 0;
}
if (a == 0) {
log_syntax(unit, LOG_WARNING, 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_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) {
int *tos = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue))
*tos = -1; /* use sd_dhcp_client's default (currently, CS6). */
else if (streq(rvalue, "none"))
*tos = 0;
else if (streq(rvalue, "CS4"))
*tos = IPTOS_CLASS_CS4;
else if (streq(rvalue, "CS6"))
*tos = IPTOS_CLASS_CS6;
else
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue);