HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/network/networkd-address.c
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;