HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/network/networkd-address.c

93,831 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 135c3a04a54923540a2b9413509b31656798e500

Lines 1001–2000 of 2,534

                        if (!address_match_null(req->userdata, address))
                                continue;
 
                        if (ret)
                                *ret = req;
 
                        return 0;
                }
 
        return -ENOENT;
}
 
int address_get(Link *link, const Address *in, Address **ret) {
        Address *a;
 
        assert(link);
        assert(in);
 
        a = set_get(link->addresses, in);
        if (a) {
                if (ret)
                        *ret = a;
                return 0;
        }
 
        /* Find matching address that originally requested as null address. */
        if (address_is_static_null(in))
                SET_FOREACH(a, link->addresses) {
                        if (!address_match_null(a, in))
                                continue;
 
                        if (ret)
                                *ret = a;
                        return 0;
                }
 
        return -ENOENT;
}
 
int address_get_harder(Link *link, const Address *in, Address **ret) {
        Request *req;
        int r;
 
        assert(link);
        assert(in);
 
        if (address_get(link, in, ret) >= 0)
                return 0;
 
        r = address_get_request(link, in, &req);
        if (r < 0)
                return r;
 
        if (ret)
                *ret = ASSERT_PTR(req->userdata);
 
        return 0;
}
 
int link_get_address_full(
                Link *link,
                int family,
                const union in_addr_union *address,
                const union in_addr_union *peer, /* optional, can be NULL */
                unsigned char prefixlen,         /* optional, can be 0 */
                Address **ret) {
 
        Address *a;
        int r;
 
        assert(link);
        assert(IN_SET(family, AF_INET, AF_INET6));
        assert(address);
 
        /* This finds an Address object on the link which matches the given address, peer, and prefix length.
         * If the prefixlen is zero, then an Address object with an arbitrary prefixlen will be returned.
         * If the peer is NULL, then an Address object with an arbitrary peer will be returned. */
 
        if (family == AF_INET6 || (prefixlen != 0 && peer)) {
                _cleanup_(address_unrefp) Address *tmp = NULL;
 
                /* In this case, we can use address_get(). */
 
                r = address_new(&tmp);
                if (r < 0)
                        return r;
 
                tmp->family = family;
                tmp->in_addr = *address;
                if (peer)
                        tmp->in_addr_peer = *peer;
                tmp->prefixlen = prefixlen;
 
                r = address_get(link, tmp, &a);
                if (r < 0)
                        return r;
 
                if (family == AF_INET6) {
                        /* IPv6 addresses are managed without peer address and prefix length. Hence, we need
                         * to check them explicitly. */
                        if (peer && !in_addr_equal(family, &a->in_addr_peer, peer))
                                return -ENOENT;
                        if (prefixlen != 0 && a->prefixlen != prefixlen)
                                return -ENOENT;
                }
 
                if (ret)
                        *ret = a;
 
                return 0;
        }
 
        SET_FOREACH(a, link->addresses) {
                if (a->family != family)
                        continue;
 
                if (!in_addr_equal(family, &a->in_addr, address))
                        continue;
 
                if (peer && !in_addr_equal(family, &a->in_addr_peer, peer))
                        continue;
 
                if (prefixlen != 0 && a->prefixlen != prefixlen)
                        continue;
 
                if (ret)
                        *ret = a;
 
                return 0;
        }
 
        return -ENOENT;
}
 
int manager_get_address_full(
                Manager *manager,
                int family,
                const union in_addr_union *address,
                const union in_addr_union *peer,
                unsigned char prefixlen,
                Address **ret) {
 
        Link *link;
 
        assert(manager);
        assert(IN_SET(family, AF_INET, AF_INET6));
        assert(address);
 
        HASHMAP_FOREACH(link, manager->links_by_index) {
                if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
                        continue;
 
                if (link_get_address_full(link, family, address, peer, prefixlen, ret) >= 0)
                        return 0;
        }
 
        return -ENOENT;
}
 
const char* format_lifetime(char *buf, size_t l, usec_t lifetime_usec) {
        assert(buf);
        assert(l > 4);
 
        if (lifetime_usec == USEC_INFINITY)
                return "forever";
 
        sprintf(buf, "for ");
        /* format_timespan() never fails */
        assert_se(format_timespan(buf + 4, l - 4, usec_sub_unsigned(lifetime_usec, now(CLOCK_BOOTTIME)), USEC_PER_SEC));
        return buf;
}
 
void log_address_debug(const Address *address, const char *str, const Link *link) {
        _cleanup_free_ char *state = NULL, *flags_str = NULL, *scope_str = NULL;
 
        assert(address);
        assert(str);
        assert(link);
 
        if (!DEBUG_LOGGING)
                return;
 
        (void) network_config_state_to_string_alloc(address->state, &state);
 
        const char *peer = in_addr_is_set(address->family, &address->in_addr_peer) ?
                IN_ADDR_TO_STRING(address->family, &address->in_addr_peer) : NULL;
 
        const char *broadcast = (address->family == AF_INET && in4_addr_is_set(&address->broadcast)) ?
                IN4_ADDR_TO_STRING(&address->broadcast) : NULL;
 
        (void) address_flags_to_string_alloc(address->flags, address->family, &flags_str);
        (void) route_scope_to_string_alloc(address->scope, &scope_str);
 
        log_link_debug(link, "%s %s address (%s): %s%s%s/%u%s%s (valid %s, preferred %s), flags: %s, scope: %s%s%s",
                       str, strna(network_config_source_to_string(address->source)), strna(state),
                       IN_ADDR_TO_STRING(address->family, &address->in_addr),
                       peer ? " peer " : "", strempty(peer), address->prefixlen,
                       broadcast ? " broadcast " : "", strempty(broadcast),
                       FORMAT_LIFETIME(address->lifetime_valid_usec),
                       FORMAT_LIFETIME(address->lifetime_preferred_usec),
                       strna(flags_str), strna(scope_str),
                       address->family == AF_INET ? ", label: " : "",
                       address->family == AF_INET ? strna(address->label) : "");
}
 
static void address_forget(Link *link, Address *address, bool removed_by_us, const char *msg) {
        assert(link);
        assert(address);
        assert(msg);
 
        Request *req;
        if (address_get_request(link, address, &req) >= 0)
                address_enter_removed(req->userdata);
 
        if (!address->link && address_get(link, address, &address) < 0)
                return;
 
        address_enter_removed(address);
        log_address_debug(address, msg, link);
        (void) address_drop(address, removed_by_us);
}
 
static int address_set_netlink_message(const Address *address, sd_netlink_message *m, Link *link) {
        int r;
 
        assert(address);
        assert(m);
        assert(link);
 
        r = sd_rtnl_message_addr_set_prefixlen(m, address->prefixlen);
        if (r < 0)
                return r;
 
        /* On remove, only IFA_F_MANAGETEMPADDR flag for IPv6 addresses are used. But anyway, set all
         * flags except tentative flag here unconditionally. Without setting the flag, the template
         * addresses generated by kernel will not be removed automatically when the main address is
         * removed. */
        uint32_t flags = address->flags & ~IFA_F_TENTATIVE;
        if (flags != 0) {
                r = sd_netlink_message_append_u32(m, IFA_FLAGS, flags);
                if (r < 0)
                        return r;
        }
 
        r = netlink_message_append_in_addr_union(m, IFA_LOCAL, address->family, &address->in_addr);
        if (r < 0)
                return r;
 
        return 0;
}
 
static int address_remove_handler(sd_netlink *rtnl, sd_netlink_message *m, RemoveRequest *rreq) {
        int r;
 
        assert(m);
        assert(rreq);
 
        Link *link = ASSERT_PTR(rreq->link);
        Address *address = ASSERT_PTR(rreq->userdata);
 
        if (link->state == LINK_STATE_LINGER)
                return 0;
 
        r = sd_netlink_message_get_errno(m);
        if (r < 0) {
                log_link_message_full_errno(link, m,
                                            (r == -EADDRNOTAVAIL || !address->link) ? LOG_DEBUG : LOG_WARNING,
                                            r, "Could not drop address");
 
                /* If the address cannot be removed, then assume the address is already removed. */
                address_forget(link, address, /* removed_by_us= */ true, "Forgetting");
        }
 
        return 1;
}
 
int address_remove(Address *address, Link *link) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
        int r;
 
        assert(address);
        assert(IN_SET(address->family, AF_INET, AF_INET6));
        assert(link);
        assert(link->ifindex > 0);
        assert(link->manager);
        assert(link->manager->rtnl);
 
        /* If the address is remembered, use the remembered object. */
        (void) address_get(link, address, &address);
 
        log_address_debug(address, "Removing", link);
 
        r = sd_rtnl_message_new_addr(link->manager->rtnl, &m, RTM_DELADDR,
                                     link->ifindex, address->family);
        if (r < 0)
                return log_link_warning_errno(link, r, "Could not allocate RTM_DELADDR message: %m");
 
        r = address_set_netlink_message(address, m, link);
        if (r < 0)
                return log_link_warning_errno(link, r, "Could not set netlink attributes: %m");
 
        r = link_remove_request_add(link, address, address, link->manager->rtnl, m, address_remove_handler);
        if (r < 0)
                return log_link_warning_errno(link, r, "Could not queue rtnetlink message: %m");
 
        address_enter_removing(address);
 
        /* The operational state is determined by address state and carrier state. Hence, if we remove
         * an address, the operational state may be changed. */
        link_update_operstate(link, true);
        return 0;
}
 
int address_remove_and_cancel(Address *address, Link *link) {
        _cleanup_(request_unrefp) Request *req = NULL;
        bool waiting = false;
 
        assert(address);
        assert(link);
        assert(link->manager);
 
        /* If the address is remembered by the link, then use the remembered object. */
        (void) address_get(link, address, &address);
 
        /* Cancel the request for the address.  If the request is already called but we have not received the
         * notification about the request, then explicitly remove the address. */
        if (address_get_request(link, address, &req) >= 0) {
                request_ref(req); /* avoid the request freed by request_detach() */
                waiting = req->waiting_reply;
                request_detach(req);
                address_cancel_requesting(address);
        }
 
        /* If we know the address will come or already exists, remove it. */
        if (waiting || (address->link && address_exists(address)))
                return address_remove(address, link);
 
        /* Otherwise, the address should be already gone or not configured yet. */
        ipv4acd_detach(link, address);
 
        return 0;
}
 
bool link_address_is_dynamic(const Link *link, const Address *address) {
        Route *route;
 
        assert(link);
        assert(link->manager);
        assert(address);
 
        if (address->lifetime_preferred_usec != USEC_INFINITY)
                return true;
 
        /* There is no way to drtermine if the IPv6 address is dynamic when the lifetime is infinity. */
        if (address->family != AF_INET)
                return false;
 
        /* Even if an IPv4 address is leased from a DHCP server with a finite lifetime, networkd assign the
         * address without lifetime when KeepConfiguration=dynamic. So, let's check that we have
         * corresponding routes with RTPROT_DHCP. */
        SET_FOREACH(route, link->manager->routes) {
                if (route->source != NETWORK_CONFIG_SOURCE_FOREIGN)
                        continue;
 
                /* The route is not assigned yet, or already being removed. Ignoring. */
                if (!route_exists(route))
                        continue;
 
                if (route->protocol != RTPROT_DHCP)
                        continue;
 
                if (route->nexthop.ifindex != link->ifindex)
                        continue;
 
                if (address->family != route->family)
                        continue;
 
                if (in_addr_equal(address->family, &address->in_addr, &route->prefsrc))
                        return true;
        }
 
        return false;
}
 
int link_drop_ipv6ll_addresses(Link *link) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
        int r;
 
        assert(link);
        assert(link->manager);
        assert(link->manager->rtnl);
 
        /* IPv6LL address may be in the tentative state, and in that case networkd has not received it.
         * So, we need to dump all IPv6 addresses. */
 
        if (link_ipv6ll_enabled_harder(link))
                return 0;
 
        r = sd_rtnl_message_new_addr(link->manager->rtnl, &req, RTM_GETADDR, link->ifindex, AF_INET6);
        if (r < 0)
                return r;
 
        r = sd_netlink_message_set_request_dump(req, true);
        if (r < 0)
                return r;
 
        r = sd_netlink_call(link->manager->rtnl, req, 0, &reply);
        if (r < 0)
                return r;
 
        for (sd_netlink_message *addr = reply; addr; addr = sd_netlink_message_next(addr)) {
                _cleanup_(address_unrefp) Address *a = NULL;
                unsigned char prefixlen;
                struct in6_addr address;
                int ifindex;
 
                /* We set ifindex in the request, and NETLINK_GET_STRICT_CHK socket option is set. Hence the
                 * check below is redundant, but let's do that for safety. */
                r = sd_rtnl_message_addr_get_ifindex(addr, &ifindex);
                if (r < 0) {
                        log_link_debug_errno(link, r, "rtnl: received address message without valid ifindex, ignoring: %m");
                        continue;
                } else if (link->ifindex != ifindex)
                        continue;
 
                uint32_t flags;
                r = sd_netlink_message_read_u32(addr, IFA_FLAGS, &flags);
                if (r < 0) {
                        log_link_debug_errno(link, r, "rtnl: Failed to read IFA_FLAGS attribute, ignoring: %m");
                        continue;
                }
 
                r = sd_rtnl_message_addr_get_prefixlen(addr, &prefixlen);
                if (r < 0) {
                        log_link_debug_errno(link, r, "rtnl: received address message without prefixlen, ignoring: %m");
                        continue;
                }
 
                if (sd_netlink_message_read_in6_addr(addr, IFA_LOCAL, NULL) >= 0)
                        /* address with peer, ignoring. */
                        continue;
 
                r = sd_netlink_message_read_in6_addr(addr, IFA_ADDRESS, &address);
                if (r < 0) {
                        log_link_debug_errno(link, r, "rtnl: received address message without valid address, ignoring: %m");
                        continue;
                }
 
                if (!in6_addr_is_link_local(&address))
                         continue;
 
                r = address_new(&a);
                if (r < 0)
                        return -ENOMEM;
 
                a->family = AF_INET6;
                a->in_addr.in6 = address;
                a->prefixlen = prefixlen;
                a->flags = flags;
 
                r = address_remove(a, link);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
int link_drop_unmanaged_addresses(Link *link) {
        Address *address;
        int r = 0;
 
        assert(link);
        assert(link->network);
 
        /* First, mark all addresses. */
        SET_FOREACH(address, link->addresses) {
                /* We consider IPv6LL addresses to be managed by the kernel, or dropped in link_drop_ipv6ll_addresses() */
                if (address->family == AF_INET6 && in6_addr_is_link_local(&address->in_addr.in6))
                        continue;
 
                /* Do not remove localhost address (127.0.0.1 and ::1) */
                if (link->flags & IFF_LOOPBACK && in_addr_is_localhost_one(address->family, &address->in_addr) > 0)
                        continue;
 
                /* Ignore addresses not assigned yet or already removing. */
                if (!address_exists(address))
                        continue;
 
                if (address->source == NETWORK_CONFIG_SOURCE_FOREIGN) {
                        if (link->network->keep_configuration == KEEP_CONFIGURATION_YES)
                                continue;
 
                        /* link_address_is_dynamic() is slightly heavy. Let's call the function only when
                         * KeepConfiguration=dynamic or static. */
                        if (IN_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DYNAMIC, KEEP_CONFIGURATION_STATIC) &&
                            link_address_is_dynamic(link, address) == (link->network->keep_configuration == KEEP_CONFIGURATION_DYNAMIC))
                                continue;
 
                } else if (address->source != NETWORK_CONFIG_SOURCE_STATIC)
                        continue; /* Ignore dynamically configured addresses. */
 
                address_mark(address);
        }
 
        /* Then, unmark requested addresses. */
        ORDERED_HASHMAP_FOREACH(address, link->network->addresses_by_section) {
                Address *existing;
 
                if (address_get(link, address, &existing) < 0)
                        continue;
 
                if (!address_can_update(existing, address))
                        continue;
 
                /* Found matching static configuration. Keep the existing address. */
                address_unmark(existing);
        }
 
        /* Finally, remove all marked addresses. */
        SET_FOREACH(address, link->addresses) {
                if (!address_is_marked(address))
                        continue;
 
                RET_GATHER(r, address_remove(address, link));
        }
 
        return r;
}
 
int link_drop_static_addresses(Link *link) {
        Address *address;
        int r = 0;
 
        assert(link);
 
        SET_FOREACH(address, link->addresses) {
                /* Remove only static addresses here. Dynamic addresses will be removed e.g. on lease
                 * expiration or stopping the DHCP client. */
                if (address->source != NETWORK_CONFIG_SOURCE_STATIC)
                        continue;
 
                /* Ignore addresses not assigned yet or already removing. */
                if (!address_exists(address))
                        continue;
 
                RET_GATHER(r, address_remove(address, link));
        }
 
        return r;
}
 
int address_configure_handler_internal(sd_netlink_message *m, Link *link, Address *address) {
        int r;
 
        assert(m);
        assert(link);
        assert(address);
 
        r = sd_netlink_message_get_errno(m);
        if (r < 0 && r != -EEXIST) {
                log_link_message_warning_errno(link, m, r, "Failed to set %s address %s",
                                               network_config_source_to_string(address->source),
                                               IN_ADDR_TO_STRING(address->family, &address->in_addr));
                link_enter_failed(link);
                return 0;
        }
 
        return 1;
}
 
static int address_configure(const Address *address, const struct ifa_cacheinfo *c, Link *link, Request *req) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
        int r;
 
        assert(address);
        assert(IN_SET(address->family, AF_INET, AF_INET6));
        assert(c);
        assert(link);
        assert(link->ifindex > 0);
        assert(link->manager);
        assert(link->manager->rtnl);
        assert(req);
 
        log_address_debug(address, "Configuring", link);
 
        r = sd_rtnl_message_new_addr_update(link->manager->rtnl, &m, link->ifindex, address->family);
        if (r < 0)
                return r;
 
        r = address_set_netlink_message(address, m, link);
        if (r < 0)
                return r;
 
        r = sd_rtnl_message_addr_set_scope(m, address->scope);
        if (r < 0)
                return r;
 
        if (address->family == AF_INET6 || in_addr_is_set(address->family, &address->in_addr_peer)) {
                r = netlink_message_append_in_addr_union(m, IFA_ADDRESS, address->family, &address->in_addr_peer);
                if (r < 0)
                        return r;
        } else if (in4_addr_is_set(&address->broadcast)) {
                r = sd_netlink_message_append_in_addr(m, IFA_BROADCAST, &address->broadcast);
                if (r < 0)
                        return r;
        }
 
        if (address->family == AF_INET && address->label) {
                r = sd_netlink_message_append_string(m, IFA_LABEL, address->label);
                if (r < 0)
                        return r;
        }
 
        r = sd_netlink_message_append_cache_info(m, IFA_CACHEINFO, c);
        if (r < 0)
                return r;
 
        r = sd_netlink_message_append_u32(m, IFA_RT_PRIORITY, address->route_metric);
        if (r < 0)
                return r;
 
        return request_call_netlink_async(link->manager->rtnl, m, req);
}
 
static int address_acquire(Link *link, const Address *address, union in_addr_union *ret) {
        union in_addr_union a;
        int r;
 
        assert(link);
        assert(address);
        assert(ret);
 
        r = address_acquire_from_dhcp_server_leases_file(link, address, ret);
        if (!IN_SET(r, -ENOENT, -ENXIO, -EINVAL))
                return r;
 
        r = address_pool_acquire(link->manager, address->family, address->prefixlen, &a);
        if (r < 0)
                return r;
        if (r == 0)
                return -EBUSY;
 
        /* Pick first address in range for ourselves. A host prefix already identifies the exact address. */
        if (address->prefixlen < FAMILY_ADDRESS_SIZE(address->family) * 8) {
                if (address->family == AF_INET)
                        a.in.s_addr |= htobe32(1);
                else
                        a.in6.s6_addr[15] |= 1;
        }
 
        *ret = a;
        return 0;
}
 
static int address_requeue_request(Request *req, Link *link, const Address *address) {
        int r;
 
        assert(req);
        assert(link);
        assert(link->manager);
        assert(link->network);
        assert(address);
 
        /* Something useful was configured? just use it */
        if (in_addr_is_set(address->family, &address->in_addr))
                return 0;
 
        /* The address is configured to be 0.0.0.0 or [::] by the user?
         * Then let's acquire something more useful. */
        union in_addr_union a;
        r = address_acquire(link, address, &a);
        if (r < 0)
                return r;
 
        _cleanup_(address_unrefp) Address *tmp = NULL;
        r = address_dup(address, &tmp);
        if (r < 0)
                return r;
 
        tmp->in_addr = a;
 
        r = link_requeue_request(link, req, tmp, NULL);
        if (r < 0)
                return r;
        if (r == 0)
                return -EEXIST; /* Already queued?? Strange... */
 
        TAKE_PTR(tmp);
        return 1; /* A new request is queued. it is not necessary to process this request anymore. */
}
 
static int address_process_request(Request *req, Link *link, Address *address) {
        Address *existing;
        struct ifa_cacheinfo c;
        int r;
 
        assert(req);
        assert(link);
        assert(address);
 
        if (!link_is_ready_to_configure(link, false))
                return 0;
 
        /* Refuse adding more than the limit */
        if (set_size(link->addresses) >= ADDRESSES_PER_LINK_MAX)
                return 0;
 
        r = address_requeue_request(req, link, address);
        if (r == -EBUSY)
                return 0;
        if (r != 0)
                return r;
 
        address_set_broadcast(address, link);
 
        r = ipv4acd_configure(link, address);
        if (r < 0)
                return r;
 
        if (!ipv4acd_bound(link, address))
                return 0;
 
        address_set_cinfo(link->manager, address, &c);
        if (c.ifa_valid == 0) {
                log_link_debug(link, "Refuse to configure %s address %s, as its valid lifetime is zero.",
                               network_config_source_to_string(address->source),
                               IN_ADDR_PREFIX_TO_STRING(address->family, &address->in_addr, address->prefixlen));
 
                address_cancel_requesting(address);
                if (address_get(link, address, &existing) >= 0)
                        address_cancel_requesting(existing);
                return 1;
        }
 
        r = address_configure(address, &c, link, req);
        if (r < 0)
                return log_link_warning_errno(link, r, "Failed to configure address: %m");
 
        address_enter_configuring(address);
        if (address_get(link, address, &existing) >= 0)
                address_enter_configuring(existing);
 
        return 1;
}
 
int link_request_address(
                Link *link,
                const Address *address,
                unsigned *message_counter,
                address_netlink_handler_t netlink_handler,
                Request **ret) {
 
        _cleanup_(address_unrefp) Address *tmp = NULL;
        Address *existing = NULL;
        int r;
 
        assert(link);
        assert(address);
        assert(address->source != NETWORK_CONFIG_SOURCE_FOREIGN);
 
        if (address->lifetime_valid_usec == 0)
                /* The requested address is outdated. Let's ignore the request. */
                return 0;
 
        if (address_get_request(link, address, NULL) >= 0)
                return 0; /* already requested, skipping. */
 
        r = address_dup(address, &tmp);
        if (r < 0)
                return log_oom();
 
        if (address_get(link, address, &existing) >= 0) {
                /* Copy already assigned address when it is requested as a null address. */
                if (address_is_static_null(address))
                        tmp->in_addr = existing->in_addr;
 
                /* Copy state for logging below. */
                tmp->state = existing->state;
        }
 
        log_address_debug(tmp, "Requesting", link);
        r = link_queue_request_safe(link, REQUEST_TYPE_ADDRESS,
                                    tmp,
                                    address_unref,
                                    address_hash_func,
                                    address_compare_func,
                                    address_process_request,
                                    message_counter, netlink_handler, ret);
        if (r < 0)
                return log_link_warning_errno(link, r, "Failed to request address: %m");
        if (r == 0)
                return 0;
 
        address_enter_requesting(tmp);
        if (existing)
                address_enter_requesting(existing);
 
        TAKE_PTR(tmp);
        return 1;
}
 
static int static_address_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, Address *address) {
        int r;
 
        assert(link);
        assert(address);
 
        r = address_configure_handler_internal(m, link, address);
        if (r <= 0)
                return r;
 
        if (link->static_address_messages == 0) {
                log_link_debug(link, "Addresses set");
                link->static_addresses_configured = true;
                link_check_ready(link);
        }
 
        return 1;
}
 
int link_request_static_address(Link *link, const Address *address) {
        assert(link);
        assert(address);
        assert(address->source == NETWORK_CONFIG_SOURCE_STATIC);
 
        return link_request_address(link, address, &link->static_address_messages,
                                    static_address_handler, NULL);
}
 
int link_request_static_addresses(Link *link) {
        Address *a;
        int r;
 
        assert(link);
        assert(link->network);
 
        link->static_addresses_configured = false;
 
        ORDERED_HASHMAP_FOREACH(a, link->network->addresses_by_section) {
                r = link_request_static_address(link, a);
                if (r < 0)
                        return r;
        }
 
        r = link_request_radv_addresses(link);
        if (r < 0)
                return r;
 
        if (link->static_address_messages == 0) {
                link->static_addresses_configured = true;
                link_check_ready(link);
        } else {
                log_link_debug(link, "Setting addresses");
                link_set_state(link, LINK_STATE_CONFIGURING);
        }
 
        return 0;
}
 
int manager_rtnl_process_address(sd_netlink *rtnl, sd_netlink_message *message, Manager *m) {
        int r;
 
        assert(rtnl);
        assert(message);
        assert(m);
 
        if (sd_netlink_message_is_error(message)) {
                r = sd_netlink_message_get_errno(message);
                if (r < 0)
                        log_message_warning_errno(message, r, "rtnl: failed to receive address message, ignoring");
 
                return 0;
        }
 
        uint16_t type;
        r = sd_netlink_message_get_type(message, &type);
        if (r < 0) {
                log_warning_errno(r, "rtnl: could not get message type, ignoring: %m");
                return 0;
        } else if (!IN_SET(type, RTM_NEWADDR, RTM_DELADDR)) {
                log_warning("rtnl: received unexpected message type %u when processing address, ignoring.", type);
                return 0;
        }
 
        int ifindex;
        r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
        if (r < 0) {
                log_warning_errno(r, "rtnl: could not get ifindex from message, ignoring: %m");
                return 0;
        } else if (ifindex <= 0) {
                log_warning("rtnl: received address message with invalid ifindex %d, ignoring.", ifindex);
                return 0;
        }
 
        Link *link;
        r = link_get_by_index(m, ifindex, &link);
        if (r < 0) {
                /* when enumerating we might be out of sync, but we will get the address again, so just
                 * ignore it */
                if (!m->enumerating)
                        log_warning("rtnl: received address for link '%d' we don't know about, ignoring.", ifindex);
                return 0;
        }
 
        _cleanup_(address_unrefp) Address *tmp = NULL;
        r = address_new(&tmp);
        if (r < 0)
                return log_oom();
 
        /* First, read minimal information to make address_get() work below. */
 
        r = sd_rtnl_message_addr_get_family(message, &tmp->family);
        if (r < 0) {
                log_link_warning(link, "rtnl: received address message without family, ignoring.");
                return 0;
        } else if (!IN_SET(tmp->family, AF_INET, AF_INET6)) {
                log_link_debug(link, "rtnl: received address message with invalid family '%i', ignoring.", tmp->family);
                return 0;
        }
 
        r = sd_rtnl_message_addr_get_prefixlen(message, &tmp->prefixlen);
        if (r < 0) {
                log_link_warning_errno(link, r, "rtnl: received address message without prefixlen, ignoring: %m");
                return 0;
        }
 
        switch (tmp->family) {
        case AF_INET:
                r = sd_netlink_message_read_in_addr(message, IFA_LOCAL, &tmp->in_addr.in);
                if (r < 0) {
                        log_link_warning_errno(link, r, "rtnl: received address message without valid address, ignoring: %m");
                        return 0;
                }
 
                r = sd_netlink_message_read_in_addr(message, IFA_ADDRESS, &tmp->in_addr_peer.in);
                if (r < 0 && r != -ENODATA) {
                        log_link_warning_errno(link, r, "rtnl: could not get peer address from address message, ignoring: %m");
                        return 0;
                } else if (r >= 0) {
                        if (in4_addr_equal(&tmp->in_addr.in, &tmp->in_addr_peer.in))
                                tmp->in_addr_peer = IN_ADDR_NULL;
                }
 
                break;
 
        case AF_INET6:
                r = sd_netlink_message_read_in6_addr(message, IFA_LOCAL, &tmp->in_addr.in6);
                if (r >= 0) {
                        /* Have peer address. */
                        r = sd_netlink_message_read_in6_addr(message, IFA_ADDRESS, &tmp->in_addr_peer.in6);
                        if (r < 0) {
                                log_link_warning_errno(link, r, "rtnl: could not get peer address from address message, ignoring: %m");
                                return 0;
                        }
                } else if (r == -ENODATA) {
                        /* Does not have peer address. */
                        r = sd_netlink_message_read_in6_addr(message, IFA_ADDRESS, &tmp->in_addr.in6);
                        if (r < 0) {
                                log_link_warning_errno(link, r, "rtnl: received address message without valid address, ignoring: %m");
                                return 0;
                        }
                } else {
                        log_link_warning_errno(link, r, "rtnl: could not get local address from address message, ignoring: %m");
                        return 0;
                }
 
                break;
 
        default:
                assert_not_reached();
        }
 
        /* Then, find the managed Address object corresponding to the received address. */
        Address *address = NULL;
        (void) address_get(link, tmp, &address);
 
        if (type == RTM_DELADDR) {
                if (address)
                        address_forget(link, address,
                                       /* removed_by_us= */ FLAGS_SET(address->state, NETWORK_CONFIG_STATE_REMOVING),
                                       "Forgetting removed");
                else
                        log_address_debug(tmp, "Kernel removed unknown", link);
 
                goto finalize;
        }
 
        bool is_new = false;
        if (!address) {
                /* If we did not know the address, then save it. */
                r = address_attach(link, tmp);
                if (r < 0) {
                        log_link_warning_errno(link, r, "Failed to save received address %s, ignoring: %m",
                                               IN_ADDR_PREFIX_TO_STRING(tmp->family, &tmp->in_addr, tmp->prefixlen));
                        return 0;
                }
                address = tmp;
 
                is_new = true;