}
static void static_address_on_acd(sd_ipv4acd *acd, int event, void *userdata) {
- _cleanup_free_ char *pretty = NULL;
Address *address;
Link *link;
int r;
address = (Address *) userdata;
link = address->link;
- (void) in_addr_to_string(address->family, &address->in_addr, &pretty);
+ assert(address->family == AF_INET);
+
switch (event) {
case SD_IPV4ACD_EVENT_STOP:
log_link_debug(link, "Stopping ACD client...");
return;
case SD_IPV4ACD_EVENT_BIND:
- log_link_debug(link, "Successfully claimed address %s", strna(pretty));
+ log_link_debug(link, "Successfully claimed address "IPV4_ADDRESS_FMT_STR,
+ IPV4_ADDRESS_FMT_VAL(address->in_addr.in));
link_check_ready(link);
break;
case SD_IPV4ACD_EVENT_CONFLICT:
- log_link_warning(link, "DAD conflict. Dropping address %s", strna(pretty));
+ log_link_warning(link, "DAD conflict. Dropping address "IPV4_ADDRESS_FMT_STR,
+ IPV4_ADDRESS_FMT_VAL(address->in_addr.in));
r = address_remove(address, link, NULL);
if (r < 0)
- log_link_error_errno(link, r, "Failed to drop DAD conflicted address %s", strna(pretty));;
+ log_link_error_errno(link, r, "Failed to drop DAD conflicted address "IPV4_ADDRESS_FMT_STR,
+ IPV4_ADDRESS_FMT_VAL(address->in_addr.in));
link_check_ready(link);
break;
if (address->family != AF_INET)
return 0;
- if (DEBUG_LOGGING) {
- _cleanup_free_ char *pretty = NULL;
-
- (void) in_addr_to_string(address->family, &address->in_addr, &pretty);
- log_link_debug(address->link, "Starting IPv4ACD client. Probing address %s", strna(pretty));
- }
+ log_address_debug(address, "Starting IPv4ACD client. Probing", address->link);
if (!address->acd) {
r = sd_ipv4acd_new(&address->acd);
}
static void dhcp_address_on_acd(sd_ipv4acd *acd, int event, void *userdata) {
- _cleanup_free_ char *pretty = NULL;
- union in_addr_union address = {};
+ struct in_addr address;
Link *link;
int r;
switch (event) {
case SD_IPV4ACD_EVENT_STOP:
- log_link_debug(link, "Stopping ACD client for DHCP4...");
+ log_link_debug(link, "Stopping ACD client for DHCPv4 address.");
return;
case SD_IPV4ACD_EVENT_BIND:
if (DEBUG_LOGGING) {
- (void) sd_dhcp_lease_get_address(link->dhcp_lease, &address.in);
- (void) in_addr_to_string(AF_INET, &address, &pretty);
- log_link_debug(link, "Successfully claimed DHCP4 address %s", strna(pretty));
+ (void) sd_dhcp_lease_get_address(link->dhcp_lease, &address);
+ log_link_debug(link, "Successfully claimed DHCPv4 address "IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(address));
}
link->dhcp4_address_bind = true;
dhcp4_check_ready(link);
break;
case SD_IPV4ACD_EVENT_CONFLICT:
- (void) sd_dhcp_lease_get_address(link->dhcp_lease, &address.in);
- (void) in_addr_to_string(AF_INET, &address, &pretty);
- log_link_warning(link, "DAD conflict. Dropping DHCP4 address %s", strna(pretty));
+ (void) sd_dhcp_lease_get_address(link->dhcp_lease, &address);
+ log_link_warning(link, "DAD conflict. Dropping DHCPv4 address "IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(address));
r = sd_dhcp_client_send_decline(link->dhcp_client);
if (r < 0)
}
static int dhcp4_start_acd(Link *link) {
- union in_addr_union addr;
- struct in_addr old;
+ struct in_addr addr, old;
int r;
if (!link->network->dhcp_send_decline)
link->dhcp4_address_bind = false;
- r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr.in);
+ r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
if (r < 0)
return r;
if (r < 0)
return r;
- r = sd_ipv4acd_set_address(link->dhcp_acd, &addr.in);
+ r = sd_ipv4acd_set_address(link->dhcp_acd, &addr);
if (r < 0)
return r;
if (r < 0)
return r;
- if (DEBUG_LOGGING) {
- _cleanup_free_ char *pretty = NULL;
-
- (void) in_addr_to_string(AF_INET, &addr, &pretty);
- log_link_debug(link, "Starting IPv4ACD client. Probing DHCPv4 address %s", strna(pretty));
- }
+ log_link_debug(link, "Starting IPv4ACD client. Probing DHCPv4 address "IPV4_ADDRESS_FMT_STR,
+ IPV4_ADDRESS_FMT_VAL(addr));
- r = sd_ipv4acd_start(link->dhcp_acd, !in4_addr_equal(&addr.in, &old));
- if (r < 0)
- return r;
-
- return 1;
+ return sd_ipv4acd_start(link->dhcp_acd, !in4_addr_equal(&addr, &old));
}
static int dhcp4_address_ready_callback(Address *address) {
static bool dhcp6_lease_has_pd_prefix(sd_dhcp6_lease *lease) {
uint32_t lifetime_preferred, lifetime_valid;
- union in_addr_union pd_prefix;
+ struct in6_addr pd_prefix;
uint8_t pd_prefix_len;
if (!lease)
sd_dhcp6_lease_reset_pd_prefix_iter(lease);
- return sd_dhcp6_lease_get_pd(lease, &pd_prefix.in6, &pd_prefix_len, &lifetime_preferred, &lifetime_valid) >= 0;
+ return sd_dhcp6_lease_get_pd(lease, &pd_prefix, &pd_prefix_len, &lifetime_preferred, &lifetime_valid) >= 0;
}
DHCP6DelegatedPrefix *dhcp6_pd_free(DHCP6DelegatedPrefix *p) {
DEFINE_HASH_OPS(dhcp6_pd_hash_ops, DHCP6DelegatedPrefix, dhcp6_pd_hash_func, dhcp6_pd_compare_func);
-static Link *dhcp6_pd_get_link_by_prefix(Link *link, const union in_addr_union *prefix) {
+static Link *dhcp6_pd_get_link_by_prefix(Link *link, const struct in6_addr *prefix) {
DHCP6DelegatedPrefix *pd;
assert(link);
assert(link->manager);
assert(prefix);
- pd = hashmap_get(link->manager->dhcp6_prefixes, &prefix->in6);
+ pd = hashmap_get(link->manager->dhcp6_prefixes, prefix);
if (!pd)
return NULL;
return pd->link;
}
-static int dhcp6_pd_get_assigned_prefix(Link *link, const union in_addr_union *pd_prefix, union in_addr_union *ret_prefix) {
+static int dhcp6_pd_get_assigned_prefix(Link *link, const struct in6_addr *pd_prefix, struct in6_addr *ret_prefix) {
DHCP6DelegatedPrefix *pd, in;
assert(link);
assert(ret_prefix);
in = (DHCP6DelegatedPrefix) {
- .pd_prefix = pd_prefix->in6,
+ .pd_prefix = *pd_prefix,
.link = link,
};
if (!pd)
return -ENOENT;
- ret_prefix->in6 = pd->prefix;
+ *ret_prefix = pd->prefix;
return 0;
}
return 1;
}
-static int dhcp6_set_pd_route(Link *link, const union in_addr_union *prefix, const union in_addr_union *pd_prefix) {
+static int dhcp6_set_pd_route(Link *link, const struct in6_addr *prefix, const struct in6_addr *pd_prefix) {
_cleanup_(dhcp6_pd_freep) DHCP6DelegatedPrefix *pd = NULL;
_cleanup_(route_freep) Route *route = NULL;
Link *assigned_link;
return r;
route->family = AF_INET6;
- route->dst = *prefix;
+ route->dst.in6 = *prefix;
route->dst_prefixlen = 64;
route->protocol = RTPROT_DHCP;
route->priority = link->network->dhcp6_pd_route_metric;
return log_oom();
*pd = (DHCP6DelegatedPrefix) {
- .prefix = prefix->in6,
- .pd_prefix = pd_prefix->in6,
+ .prefix = *prefix,
+ .pd_prefix = *pd_prefix,
.link = link_ref(link),
};
_cleanup_free_ char *buffer = NULL;
int log_level;
+ assert(address);
+ assert(address->family == AF_INET6);
+
log_level = address_get(link, address, NULL) >= 0 ? LOG_DEBUG : LOG_INFO;
if (log_level < log_get_max_level())
return;
- (void) in_addr_prefix_to_string(address->family, &address->in_addr, address->prefixlen, &buffer);
+ (void) in6_addr_prefix_to_string(&address->in_addr.in6, address->prefixlen, &buffer);
if (address->cinfo.ifa_valid != CACHE_INFO_INFINITY_LIFE_TIME)
valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
address->cinfo.ifa_valid * USEC_PER_SEC,
static int dhcp6_set_pd_address(
Link *link,
- const union in_addr_union *prefix,
+ const struct in6_addr *prefix,
uint32_t lifetime_preferred,
uint32_t lifetime_valid) {
if (r < 0)
return log_link_error_errno(link, r, "Failed to allocate address for DHCPv6 delegated prefix: %m");
- address->in_addr = *prefix;
+ address->in_addr.in6 = *prefix;
- if (in_addr_is_set(AF_INET6, &link->network->dhcp6_pd_token))
- memcpy(address->in_addr.in6.s6_addr + 8, link->network->dhcp6_pd_token.in6.s6_addr + 8, 8);
+ if (in6_addr_is_set(&link->network->dhcp6_pd_token))
+ memcpy(address->in_addr.in6.s6_addr + 8, link->network->dhcp6_pd_token.s6_addr + 8, 8);
else {
r = generate_ipv6_eui_64_address(link, &address->in_addr.in6);
if (r < 0)
static int dhcp6_pd_assign_prefix(
Link *link,
- const union in_addr_union *prefix,
- const union in_addr_union *pd_prefix,
+ const struct in6_addr *prefix,
+ const struct in6_addr *pd_prefix,
uint32_t lifetime_preferred,
uint32_t lifetime_valid) {
assert(prefix);
if (link->network->dhcp6_pd_announce) {
- r = radv_add_prefix(link, &prefix->in6, 64, lifetime_preferred, lifetime_valid);
+ r = radv_add_prefix(link, prefix, 64, lifetime_preferred, lifetime_valid);
if (r < 0)
return r;
}
static int dhcp6_get_preferred_delegated_prefix(
Link *link,
- const union in_addr_union *masked_pd_prefix,
+ const struct in6_addr *masked_pd_prefix,
uint8_t pd_prefix_len,
- union in_addr_union *ret) {
+ struct in6_addr *ret) {
/* We start off with the original PD prefix we have been assigned and iterate from there */
union in_addr_union prefix;
assert(pd_prefix_len <= 64);
n_prefixes = UINT64_C(1) << (64 - pd_prefix_len);
- prefix = *masked_pd_prefix;
+ prefix.in6 = *masked_pd_prefix;
if (link_has_preferred_subnet_id(link)) {
uint64_t subnet_id = link->network->dhcp6_pd_subnet_id;
/* Verify that the prefix we did calculate fits in the pd prefix.
* This should not fail as we checked the prefix size beforehand */
- assert_se(in_addr_prefix_covers(AF_INET6, masked_pd_prefix, pd_prefix_len, &prefix) > 0);
+ assert_se(in_addr_prefix_covers(AF_INET6, (const union in_addr_union*) masked_pd_prefix, pd_prefix_len, &prefix) > 0);
- assigned_link = dhcp6_pd_get_link_by_prefix(link, &prefix);
+ assigned_link = dhcp6_pd_get_link_by_prefix(link, &prefix.in6);
if (assigned_link && assigned_link != link) {
_cleanup_free_ char *assigned_buf = NULL;
- (void) in_addr_to_string(AF_INET6, &prefix, &assigned_buf);
+ (void) in6_addr_to_string(&prefix.in6, &assigned_buf);
return log_link_warning_errno(link, SYNTHETIC_ERRNO(EAGAIN),
"The requested prefix %s is already assigned to another link.",
strna(assigned_buf));
}
- *ret = prefix;
+ *ret = prefix.in6;
return 0;
}
for (uint64_t n = 0; n < n_prefixes; n++) {
/* If we do not have an allocation preference just iterate
* through the address space and return the first free prefix. */
- assigned_link = dhcp6_pd_get_link_by_prefix(link, &prefix);
+ assigned_link = dhcp6_pd_get_link_by_prefix(link, &prefix.in6);
if (!assigned_link || assigned_link == link) {
- *ret = prefix;
+ *ret = prefix.in6;
return 0;
}
}
static void dhcp6_pd_prefix_distribute(Link *dhcp6_link,
- const union in_addr_union *masked_pd_prefix,
+ const struct in6_addr *masked_pd_prefix,
uint8_t pd_prefix_len,
uint32_t lifetime_preferred,
uint32_t lifetime_valid,
HASHMAP_FOREACH(link, dhcp6_link->manager->links) {
_cleanup_free_ char *assigned_buf = NULL;
- union in_addr_union assigned_prefix;
+ struct in6_addr assigned_prefix;
if (link == dhcp6_link)
continue;
}
}
- (void) in_addr_to_string(AF_INET6, &assigned_prefix, &assigned_buf);
+ (void) in6_addr_to_string(&assigned_prefix, &assigned_buf);
r = dhcp6_pd_assign_prefix(link, &assigned_prefix, masked_pd_prefix,
lifetime_preferred, lifetime_valid);
if (r < 0) {
return 1;
}
-static int dhcp6_set_unreachable_route(Link *link, const union in_addr_union *addr, uint8_t prefixlen) {
+static int dhcp6_set_unreachable_route(Link *link, const struct in6_addr *addr, uint8_t prefixlen) {
_cleanup_(route_freep) Route *route = NULL;
_cleanup_free_ char *buf = NULL;
Route *ret;
assert(link);
assert(addr);
- (void) in_addr_prefix_to_string(AF_INET6, addr, prefixlen, &buf);
+ (void) in6_addr_prefix_to_string(addr, prefixlen, &buf);
if (prefixlen == 64) {
log_link_debug(link, "Not adding a blocking route for DHCPv6 delegated subnet %s since distributed prefix is 64",
return log_oom();
route->family = AF_INET6;
- route->dst = *addr;
+ route->dst.in6 = *addr;
route->dst_prefixlen = prefixlen;
route->table = link_get_dhcp_route_table(link);
route->type = RTN_UNREACHABLE;
return 0;
}
-static int dhcp6_pd_prefix_add(Link *link, const union in_addr_union *prefix, uint8_t prefixlen) {
+static int dhcp6_pd_prefix_add(Link *link, const struct in6_addr *prefix, uint8_t prefixlen) {
_cleanup_free_ struct in_addr_prefix *p = NULL;
_cleanup_free_ char *buf = NULL;
int r;
*p = (struct in_addr_prefix) {
.family = AF_INET6,
.prefixlen = prefixlen,
- .address = *prefix,
+ .address.in6 = *prefix,
};
- (void) in_addr_prefix_to_string(p->family, &p->address, p->prefixlen, &buf);
+ (void) in6_addr_prefix_to_string(prefix, prefixlen, &buf);
log_link_full(link,
set_contains(link->dhcp6_pd_prefixes, p) ? LOG_DEBUG :
for (sd_dhcp6_lease_reset_pd_prefix_iter(dhcp6_link->dhcp6_lease);;) {
uint32_t lifetime_preferred, lifetime_valid;
- union in_addr_union pd_prefix, prefix;
+ struct in6_addr pd_prefix;
+ union in_addr_union prefix;
uint8_t pd_prefix_len;
- r = sd_dhcp6_lease_get_pd(dhcp6_link->dhcp6_lease, &pd_prefix.in6, &pd_prefix_len,
+ r = sd_dhcp6_lease_get_pd(dhcp6_link->dhcp6_lease, &pd_prefix, &pd_prefix_len,
&lifetime_preferred, &lifetime_valid);
if (r < 0)
break;
assert(pd_prefix_len <= 64);
- prefix = pd_prefix;
+ prefix.in6 = pd_prefix;
r = in_addr_mask(AF_INET6, &prefix, pd_prefix_len);
if (r < 0)
return log_link_error_errno(dhcp6_link, r, "Failed to mask DHCPv6 PD prefix: %m");
uint64_t n_prefixes = UINT64_C(1) << (64 - pd_prefix_len);
_cleanup_free_ char *buf = NULL;
- (void) in_addr_prefix_to_string(AF_INET6, &prefix, pd_prefix_len, &buf);
+ (void) in6_addr_prefix_to_string(&prefix.in6, pd_prefix_len, &buf);
log_link_debug(dhcp6_link, "Assigning up to %" PRIu64 " prefixes from %s",
n_prefixes, strna(buf));
}
dhcp6_pd_prefix_distribute(dhcp6_link,
- &prefix,
+ &prefix.in6,
pd_prefix_len,
lifetime_preferred,
lifetime_valid,
true);
dhcp6_pd_prefix_distribute(dhcp6_link,
- &prefix,
+ &prefix.in6,
pd_prefix_len,
lifetime_preferred,
lifetime_valid,
assert(link);
assert(address);
+ assert(address->family == AF_INET6);
- (void) in_addr_prefix_to_string(address->family, &address->in_addr, address->prefixlen, &buffer);
+ (void) in6_addr_prefix_to_string(&address->in_addr.in6, address->prefixlen, &buffer);
if (address->cinfo.ifa_valid != CACHE_INFO_INFINITY_LIFE_TIME)
valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
address->cinfo.ifa_valid * USEC_PER_SEC,
void *data,
void *userdata) {
- union in_addr_union *addr = data, tmp;
+ struct in6_addr *addr = data;
+ union in_addr_union tmp;
int r;
assert(filename);
assert(data);
if (isempty(rvalue)) {
- *addr = IN_ADDR_NULL;
+ *addr = (struct in6_addr) {};
return 0;
}
return 0;
}
- *addr = tmp;
+ *addr = tmp.in6;
return 0;
}
assert(address);
assert(address->link);
+ assert(address->family == AF_INET6);
SET_FOREACH(n, address->link->ndisc_addresses)
if (n->address == address) {
if (in6_addr_is_null(&router)) {
_cleanup_free_ char *buf = NULL;
- (void) in_addr_prefix_to_string(address->family, &address->in_addr, address->prefixlen, &buf);
+ (void) in6_addr_prefix_to_string(&address->in_addr.in6, address->prefixlen, &buf);
log_link_debug(address->link, "%s is called for %s, but it is already removed, ignoring.",
__func__, strna(buf));
return 0;
/* Make this called only once */
SET_FOREACH(n, address->link->ndisc_addresses)
- if (IN6_ARE_ADDR_EQUAL(&n->router, &router))
+ if (in6_addr_equal(&n->router, &router))
n->address->callback = NULL;
return ndisc_remove_old_one(address->link, &router, true);
return 0;
SET_FOREACH(na, link->ndisc_addresses)
- if (!na->marked && IN6_ARE_ADDR_EQUAL(&na->router, router)) {
+ if (!na->marked && in6_addr_equal(&na->router, router)) {
set_callback = true;
break;
}
if (set_callback) {
SET_FOREACH(na, link->ndisc_addresses)
- if (!na->marked && IN6_ARE_ADDR_EQUAL(&na->router, router))
+ if (!na->marked && in6_addr_equal(&na->router, router))
na->address->callback = ndisc_address_callback;
if (DEBUG_LOGGING) {
_cleanup_free_ char *buf = NULL;
- (void) in_addr_to_string(AF_INET6, (const union in_addr_union*) router, &buf);
+ (void) in6_addr_to_string(router, &buf);
log_link_debug(link, "No SLAAC address obtained from %s is ready. "
"The old NDisc information will be removed later.",
strna(buf));
if (DEBUG_LOGGING) {
_cleanup_free_ char *buf = NULL;
- (void) in_addr_to_string(AF_INET6, (const union in_addr_union*) router, &buf);
+ (void) in6_addr_to_string(router, &buf);
log_link_debug(link, "Removing old NDisc information obtained from %s.", strna(buf));
}
SET_FOREACH(na, link->ndisc_addresses)
- if (na->marked && IN6_ARE_ADDR_EQUAL(&na->router, router)) {
+ if (na->marked && in6_addr_equal(&na->router, router)) {
k = address_remove(na->address, link, NULL);
if (k < 0)
r = k;
}
SET_FOREACH(nr, link->ndisc_routes)
- if (nr->marked && IN6_ARE_ADDR_EQUAL(&nr->router, router)) {
+ if (nr->marked && in6_addr_equal(&nr->router, router)) {
k = route_remove(nr->route, NULL, link, NULL);
if (k < 0)
r = k;
}
SET_FOREACH(rdnss, link->ndisc_rdnss)
- if (rdnss->marked && IN6_ARE_ADDR_EQUAL(&rdnss->router, router)) {
+ if (rdnss->marked && in6_addr_equal(&rdnss->router, router)) {
free(set_remove(link->ndisc_rdnss, rdnss));
updated = true;
}
SET_FOREACH(dnssl, link->ndisc_dnssl)
- if (dnssl->marked && IN6_ARE_ADDR_EQUAL(&dnssl->router, router)) {
+ if (dnssl->marked && in6_addr_equal(&dnssl->router, router)) {
free(set_remove(link->ndisc_dnssl, dnssl));
updated = true;
}
static int ndisc_router_process_default(Link *link, sd_ndisc_router *rt) {
_cleanup_(route_freep) Route *route = NULL;
- union in_addr_union gateway;
+ struct in6_addr gateway;
uint16_t lifetime;
unsigned preference;
uint32_t table, mtu;
if (lifetime == 0) /* not a default router */
return 0;
- r = sd_ndisc_router_get_address(rt, &gateway.in6);
+ r = sd_ndisc_router_get_address(rt, &gateway);
if (r < 0)
return log_link_error_errno(link, r, "Failed to get gateway address from RA: %m");
- if (link_has_ipv6_address(link, &gateway.in6) > 0) {
+ if (link_has_ipv6_address(link, &gateway) > 0) {
if (DEBUG_LOGGING) {
_cleanup_free_ char *buffer = NULL;
- (void) in_addr_to_string(AF_INET6, &gateway, &buffer);
+ (void) in6_addr_to_string(&gateway, &buffer);
log_link_debug(link, "No NDisc route added, gateway %s matches local address",
- strnull(buffer));
+ strna(buffer));
}
return 0;
}
route->protocol = RTPROT_RA;
route->pref = preference;
route->gw_family = AF_INET6;
- route->gw = gateway;
+ route->gw.in6 = gateway;
route->lifetime = usec_add(time_now, lifetime * USEC_PER_SEC);
route->mtu = mtu;
if (route_gw->gw_family != AF_INET6)
continue;
- route_gw->gw = gateway;
+ route_gw->gw.in6 = gateway;
if (!route_gw->table_set)
route_gw->table = table;
if (!route_gw->priority_set)
_cleanup_free_ struct in6_addr *new_address = NULL;
if (j->address_generation_type == IPV6_TOKEN_ADDRESS_GENERATION_PREFIXSTABLE
- && (in6_addr_is_null(&j->prefix) || IN6_ARE_ADDR_EQUAL(&j->prefix, address))) {
+ && (in6_addr_is_null(&j->prefix) || in6_addr_equal(&j->prefix, address))) {
/* While this loop uses dad_counter and a retry limit as specified in RFC 7217, the loop
* does not actually attempt Duplicate Address Detection; the counter will be incremented
* only when the address generation algorithm produces an invalid address, and the loop
static int ndisc_router_process_route(Link *link, sd_ndisc_router *rt) {
_cleanup_(route_freep) Route *route = NULL;
- union in_addr_union gateway, dst;
+ struct in6_addr gateway, dst;
uint32_t lifetime;
unsigned preference, prefixlen;
usec_t time_now;
if (lifetime == 0)
return 0;
- r = sd_ndisc_router_route_get_address(rt, &dst.in6);
+ r = sd_ndisc_router_route_get_address(rt, &dst);
if (r < 0)
return log_link_error_errno(link, r, "Failed to get route address: %m");
if ((!set_isempty(link->network->ndisc_allow_listed_route_prefix) &&
- !set_contains(link->network->ndisc_allow_listed_route_prefix, &dst.in6)) ||
- set_contains(link->network->ndisc_deny_listed_route_prefix, &dst.in6)) {
+ !set_contains(link->network->ndisc_allow_listed_route_prefix, &dst)) ||
+ set_contains(link->network->ndisc_deny_listed_route_prefix, &dst)) {
if (DEBUG_LOGGING) {
_cleanup_free_ char *buf = NULL;
- (void) in_addr_to_string(AF_INET6, &dst, &buf);
+ (void) in6_addr_to_string(&dst, &buf);
if (!set_isempty(link->network->ndisc_allow_listed_route_prefix))
- log_link_debug(link, "Route prefix '%s' is not in allow list, ignoring", strnull(buf));
+ log_link_debug(link, "Route prefix '%s' is not in allow list, ignoring", strna(buf));
else
- log_link_debug(link, "Route prefix '%s' is in deny list, ignoring", strnull(buf));
+ log_link_debug(link, "Route prefix '%s' is in deny list, ignoring", strna(buf));
}
return 0;
}
- r = sd_ndisc_router_get_address(rt, &gateway.in6);
+ r = sd_ndisc_router_get_address(rt, &gateway);
if (r < 0)
return log_link_error_errno(link, r, "Failed to get gateway address from RA: %m");
- if (link_has_ipv6_address(link, &gateway.in6) > 0) {
+ if (link_has_ipv6_address(link, &gateway) > 0) {
if (DEBUG_LOGGING) {
_cleanup_free_ char *buf = NULL;
- (void) in_addr_to_string(AF_INET6, &gateway, &buf);
- log_link_debug(link, "Advertised route gateway, %s, is local to the link, ignoring route", strnull(buf));
+ (void) in6_addr_to_string(&gateway, &buf);
+ log_link_debug(link, "Advertised route gateway %s is local to the link, ignoring route", strna(buf));
}
return 0;
}
route->priority = link->network->ipv6_accept_ra_route_metric;
route->protocol = RTPROT_RA;
route->pref = preference;
- route->gw = gateway;
+ route->gw.in6 = gateway;
route->gw_family = AF_INET6;
- route->dst = dst;
+ route->dst.in6 = dst;
route->dst_prefixlen = prefixlen;
route->lifetime = usec_add(time_now, lifetime * USEC_PER_SEC);
return log_link_error_errno(link, n, "Failed to get RDNSS addresses: %m");
SET_FOREACH(rdnss, link->ndisc_rdnss)
- if (IN6_ARE_ADDR_EQUAL(&rdnss->router, &router))
+ if (in6_addr_equal(&rdnss->router, &router))
rdnss->marked = true;
if (lifetime == 0)
return log_link_error_errno(link, r, "Failed to get DNSSL addresses: %m");
SET_FOREACH(dnssl, link->ndisc_dnssl)
- if (IN6_ARE_ADDR_EQUAL(&dnssl->router, &router))
+ if (in6_addr_equal(&dnssl->router, &router))
dnssl->marked = true;
if (lifetime == 0)
switch (type) {
case SD_NDISC_OPTION_PREFIX_INFORMATION: {
- union in_addr_union a;
+ struct in6_addr a;
uint8_t flags;
- r = sd_ndisc_router_prefix_get_address(rt, &a.in6);
+ r = sd_ndisc_router_prefix_get_address(rt, &a);
if (r < 0)
return log_link_error_errno(link, r, "Failed to get prefix address: %m");
if ((!set_isempty(link->network->ndisc_allow_listed_prefix) &&
- !set_contains(link->network->ndisc_allow_listed_prefix, &a.in6)) ||
- set_contains(link->network->ndisc_deny_listed_prefix, &a.in6)) {
+ !set_contains(link->network->ndisc_allow_listed_prefix, &a)) ||
+ set_contains(link->network->ndisc_deny_listed_prefix, &a)) {
if (DEBUG_LOGGING) {
_cleanup_free_ char *b = NULL;
- (void) in_addr_to_string(AF_INET6, &a, &b);
+ (void) in6_addr_to_string(&a, &b);
if (!set_isempty(link->network->ndisc_allow_listed_prefix))
log_link_debug(link, "Prefix '%s' is not in allow list, ignoring", strna(b));
else
}
static int ndisc_router_handler(Link *link, sd_ndisc_router *rt) {
- union in_addr_union router;
+ struct in6_addr router;
uint64_t flags;
NDiscAddress *na;
NDiscRoute *nr;
assert(link->manager);
assert(rt);
- r = sd_ndisc_router_get_address(rt, &router.in6);
+ r = sd_ndisc_router_get_address(rt, &router);
if (r < 0)
return log_link_error_errno(link, r, "Failed to get router address from RA: %m");
if ((!set_isempty(link->network->ndisc_allow_listed_router) &&
- !set_contains(link->network->ndisc_allow_listed_router, &router.in6)) ||
- set_contains(link->network->ndisc_deny_listed_router, &router.in6)) {
+ !set_contains(link->network->ndisc_allow_listed_router, &router)) ||
+ set_contains(link->network->ndisc_deny_listed_router, &router)) {
if (DEBUG_LOGGING) {
_cleanup_free_ char *buf = NULL;
- (void) in_addr_to_string(AF_INET6, &router, &buf);
+ (void) in6_addr_to_string(&router, &buf);
if (!set_isempty(link->network->ndisc_allow_listed_router))
log_link_debug(link, "Router '%s' is not in allow list, ignoring", strna(buf));
else
}
SET_FOREACH(na, link->ndisc_addresses)
- if (IN6_ARE_ADDR_EQUAL(&na->router, &router.in6))
+ if (in6_addr_equal(&na->router, &router))
na->marked = true;
SET_FOREACH(nr, link->ndisc_routes)
- if (IN6_ARE_ADDR_EQUAL(&nr->router, &router.in6))
+ if (in6_addr_equal(&nr->router, &router))
nr->marked = true;
r = sd_ndisc_router_get_flags(rt, &flags);
bool dhcp6_pd_manage_temporary_address;
int64_t dhcp6_pd_subnet_id;
uint32_t dhcp6_pd_route_metric;
- union in_addr_union dhcp6_pd_token;
+ struct in6_addr dhcp6_pd_token;
/* Bridge Support */
int use_bpdu;
projects / thirdparty / systemd.git / commitdiff
