From b750101eb236130cf056c675997decbac904cc49 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 17:35:18 +0200 Subject: Adding upstream version 252.22. Signed-off-by: Daniel Baumann --- src/network/networkd-ipv4acd.c | 327 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 327 insertions(+) create mode 100644 src/network/networkd-ipv4acd.c (limited to 'src/network/networkd-ipv4acd.c') diff --git a/src/network/networkd-ipv4acd.c b/src/network/networkd-ipv4acd.c new file mode 100644 index 0000000..877dee0 --- /dev/null +++ b/src/network/networkd-ipv4acd.c @@ -0,0 +1,327 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +#include /* IFF_LOOPBACK */ +#include /* ARPHRD_ETHER */ + +#include "sd-dhcp-client.h" +#include "sd-ipv4acd.h" + +#include "ipvlan.h" +#include "networkd-address.h" +#include "networkd-dhcp4.h" +#include "networkd-ipv4acd.h" +#include "networkd-link.h" +#include "networkd-manager.h" + +bool link_ipv4acd_supported(Link *link) { + assert(link); + + if (link->flags & IFF_LOOPBACK) + return false; + + /* ARPHRD_INFINIBAND seems to potentially support IPv4ACD. + * But currently sd-ipv4acd only supports ARPHRD_ETHER. */ + if (link->iftype != ARPHRD_ETHER) + return false; + + if (link->hw_addr.length != ETH_ALEN) + return false; + + if (ether_addr_is_null(&link->hw_addr.ether)) + return false; + + if (streq_ptr(link->kind, "vrf")) + return false; + + /* L3 or L3S mode do not support ARP. */ + if (IN_SET(link_get_ipvlan_mode(link), NETDEV_IPVLAN_MODE_L3, NETDEV_IPVLAN_MODE_L3S)) + return false; + + return true; +} + +static bool address_ipv4acd_enabled(Address *address) { + assert(address); + assert(address->link); + + if (address->family != AF_INET) + return false; + + if (!FLAGS_SET(address->duplicate_address_detection, ADDRESS_FAMILY_IPV4)) + return false; + + /* Currently, only static and DHCP4 addresses are supported. */ + if (!IN_SET(address->source, NETWORK_CONFIG_SOURCE_STATIC, NETWORK_CONFIG_SOURCE_DHCP4)) + return false; + + if (!link_ipv4acd_supported(address->link)) + return false; + + return true; +} + +bool ipv4acd_bound(const Address *address) { + assert(address); + + if (!address->acd) + return true; + + return address->acd_bound; +} + +static int static_ipv4acd_address_remove(Link *link, Address *address, bool on_conflict) { + int r; + + assert(link); + assert(address); + + if (!address_exists(address)) + return 0; /* Not assigned. */ + + if (on_conflict) + log_link_warning(link, "Dropping address "IPV4_ADDRESS_FMT_STR", as an address conflict was detected.", + IPV4_ADDRESS_FMT_VAL(address->in_addr.in)); + else + log_link_debug(link, "Removing address "IPV4_ADDRESS_FMT_STR", as the ACD client is stopped.", + IPV4_ADDRESS_FMT_VAL(address->in_addr.in)); + + r = address_remove(address); + if (r < 0) + return log_link_warning_errno(link, r, "Failed to remove address "IPV4_ADDRESS_FMT_STR": %m", + IPV4_ADDRESS_FMT_VAL(address->in_addr.in)); + + return 0; +} + +static int dhcp4_address_on_conflict(Link *link, Address *address) { + int r; + + assert(link); + assert(link->dhcp_client); + + r = sd_dhcp_client_send_decline(link->dhcp_client); + if (r < 0) + log_link_warning_errno(link, r, "Failed to send DHCP DECLINE, ignoring: %m"); + + if (!link->dhcp_lease) + /* Unlikely, but during probing the address, the lease may be lost. */ + return 0; + + log_link_warning(link, "Dropping DHCPv4 lease, as an address conflict was detected."); + r = dhcp4_lease_lost(link); + if (r < 0) + return log_link_warning_errno(link, r, "Failed to drop DHCPv4 lease: %m"); + + /* It is not necessary to call address_remove() here, as dhcp4_lease_lost() removes it. */ + return 0; +} + +static void on_acd(sd_ipv4acd *acd, int event, void *userdata) { + Address *address = ASSERT_PTR(userdata); + Link *link; + int r; + + assert(acd); + assert(address->acd == acd); + assert(address->link); + assert(address->family == AF_INET); + assert(IN_SET(address->source, NETWORK_CONFIG_SOURCE_STATIC, NETWORK_CONFIG_SOURCE_DHCP4)); + + link = address->link; + + switch (event) { + case SD_IPV4ACD_EVENT_STOP: + address->acd_bound = false; + + if (address->source == NETWORK_CONFIG_SOURCE_STATIC) { + r = static_ipv4acd_address_remove(link, address, /* on_conflict = */ false); + if (r < 0) + link_enter_failed(link); + } + + /* We have nothing to do for DHCPv4 lease here, as the dhcp client is already stopped + * when stopping the ipv4acd client. See link_stop_engines(). */ + break; + + case SD_IPV4ACD_EVENT_BIND: + address->acd_bound = true; + + log_link_debug(link, "Successfully claimed address "IPV4_ADDRESS_FMT_STR, + IPV4_ADDRESS_FMT_VAL(address->in_addr.in)); + break; + + case SD_IPV4ACD_EVENT_CONFLICT: + address->acd_bound = false; + + log_link_warning(link, "Dropping address "IPV4_ADDRESS_FMT_STR", as an address conflict was detected.", + IPV4_ADDRESS_FMT_VAL(address->in_addr.in)); + + if (address->source == NETWORK_CONFIG_SOURCE_STATIC) + r = static_ipv4acd_address_remove(link, address, /* on_conflict = */ true); + else + r = dhcp4_address_on_conflict(link, address); + if (r < 0) + link_enter_failed(link); + break; + + default: + assert_not_reached(); + } +} + +static int ipv4acd_check_mac(sd_ipv4acd *acd, const struct ether_addr *mac, void *userdata) { + Manager *m = ASSERT_PTR(userdata); + struct hw_addr_data hw_addr; + + assert(mac); + + hw_addr = (struct hw_addr_data) { + .length = ETH_ALEN, + .ether = *mac, + }; + + return link_get_by_hw_addr(m, &hw_addr, NULL) >= 0; +} + +static int address_ipv4acd_start(Address *address) { + assert(address); + assert(address->link); + + if (!address->acd) + return 0; + + if (sd_ipv4acd_is_running(address->acd)) + return 0; + + if (!link_has_carrier(address->link)) + return 0; + + return sd_ipv4acd_start(address->acd, true); +} + +int ipv4acd_configure(Address *address) { + Link *link; + int r; + + assert(address); + + link = ASSERT_PTR(address->link); + + if (!address_ipv4acd_enabled(address)) { + address->acd = sd_ipv4acd_unref(address->acd); + address->acd_bound = false; + return 0; + } + + if (address->acd) + return address_ipv4acd_start(address); + + log_link_debug(link, "Configuring IPv4ACD for address "IPV4_ADDRESS_FMT_STR, + IPV4_ADDRESS_FMT_VAL(address->in_addr.in)); + + r = sd_ipv4acd_new(&address->acd); + if (r < 0) + return r; + + r = sd_ipv4acd_attach_event(address->acd, link->manager->event, 0); + if (r < 0) + return r; + + r = sd_ipv4acd_set_ifindex(address->acd, link->ifindex); + if (r < 0) + return r; + + r = sd_ipv4acd_set_mac(address->acd, &link->hw_addr.ether); + if (r < 0) + return r; + + r = sd_ipv4acd_set_address(address->acd, &address->in_addr.in); + if (r < 0) + return r; + + r = sd_ipv4acd_set_callback(address->acd, on_acd, address); + if (r < 0) + return r; + + r = sd_ipv4acd_set_check_mac_callback(address->acd, ipv4acd_check_mac, link->manager); + if (r < 0) + return r; + + return address_ipv4acd_start(address); +} + +int ipv4acd_update_mac(Link *link) { + Address *address; + int k, r = 0; + + assert(link); + + if (link->hw_addr.length != ETH_ALEN) + return 0; + if (ether_addr_is_null(&link->hw_addr.ether)) + return 0; + + SET_FOREACH(address, link->addresses) { + if (!address->acd) + continue; + + k = sd_ipv4acd_set_mac(address->acd, &link->hw_addr.ether); + if (k < 0) + r = k; + } + if (r < 0) + link_enter_failed(link); + + return r; +} + +int ipv4acd_start(Link *link) { + Address *address; + int r; + + assert(link); + + SET_FOREACH(address, link->addresses) { + r = address_ipv4acd_start(address); + if (r < 0) + return r; + } + + return 0; +} + +int ipv4acd_stop(Link *link) { + Address *address; + int k, r = 0; + + assert(link); + + SET_FOREACH(address, link->addresses) { + if (!address->acd) + continue; + + k = sd_ipv4acd_stop(address->acd); + if (k < 0) + r = k; + } + + return r; +} + +int ipv4acd_set_ifname(Link *link) { + Address *address; + int r; + + assert(link); + + SET_FOREACH(address, link->addresses) { + if (!address->acd) + continue; + + r = sd_ipv4acd_set_ifname(address->acd, link->ifname); + if (r < 0) + return r; + } + + return 0; +} -- cgit v1.2.3