HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/network/networkd-link.c

119,885 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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;