HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/network/networkd-link.c
Git blob: ea4965d466277b64dca8045abd509ddb28094d14
Lines 1001–2000 of 3,219
static void link_free_bound_to_list(Link *link) {
bool updated = false;
Link *bound_to;
assert(link);
while ((bound_to = hashmap_steal_first(link->bound_to_links))) {
updated = true;
if (hashmap_remove(bound_to->bound_by_links, INT_TO_PTR(link->ifindex)))
link_dirty(bound_to);
}
if (updated)
link_dirty(link);
}
static void link_free_bound_by_list(Link *link) {
bool updated = false;
Link *bound_by;
assert(link);
while ((bound_by = hashmap_steal_first(link->bound_by_links))) {
updated = true;
if (hashmap_remove(bound_by->bound_to_links, INT_TO_PTR(link->ifindex))) {
link_dirty(bound_by);
link_handle_bound_to_list(bound_by);
}
}
if (updated)
link_dirty(link);
}
int link_append_to_master(Link *link) {
Link *master;
int r;
assert(link);
/* - The link may have no master.
* - RTM_NEWLINK message about master interface may not be received yet. */
if (link_get_master(link, &master) < 0)
return 0;
r = set_ensure_put(&master->slaves, &link_hash_ops, link);
if (r <= 0)
return r;
link_ref(link);
return 0;
}
static void link_drop_from_master(Link *link) {
Link *master;
assert(link);
if (!link->manager)
return;
if (link_get_master(link, &master) < 0)
return;
link_unref(set_remove(master->slaves, link));
}
int link_drop_requests(Link *link, NetworkConfigSource source) {
Request *req;
int ret = 0;
assert(link);
assert(link->manager);
/* If the interface is already removed, then per-source request removal is not necessary. */
if (source >= 0 && link->state == LINK_STATE_LINGER)
return 0;
ORDERED_SET_FOREACH(req, link->manager->request_queue) {
if (req->link != link)
continue;
/* If the request is already called, but its reply is not received, then we need to
* drop the configuration (e.g. address) here. Note, if the configuration is known,
* it will be handled later by link_drop_unmanaged_addresses() or so. */
bool remove = req->waiting_reply && link->state != LINK_STATE_LINGER;
switch (req->type) {
case REQUEST_TYPE_ADDRESS: {
Address *address = ASSERT_PTR(req->userdata);
if (source >= 0 && address->source != source)
continue;
if (address_get(link, address, /* ret= */ NULL) < 0) {
if (remove)
RET_GATHER(ret, address_remove(address, link));
else
ipv4acd_detach(link, address);
}
break;
}
case REQUEST_TYPE_NEIGHBOR: {
Neighbor *neighbor = ASSERT_PTR(req->userdata);
if (source >= 0 && neighbor->source != source)
continue;
if (remove && neighbor_get(link, neighbor, /* ret= */ NULL) < 0)
RET_GATHER(ret, neighbor_remove(neighbor, link));
break;
}
case REQUEST_TYPE_NEXTHOP: {
NextHop *nexthop = ASSERT_PTR(req->userdata);
if (source >= 0 && nexthop->source != source)
continue;
if (remove && nexthop_get_by_id(link->manager, nexthop->id, /* ret= */ NULL) < 0)
RET_GATHER(ret, nexthop_remove(nexthop, link->manager));
break;
}
case REQUEST_TYPE_ROUTE: {
Route *route = ASSERT_PTR(req->userdata);
if (source >= 0 && route->source != source)
continue;
if (remove && route_get(link->manager, route, /* ret= */ NULL) < 0)
RET_GATHER(ret, route_remove(route, link->manager));
break;
}
default:
/* If a source is specified, then ignore all other kinds of requests. */
if (source >= 0)
continue;
}
request_detach(req);
}
return ret;
}
static Link *link_drop(Link *link) {
if (!link)
return NULL;
assert(link->manager);
bool notify = link_has_local_lease_domain(link);
link_set_state(link, LINK_STATE_LINGER);
/* Drop all references from other links and manager. Note that async netlink calls may have
* references to the link, and they will be dropped when we receive replies. */
(void) link_drop_requests(link, _NETWORK_CONFIG_SOURCE_INVALID);
link_free_bound_to_list(link);
link_free_bound_by_list(link);
link_clear_sr_iov_ifindices(link);
link_drop_from_master(link);
if (link->state_file)
(void) unlink(link->state_file);
link_clean(link);
STRV_FOREACH(n, link->alternative_names)
hashmap_remove_value(link->manager->links_by_name, *n, link);
hashmap_remove_value(link->manager->links_by_name, link->ifname, link);
/* bonding master and its slaves have the same hardware address. */
hashmap_remove_value(link->manager->links_by_hw_addr, &link->hw_addr, link);
/* The following must be called at last. */
hashmap_remove_value(link->manager->links_by_index, INT_TO_PTR(link->ifindex), link);
if (notify)
manager_notify_hook_filters(link->manager);
return link_unref(link);
}
static int link_drop_unmanaged_config(Link *link) {
int r;
assert(link);
assert(link->state == LINK_STATE_CONFIGURING);
assert(link->manager);
r = link_drop_unmanaged_routes(link);
RET_GATHER(r, link_drop_unmanaged_nexthops(link));
RET_GATHER(r, link_drop_unmanaged_addresses(link));
RET_GATHER(r, link_drop_unmanaged_neighbors(link));
RET_GATHER(r, link_drop_unmanaged_routing_policy_rules(link));
return r;
}
static int link_drop_static_config(Link *link) {
int r;
assert(link);
assert(link->manager);
r = link_drop_static_routes(link);
RET_GATHER(r, link_drop_static_nexthops(link));
RET_GATHER(r, link_drop_static_addresses(link));
RET_GATHER(r, link_drop_static_neighbors(link));
RET_GATHER(r, link_drop_static_routing_policy_rules(link));
return r;
}
static int link_drop_dynamic_config(Link *link, Network *network) {
int r;
assert(link);
assert(link->network);
/* Drop unnecessary dynamic configurations gracefully, e.g. drop DHCP lease in the case that
* previously DHCP=yes and now DHCP=no, but keep DHCP lease when DHCP setting is unchanged. */
r = link_drop_ndisc_config(link, network);
RET_GATHER(r, link_drop_radv_config(link, network)); /* Stop before dropping DHCP-PD prefixes. */
RET_GATHER(r, link_drop_ipv4ll_config(link, network)); /* Stop before DHCPv4 client. */
RET_GATHER(r, link_drop_dhcp4_config(link, network));
RET_GATHER(r, link_drop_dhcp6_config(link, network));
RET_GATHER(r, link_drop_dhcp_pd_config(link, network));
link->dhcp_relay_interface = sd_dhcp_relay_interface_unref(link->dhcp_relay_interface);
link->dhcp_relay_interface_compat = sd_dhcp_relay_interface_unref(link->dhcp_relay_interface_compat);
link->dhcp_server = sd_dhcp_server_unref(link->dhcp_server);
link->lldp_rx = sd_lldp_rx_unref(link->lldp_rx); /* TODO: keep the received neighbors. */
link->lldp_tx = sd_lldp_tx_unref(link->lldp_tx);
/* Even if we do not release DHCP lease or so, reset 'configured' flags. Otherwise, e.g. if
* previously UseDNS= was disabled but is now enabled, link will enter configured state before
* expected DNS servers being acquired. */
link->ipv4ll_address_configured = false;
link->dhcp4_configured = false;
link->dhcp6_configured = false;
link->dhcp_pd_configured = false;
link->ndisc_configured = false;
return r;
}
static int link_configure(Link *link) {
int r;
assert(link);
assert(link->network);
assert(link->state == LINK_STATE_INITIALIZED);
link_set_state(link, LINK_STATE_CONFIGURING);
r = link_drop_unmanaged_config(link);
if (r < 0)
return r;
r = link_new_bound_to_list(link);
if (r < 0)
return r;
r = link_request_traffic_control(link);
if (r < 0)
return r;
r = link_configure_mtu(link);
if (r < 0)
return r;
if (link->iftype == ARPHRD_CAN) {
/* let's shortcut things for CAN which doesn't need most of what's done below. */
r = link_request_to_set_can(link);
if (r < 0)
return r;
return link_request_to_activate(link);
}
r = link_request_sr_iov_vfs(link);
if (r < 0)
return r;
r = link_set_sysctl(link);
if (r < 0)
return r;
r = link_request_to_set_mac(link, /* allow_retry= */ true);
if (r < 0)
return r;
r = link_request_to_set_ipoib(link);
if (r < 0)
return r;
r = link_request_to_set_flags(link);
if (r < 0)
return r;
r = link_request_to_set_group(link);
if (r < 0)
return r;
r = link_request_to_set_addrgen_mode(link);
if (r < 0)
return r;
r = link_request_to_set_master(link);
if (r < 0)
return r;
r = link_request_stacked_netdevs(link, _NETDEV_LOCAL_ADDRESS_TYPE_INVALID);
if (r < 0)
return r;
r = link_request_to_set_bond(link);
if (r < 0)
return r;
r = link_request_to_set_bridge(link);
if (r < 0)
return r;
r = link_request_to_set_bridge_vlan(link);
if (r < 0)
return r;
r = link_request_to_activate(link);
if (r < 0)
return r;
r = ipv4ll_configure(link);
if (r < 0)
return r;
r = link_request_dhcp4_client(link);
if (r < 0)
return r;
r = link_request_dhcp6_client(link);
if (r < 0)
return r;
r = link_request_ndisc(link);
if (r < 0)
return r;
r = link_request_dhcp_relay(link);
if (r < 0)
return r;
r = link_request_dhcp_server(link);
if (r < 0)
return r;
r = link_request_radv(link);
if (r < 0)
return r;
r = link_lldp_rx_configure(link);
if (r < 0)
return r;
r = link_lldp_tx_configure(link);
if (r < 0)
return r;
r = link_request_static_configs(link);
if (r < 0)
return r;
r = link_modem_reconfigure(link);
if (r < 0)
return r;
if (!link_has_carrier(link))
return 0;
return link_acquire_dynamic_conf(link);
}
static int link_get_network(Link *link, Network **ret) {
Network *network;
int r;
assert(link);
assert(link->manager);
assert(ret);
ORDERED_HASHMAP_FOREACH(network, link->manager->networks) {
bool warn = false;
r = net_match_config(
&network->match,
link->dev,
&link->hw_addr,
&link->permanent_hw_addr,
link->driver,
link->iftype,
link->kind,
link->ifname,
link->alternative_names,
link->wlan_iftype,
link->ssid,
&link->bssid);
if (r < 0)
return r;
if (r == 0)
continue;
if (network->match.ifname && link->dev) {
uint8_t name_assign_type;
if (device_get_sysattr_u8(link->dev, "name_assign_type", &name_assign_type) >= 0)
warn = name_assign_type == NET_NAME_ENUM;
}
log_link_full(link, warn ? LOG_WARNING : LOG_DEBUG,
"Found matching .network file%s: %s",
warn ? ", based on potentially unpredictable interface name" : "",
network->filename);
if (network->unmanaged)
return -ENOENT;
*ret = network;
return 0;
}
return log_link_debug_errno(link, SYNTHETIC_ERRNO(ENOENT), "No matching .network found.");
}
static void link_enter_unmanaged(Link *link) {
assert(link);
if (link->state == LINK_STATE_UNMANAGED)
return;
bool notify = link_has_local_lease_domain(link);
log_link_full(link, link->state == LINK_STATE_INITIALIZED ? LOG_DEBUG : LOG_INFO,
"Unmanaging interface.");
(void) link_stop_engines(link, /* may_keep_dynamic= */ false);
(void) link_drop_requests(link, _NETWORK_CONFIG_SOURCE_INVALID);
(void) link_drop_static_config(link);
/* The bound_to map depends on .network file, hence it needs to be freed. But, do not free the
* bound_by map. Otherwise, if a link enters unmanaged state below, then its carrier state will
* not propagated to other interfaces anymore. Moreover, it is not necessary to recreate the
* map here, as it depends on .network files assigned to other links. */
link_free_bound_to_list(link);
link_free_engines(link);
link->network = network_unref(link->network);
link_set_state(link, LINK_STATE_UNMANAGED);
if (notify)
manager_notify_hook_filters(link->manager);
}
static int link_managed_by_us(Link *link) {
int r;
assert(link);
if (!link->dev)
return true;
const char *s;
r = sd_device_get_property_value(link->dev, "ID_NET_MANAGED_BY", &s);
if (r == -ENOENT)
return true;
if (r < 0)
return log_link_warning_errno(link, r, "Failed to get ID_NET_MANAGED_BY udev property: %m");
if (streq(s, "io.systemd.Network"))
return true;
if (link->state == LINK_STATE_UNMANAGED)
return false; /* Already in unmanaged state */
log_link_debug(link, "Interface is requested to be managed by '%s', unmanaging the interface.", s);
link_set_state(link, LINK_STATE_UNMANAGED);
return false;
}
int link_reconfigure_impl(Link *link, LinkReconfigurationFlag flags) {
Network *network = NULL;
int r;
assert(link);
assert(link->manager);
link_assign_netdev(link);
if (link->manager->state != MANAGER_RUNNING)
return 0;
if (IN_SET(link->state, LINK_STATE_PENDING, LINK_STATE_LINGER))
return 0;
r = link_managed_by_us(link);
if (r <= 0)
return r;
r = link_get_network(link, &network);
if (r == -ENOENT) {
link_enter_unmanaged(link);
return 0;
}
if (r < 0)
return r;
if (link->network == network && !FLAGS_SET(flags, LINK_RECONFIGURE_UNCONDITIONALLY))
return 0;
_cleanup_free_ char *joined = strv_join(network->dropins, ", ");
if (link->network)
log_link_info(link, "Reconfiguring with %s%s%s%s.",
network->filename,
isempty(joined) ? "" : " (dropins: ",
joined,
isempty(joined) ? "" : ")");
else
log_link_info(link, "Configuring with %s%s%s%s.",
network->filename,
isempty(joined) ? "" : " (dropins: ",
joined,
isempty(joined) ? "" : ")");
/* Dropping configurations based on the old .network file. */
r = link_drop_requests(link, _NETWORK_CONFIG_SOURCE_INVALID);
if (r < 0)
return r;
/* The bound_to map depends on .network file, hence it needs to be freed. But, do not free the
* bound_by map. Otherwise, if a link enters unmanaged state below, then its carrier state will
* not propagated to other interfaces anymore. Moreover, it is not necessary to recreate the
* map here, as it depends on .network files assigned to other links. */
link_free_bound_to_list(link);
_cleanup_(network_unrefp) Network *old_network = TAKE_PTR(link->network);
/* Then, apply new .network file */
link->network = network_ref(network);
if (FLAGS_SET(network->keep_configuration, KEEP_CONFIGURATION_DYNAMIC) ||
!FLAGS_SET(flags, LINK_RECONFIGURE_CLEANLY)) {
/* To make 'networkctl reconfigure INTERFACE' work safely for an interface whose new .network
* file has KeepConfiguration=dynamic or yes, even if a clean reconfiguration is requested,
* drop only unnecessary or possibly being changed dynamic configurations here. */
r = link_drop_dynamic_config(link, old_network);
if (r < 0)
return r;
} else {
/* Otherwise, stop DHCP client and friends unconditionally, and drop all dynamic
* configurations like DHCP address and routes. */
r = link_stop_engines(link, /* may_keep_dynamic= */ false);
if (r < 0)
return r;
/* Free DHCP client and friends. */
link_free_engines(link);
}
link_update_operstate(link, true);
link_dirty(link);
link_set_state(link, LINK_STATE_INITIALIZED);
link->activated = false;
r = link_configure(link);
if (r < 0)
return r;
return 1;
}
typedef struct LinkReconfigurationData {
Manager *manager;
Link *link;
LinkReconfigurationFlag flags;
sd_bus_message *message;
sd_varlink *varlink;
unsigned *counter;
} LinkReconfigurationData;
static LinkReconfigurationData* link_reconfiguration_data_free(LinkReconfigurationData *data) {
if (!data)
return NULL;
link_unref(data->link);
sd_bus_message_unref(data->message);
sd_varlink_unref(data->varlink);
return mfree(data);
}
DEFINE_TRIVIAL_CLEANUP_FUNC(LinkReconfigurationData*, link_reconfiguration_data_free);
static void link_reconfiguration_data_destroy_callback(LinkReconfigurationData *data) {
int r;
assert(data);
assert(!data->message || !data->varlink); /* D-Bus and Varlink callers are mutually exclusive */
if (data->counter) {
assert(*data->counter > 0);
(*data->counter)--;
}
if (!data->counter || *data->counter == 0) {
/* Update the state files before replying. Otherwise, systemd-networkd-wait-online following
* networkctl reload/reconfigure may read an outdated state file and wrongly consider an
* interface already in the configured state. */
(void) manager_clean_all(data->manager);
if (data->message) {
r = sd_bus_reply_method_return(data->message, NULL);
if (r < 0)
log_warning_errno(r, "Failed to reply for DBus method, ignoring: %m");
}
if (data->varlink) {
r = sd_varlink_reply(data->varlink, NULL);
if (r < 0)
log_warning_errno(r, "Failed to reply to Varlink request, ignoring: %m");
}
}
link_reconfiguration_data_free(data);
}
static int link_reconfigure_handler(sd_netlink *rtnl, sd_netlink_message *m, LinkReconfigurationData *data) {
Link *link = ASSERT_PTR(ASSERT_PTR(data)->link);
int r;
r = link_getlink_handler_internal(rtnl, m, link, "Failed to update link state");
if (r <= 0)
return r;
r = link_reconfigure_impl(link, data->flags);
if (r < 0) {
link_enter_failed(link);
return 0;
}
return r;
}
int link_reconfigure_full(Link *link, LinkReconfigurationFlag flags, sd_bus_message *message, sd_varlink *varlink, unsigned *counter) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
_cleanup_(link_reconfiguration_data_freep) LinkReconfigurationData *data = NULL;
int r;
assert(link);
assert(link->manager);
assert(link->manager->rtnl);
assert(!message || !varlink); /* D-Bus and Varlink callers are mutually exclusive */
/* When the link is in the pending or initialized state, link_reconfigure_impl() will be called later
* by link_initialized() or link_initialized_and_synced(). To prevent the function from being called
* multiple times simultaneously, let's refuse to reconfigure the interface here in such cases. */
if (IN_SET(link->state, LINK_STATE_PENDING, LINK_STATE_INITIALIZED, LINK_STATE_LINGER))
return 0; /* 0 means no-op. */
data = new(LinkReconfigurationData, 1);
if (!data) {
r = -ENOMEM;
goto failed;
}
*data = (LinkReconfigurationData) {
.manager = link->manager,
.link = link_ref(link),
.flags = flags,
.message = sd_bus_message_ref(message), /* message may be NULL, but _ref() works fine. */
.varlink = sd_varlink_ref(varlink), /* varlink may be NULL, but _ref() works fine. */
.counter = counter,
};
r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
if (r < 0)
goto failed;
r = netlink_call_async(link->manager->rtnl, NULL, req,
link_reconfigure_handler,
link_reconfiguration_data_destroy_callback, data);
if (r < 0)
goto failed;
TAKE_PTR(data);
if (counter)
(*counter)++;
if (link->state == LINK_STATE_FAILED)
link_set_state(link, LINK_STATE_INITIALIZED);
return 1; /* 1 means the interface will be reconfigured, and bus method will be replied later. */
failed:
log_link_warning_errno(link, r, "Failed to reconfigure interface: %m");
link_enter_failed(link);
return r;
}
static int link_initialized_and_synced(Link *link) {
int r;
assert(link);
assert(link->manager);
if (link->state == LINK_STATE_PENDING) {
log_link_debug(link, "Link state is up-to-date");
link_set_state(link, LINK_STATE_INITIALIZED);
r = link_new_bound_by_list(link);
if (r < 0)
return r;
r = link_handle_bound_by_list(link);
if (r < 0)
return r;
}
return link_reconfigure_impl(link, /* flags= */ 0);
}
static int link_initialized_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
int r;
r = link_getlink_handler_internal(rtnl, m, link, "Failed to wait for the interface to be initialized");
if (r <= 0)
return r;
r = link_initialized_and_synced(link);
if (r < 0)
link_enter_failed(link);
return 0;
}
static int link_initialized(Link *link, sd_device *device) {
int r;
assert(link);
assert(device);
/* Always replace with the new sd_device object. As the sysname (and possibly other properties
* or sysattrs) may be outdated. */
device_unref_and_replace_new_ref(link->dev, device);
r = link_managed_by_us(link);
if (r <= 0)
return r;
if (link->dhcp_client) {
r = sd_dhcp_client_attach_device(link->dhcp_client, link->dev);
if (r < 0)
log_link_warning_errno(link, r, "Failed to attach device to DHCPv4 client, ignoring: %m");
}
if (link->dhcp6_client) {
r = sd_dhcp6_client_attach_device(link->dhcp6_client, link->dev);
if (r < 0)
log_link_warning_errno(link, r, "Failed to attach device to DHCPv6 client, ignoring: %m");
}
r = link_set_sr_iov_ifindices(link);
if (r < 0)
log_link_warning_errno(link, r, "Failed to manage SR-IOV PF and VF ports, ignoring: %m");
if (link->state != LINK_STATE_PENDING)
return link_reconfigure(link, /* flags= */ 0);
log_link_debug(link, "udev initialized link");
/* udev has initialized the link, but we don't know if we have yet
* processed the NEWLINK messages with the latest state. Do a GETLINK,
* when it returns we know that the pending NEWLINKs have already been
* processed and that we are up-to-date */
return link_call_getlink(link, link_initialized_handler);
}
int link_check_initialized(Link *link) {
_cleanup_(sd_device_unrefp) sd_device *device = NULL;
int r;
assert(link);
if (!udev_available())
return link_initialized_and_synced(link);
/* udev should be around */
r = sd_device_new_from_ifindex(&device, link->ifindex);
if (r < 0) {
log_link_debug_errno(link, r, "Could not find device, waiting for device initialization: %m");
return 0;
}
r = device_is_processed(device);
if (r < 0)
return log_link_warning_errno(link, r, "Could not determine whether the device is processed by udevd: %m");
if (r == 0) {
/* not yet ready */
log_link_debug(link, "link pending udev initialization...");
return 0;
}
r = device_is_renaming(device);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to determine the device is being renamed: %m");
if (r > 0) {
log_link_debug(link, "Interface is being renamed, pending initialization.");
return 0;
}
return link_initialized(link, device);
}
int manager_udev_process_link(Manager *m, sd_device *device, sd_device_action_t action) {
int r, ifindex;
Link *link;
assert(m);
assert(device);
r = sd_device_get_ifindex(device, &ifindex);
if (r < 0)
return log_device_debug_errno(device, r, "Failed to get ifindex: %m");
r = link_get_by_index(m, ifindex, &link);
if (r < 0) {
/* This error is not critical, as the corresponding rtnl message may be received later. */
log_device_debug_errno(device, r, "Failed to get link from ifindex %i, ignoring: %m", ifindex);
return 0;
}
/* Let's unref the sd-device object assigned to the corresponding Link object, but keep the Link
* object here. It will be removed only when rtnetlink says so. */
if (action == SD_DEVICE_REMOVE) {
link->dev = sd_device_unref(link->dev);
return 0;
}
r = device_is_renaming(device);
if (r < 0)
return log_device_debug_errno(device, r, "Failed to determine if the device is renaming or not: %m");
if (r > 0) {
log_device_debug(device, "Device is renaming, waiting for the interface to be renamed.");
/* TODO:
* What happens when a device is initialized, then soon renamed after that? When we detect
* such, maybe we should cancel or postpone all queued requests for the interface. */
return 0;
}
r = link_initialized(link, device);
if (r < 0)
link_enter_failed(link);
return 0;
}
static int link_carrier_gained(Link *link) {
LinkReconfigurationFlag flags = 0;
int r;
assert(link);
log_link_info(link, "Gained carrier");
r = event_source_disable(link->carrier_lost_timer);
if (r < 0)
log_link_warning_errno(link, r, "Failed to disable carrier lost timer, ignoring: %m");
/* Process BindCarrier= setting specified by other interfaces. This is independent of the .network
* file assigned to this interface, but depends on .network files assigned to other interfaces.
* Hence, this can and should be called earlier. */
r = link_handle_bound_by_list(link);
if (r < 0)
return r;
/* If a wireless interface was connected to an access point, and the SSID is changed (that is,
* both previous_ssid and ssid are non-NULL), then the connected wireless network could be
* changed. So, always reconfigure the link. Which means e.g. the DHCP client will be
* restarted, and the correct network information will be gained.
*
* However, do not reconfigure the wireless interface forcibly if it was not connected to any
* access points previously (previous_ssid is NULL in this case). As, a .network file may be
* already assigned to the interface (in that case, the .network file does not have the SSID=
* setting in the [Match] section), and the interface is already being configured. Of course,
* there may exist another .network file with higher priority and a matching SSID= setting. But
* in that case, link_reconfigure_impl() can handle that without any flags.
*
* For non-wireless interfaces, we have no way to detect the connected network change. So,
* we do not set any flags here. Note, both ssid and previous_ssid are NULL in that case. */
if (link->previous_ssid && !streq_ptr(link->previous_ssid, link->ssid))
flags |= LINK_RECONFIGURE_UNCONDITIONALLY | LINK_RECONFIGURE_CLEANLY;
link->previous_ssid = mfree(link->previous_ssid);
/* AP and P2P-GO interfaces may have a new SSID - update the link properties in case a new .network
* profile wants to match on it with SSID= in its [Match] section.
*/
if (IN_SET(link->wlan_iftype, NL80211_IFTYPE_AP, NL80211_IFTYPE_P2P_GO)) {
r = link_get_wlan_interface(link);
if (r < 0)
return r;
}
/* At this stage, both wlan and link information should be up-to-date. Hence, it is not necessary to
* call RTM_GETLINK, NL80211_CMD_GET_INTERFACE, or NL80211_CMD_GET_STATION commands, and simply call
* link_reconfigure_impl(). Note, link_reconfigure_impl() returns 1 when the link is reconfigured. */
r = link_reconfigure_impl(link, flags);
if (r != 0)
return r;
if (link->iftype == ARPHRD_CAN)
/* let's shortcut things for CAN which doesn't need most of what's done below. */
return 0;
if (IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED)) {
r = link_acquire_dynamic_conf(link);
if (r < 0)
return r;
r = link_request_static_configs(link);
if (r < 0)
return r;
}
return 0;
}
static int link_carrier_lost_impl(Link *link) {
int ret = 0;
assert(link);
link->previous_ssid = mfree(link->previous_ssid);
ret = link_handle_bound_by_list(link);
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
return ret;
if (!link->network)
return ret;
RET_GATHER(ret, link_stop_engines(link, /* may_keep_dynamic= */ false));
RET_GATHER(ret, link_drop_static_config(link));
return ret;
}
static int link_carrier_lost_handler(sd_event_source *s, uint64_t usec, void *userdata) {
Link *link = ASSERT_PTR(userdata);
int r;
r = link_carrier_lost_impl(link);
if (r < 0) {
log_link_warning_errno(link, r, "Failed to process carrier lost event: %m");
link_enter_failed(link);
}
return 0;
}
static int link_carrier_lost(Link *link) {
uint16_t dhcp_mtu;
usec_t usec;
assert(link);
log_link_info(link, "Lost carrier");
if (link->iftype == ARPHRD_CAN)
/* let's shortcut things for CAN which doesn't need most of what's done below. */
usec = 0;
else if (!link->network)
usec = 0;
else if (link->network->ignore_carrier_loss_set)
/* If IgnoreCarrierLoss= is explicitly specified, then use the specified value. */
usec = link->network->ignore_carrier_loss_usec;
else if (link->network->bond && link->wlan_iftype > 0)
/* Enslaving wlan interface to a bond disconnects from the connected AP, and causes its
* carrier to be lost. See #19832. */
usec = 3 * USEC_PER_SEC;