HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/network/networkd-dhcp4.c

78,999 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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);