GitHub-Mirror/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd synced 2025-10-06 00:13:24 +02:00
Code Issues Releases Wiki Activity

test: allow to run test-local-addresses with IPv6 disabled by default, and assume RTA_VIA is always supported (#38039)

Browse Source
This commit is contained in:
Luca Boccassi
2025-07-03 09:58:02 +01:00
committed by GitHub
parent 34af1513d0 3d38732179
commit a63f0ea73d
2 changed files with 161 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

327
src/test/test-local-addresses.c
View File

@@ -10,10 +10,9 @@
#include "in-addr-util.h"
#include "local-addresses.h"
#include "netlink-util.h"
#include "sysctl-util.h"
#include "tests.h"
static bool support_rta_via = false;
static void print_local_addresses(const struct local_address *a, size_t n) {
FOREACH_ARRAY(i, a, n)
log_debug("%s ifindex=%i scope=%u priority=%"PRIu32" weight=%"PRIu32" address=%s",
@@ -25,50 +24,42 @@ TEST(local_addresses) {
struct local_address *a = NULL;
int n;
n = local_addresses(NULL, 0, AF_INET, &a);
assert_se(n >= 0);
ASSERT_OK(n = local_addresses(NULL, 0, AF_INET, &a));
log_debug("/* Local Addresses(ifindex:0, AF_INET) */");
print_local_addresses(a, n);
a = mfree(a);
n = local_addresses(NULL, 0, AF_INET6, &a);
assert_se(n >= 0);
ASSERT_OK(n = local_addresses(NULL, 0, AF_INET6, &a));
log_debug("/* Local Addresses(ifindex:0, AF_INET6) */");
print_local_addresses(a, n);
a = mfree(a);
n = local_addresses(NULL, 0, AF_UNSPEC, &a);
assert_se(n >= 0);
ASSERT_OK(n = local_addresses(NULL, 0, AF_UNSPEC, &a));
log_debug("/* Local Addresses(ifindex:0, AF_UNSPEC) */");
print_local_addresses(a, n);
a = mfree(a);
n = local_addresses(NULL, 1, AF_INET, &a);
assert_se(n >= 0);
ASSERT_OK(n = local_addresses(NULL, 1, AF_INET, &a));
log_debug("/* Local Addresses(ifindex:1, AF_INET) */");
print_local_addresses(a, n);
a = mfree(a);
n = local_addresses(NULL, 1, AF_INET6, &a);
assert_se(n >= 0);
ASSERT_OK(n = local_addresses(NULL, 1, AF_INET6, &a));
log_debug("/* Local Addresses(ifindex:1, AF_INET6) */");
print_local_addresses(a, n);
a = mfree(a);
n = local_addresses(NULL, 1, AF_UNSPEC, &a);
assert_se(n >= 0);
ASSERT_OK(n = local_addresses(NULL, 1, AF_UNSPEC, &a));
log_debug("/* Local Addresses(ifindex:1, AF_UNSPEC) */");
print_local_addresses(a, n);
a = mfree(a);
n = local_gateways(NULL, 0, AF_UNSPEC, &a);
assert_se(n >= 0);
ASSERT_OK(n = local_gateways(NULL, 0, AF_UNSPEC, &a));
log_debug("/* Local Gateways */");
print_local_addresses(a, n);
a = mfree(a);
n = local_outbounds(NULL, 0, AF_UNSPEC, &a);
assert_se(n >= 0);
ASSERT_OK(n = local_outbounds(NULL, 0, AF_UNSPEC, &a));
log_debug("/* Local Outbounds */");
print_local_addresses(a, n);
free(a);
@@ -81,36 +72,38 @@ static void check_local_addresses(sd_netlink *rtnl, int ifindex, int request_ifi
log_debug("/* Local Addresses (ifindex:%i, %s) */", request_ifindex, family == AF_UNSPEC ? "AF_UNSPEC" : af_to_name(family));
n = local_addresses(rtnl, request_ifindex, family, &a);
assert_se(n >= 0);
ASSERT_OK(n = local_addresses(rtnl, request_ifindex, family, &a));
print_local_addresses(a, n);
assert_se(in_addr_from_string(AF_INET, "10.123.123.123", &u) >= 0);
assert_se(has_local_address(a, n,
ASSERT_OK(in_addr_from_string(AF_INET, "10.123.123.123", &u));
ASSERT_EQ(has_local_address(a, n,
&(struct local_address) {
.ifindex = ifindex,
.scope = RT_SCOPE_UNIVERSE,
.family = AF_INET,
.address = u,
}) == IN_SET(family, AF_UNSPEC, AF_INET));
}),
IN_SET(family, AF_UNSPEC, AF_INET));
assert_se(in_addr_from_string(AF_INET6, "2001:db8:0:123::123", &u) >= 0);
assert_se(has_local_address(a, n,
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:0:123::123", &u));
ASSERT_EQ(has_local_address(a, n,
&(struct local_address) {
.ifindex = ifindex,
.scope = RT_SCOPE_UNIVERSE,
.family = AF_INET6,
.address = u,
}) == IN_SET(family, AF_UNSPEC, AF_INET6));
}),
IN_SET(family, AF_UNSPEC, AF_INET6));
assert_se(in_addr_from_string(AF_INET6, "2001:db8:1:123::123", &u) >= 0);
assert_se(has_local_address(a, n,
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:1:123::123", &u));
ASSERT_EQ(has_local_address(a, n,
&(struct local_address) {
.ifindex = ifindex,
.scope = RT_SCOPE_UNIVERSE,
.family = AF_INET6,
.address = u,
}) == IN_SET(family, AF_UNSPEC, AF_INET6));
}),
IN_SET(family, AF_UNSPEC, AF_INET6));
}
static void check_local_gateways(sd_netlink *rtnl, int ifindex, int request_ifindex, int family) {
@@ -120,36 +113,38 @@ static void check_local_gateways(sd_netlink *rtnl, int ifindex, int request_ifin
log_debug("/* Local Gateways (ifindex:%i, %s) */", request_ifindex, family == AF_UNSPEC ? "AF_UNSPEC" : af_to_name(family));
n = local_gateways(rtnl, request_ifindex, family, &a);
assert_se(n >= 0);
ASSERT_OK(n = local_gateways(rtnl, request_ifindex, family, &a));
print_local_addresses(a, n);
assert_se(in_addr_from_string(AF_INET, "10.123.0.1", &u) >= 0);
assert_se(has_local_address(a, n,
ASSERT_OK(in_addr_from_string(AF_INET, "10.123.0.1", &u));
ASSERT_EQ(has_local_address(a, n,
&(struct local_address) {
.ifindex = ifindex,
.priority = 1234,
.family = AF_INET,
.address = u,
}) == IN_SET(family, AF_UNSPEC, AF_INET));
}),
IN_SET(family, AF_UNSPEC, AF_INET));
assert_se(in_addr_from_string(AF_INET6, "2001:db8:0:123::1", &u) >= 0);
assert_se(has_local_address(a, n,
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:0:123::1", &u));
ASSERT_EQ(has_local_address(a, n,
&(struct local_address) {
.ifindex = ifindex,
.priority = 1234,
.family = AF_INET6,
.address = u,
}) == (family == AF_UNSPEC && support_rta_via));
}),
family == AF_UNSPEC);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:1:123::1", &u) >= 0);
assert_se(has_local_address(a, n,
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:1:123::1", &u));
ASSERT_EQ(has_local_address(a, n,
&(struct local_address) {
.ifindex = ifindex,
.priority = 1234,
.family = AF_INET6,
.address = u,
}) == IN_SET(family, AF_UNSPEC, AF_INET6));
}),
IN_SET(family, AF_UNSPEC, AF_INET6));
}
static void check_local_outbounds(sd_netlink *rtnl, int ifindex, int request_ifindex, int family, const char *ipv6_expected) {
@@ -160,33 +155,35 @@ static void check_local_outbounds(sd_netlink *rtnl, int ifindex, int request_ifi
log_debug("/* Local Outbounds (ifindex:%i, %s, expected_ipv6_address=%s) */",
request_ifindex, family == AF_UNSPEC ? "AF_UNSPEC" : af_to_name(family), ipv6_expected);
n = local_outbounds(rtnl, request_ifindex, family, &a);
assert_se(n >= 0);
ASSERT_OK(n = local_outbounds(rtnl, request_ifindex, family, &a));
print_local_addresses(a, n);
assert_se(in_addr_from_string(AF_INET, "10.123.123.123", &u) >= 0);
assert_se(has_local_address(a, n,
ASSERT_OK(in_addr_from_string(AF_INET, "10.123.123.123", &u));
ASSERT_EQ(has_local_address(a, n,
&(struct local_address) {
.ifindex = ifindex,
.family = AF_INET,
.address = u,
}) == IN_SET(family, AF_UNSPEC, AF_INET));
}),
IN_SET(family, AF_UNSPEC, AF_INET));
assert_se(in_addr_from_string(AF_INET6, "2001:db8:0:123::123", &u) >= 0);
assert_se(has_local_address(a, n,
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:0:123::123", &u));
ASSERT_EQ(has_local_address(a, n,
&(struct local_address) {
.ifindex = ifindex,
.family = AF_INET6,
.address = u,
}) == (family == AF_UNSPEC && support_rta_via));
}),
family == AF_UNSPEC);
assert_se(in_addr_from_string(AF_INET6, ipv6_expected, &u) >= 0);
assert_se(has_local_address(a, n,
ASSERT_OK(in_addr_from_string(AF_INET6, ipv6_expected, &u));
ASSERT_EQ(has_local_address(a, n,
&(struct local_address) {
.ifindex = ifindex,
.family = AF_INET6,
.address = u,
}) == IN_SET(family, AF_UNSPEC, AF_INET6));
}),
IN_SET(family, AF_UNSPEC, AF_INET6));
}
TEST(local_addresses_with_dummy) {
@@ -195,108 +192,106 @@ TEST(local_addresses_with_dummy) {
union in_addr_union u;
int r, ifindex;
assert_se(sd_netlink_open(&rtnl) >= 0);
ASSERT_OK(sd_netlink_open(&rtnl));
/* Create a dummy interface */
assert_se(sd_rtnl_message_new_link(rtnl, &message, RTM_NEWLINK, 0) >= 0);
assert_se(sd_netlink_message_append_string(message, IFLA_IFNAME, "test-local-addr") >= 0);
assert_se(sd_netlink_message_open_container(message, IFLA_LINKINFO) >= 0);
assert_se(sd_netlink_message_append_string(message, IFLA_INFO_KIND, "dummy") >= 0);
ASSERT_OK(sd_rtnl_message_new_link(rtnl, &message, RTM_NEWLINK, 0));
ASSERT_OK(sd_netlink_message_append_string(message, IFLA_IFNAME, "test-local-addr"));
ASSERT_OK(sd_netlink_message_open_container(message, IFLA_LINKINFO));
ASSERT_OK(sd_netlink_message_append_string(message, IFLA_INFO_KIND, "dummy"));
r = sd_netlink_call(rtnl, message, 0, NULL);
if (r == -EPERM)
return (void) log_tests_skipped("missing required capabilities");
if (r == -EOPNOTSUPP)
return (void) log_tests_skipped("dummy network interface is not supported");
assert_se(r >= 0);
ASSERT_OK(r);
message = sd_netlink_message_unref(message);
/* Get ifindex */
assert_se(sd_rtnl_message_new_link(rtnl, &message, RTM_GETLINK, 0) >= 0);
assert_se(sd_netlink_message_append_string(message, IFLA_IFNAME, "test-local-addr") >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, &reply) >= 0);
assert_se(sd_rtnl_message_link_get_ifindex(reply, &ifindex) >= 0);
assert_se(ifindex > 0);
ASSERT_OK(sd_rtnl_message_new_link(rtnl, &message, RTM_GETLINK, 0));
ASSERT_OK(sd_netlink_message_append_string(message, IFLA_IFNAME, "test-local-addr"));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, &reply));
ASSERT_OK(sd_rtnl_message_link_get_ifindex(reply, &ifindex));
ASSERT_GT(ifindex, 0);
message = sd_netlink_message_unref(message);
reply = sd_netlink_message_unref(reply);
/* Enable IPv6 for the case that it is disabled by default. */
ASSERT_OK(sysctl_write_ip_property_boolean(AF_INET6, "test-local-addr", "disable_ipv6", false, /* shadow = */ NULL));
/* Bring the interface up */
assert_se(sd_rtnl_message_new_link(rtnl, &message, RTM_SETLINK, ifindex) >= 0);
assert_se(sd_rtnl_message_link_set_flags(message, IFF_UP, IFF_UP) >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, NULL) >= 0);
ASSERT_OK(sd_rtnl_message_new_link(rtnl, &message, RTM_SETLINK, ifindex));
ASSERT_OK(sd_rtnl_message_link_set_flags(message, IFF_UP, IFF_UP));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
/* Add an IPv4 address */
assert_se(sd_rtnl_message_new_addr_update(rtnl, &message, ifindex, AF_INET) >= 0);
assert_se(sd_rtnl_message_addr_set_scope(message, RT_SCOPE_UNIVERSE) >= 0);
assert_se(sd_rtnl_message_addr_set_prefixlen(message, 16) >= 0);
assert_se(in_addr_from_string(AF_INET, "10.123.123.123", &u) >= 0);
assert_se(sd_netlink_message_append_in_addr(message, IFA_LOCAL, &u.in) >= 0);
assert_se(in_addr_from_string(AF_INET, "10.123.255.255", &u) >= 0);
assert_se(sd_netlink_message_append_in_addr(message, IFA_BROADCAST, &u.in) >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, NULL) >= 0);
ASSERT_OK(sd_rtnl_message_new_addr_update(rtnl, &message, ifindex, AF_INET));
ASSERT_OK(sd_rtnl_message_addr_set_scope(message, RT_SCOPE_UNIVERSE));
ASSERT_OK(sd_rtnl_message_addr_set_prefixlen(message, 16));
ASSERT_OK(in_addr_from_string(AF_INET, "10.123.123.123", &u));
ASSERT_OK(sd_netlink_message_append_in_addr(message, IFA_LOCAL, &u.in));
ASSERT_OK(in_addr_from_string(AF_INET, "10.123.255.255", &u));
ASSERT_OK(sd_netlink_message_append_in_addr(message, IFA_BROADCAST, &u.in));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
/* Add IPv6 addresses */
assert_se(sd_rtnl_message_new_addr_update(rtnl, &message, ifindex, AF_INET6) >= 0);
assert_se(sd_rtnl_message_addr_set_scope(message, RT_SCOPE_UNIVERSE) >= 0);
assert_se(sd_rtnl_message_addr_set_prefixlen(message, 64) >= 0);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:0:123::123", &u) >= 0);
assert_se(sd_netlink_message_append_in6_addr(message, IFA_LOCAL, &u.in6) >= 0);
assert_se(sd_netlink_message_append_u32(message, IFA_FLAGS, IFA_F_NODAD) >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, NULL) >= 0);
ASSERT_OK(sd_rtnl_message_new_addr_update(rtnl, &message, ifindex, AF_INET6));
ASSERT_OK(sd_rtnl_message_addr_set_scope(message, RT_SCOPE_UNIVERSE));
ASSERT_OK(sd_rtnl_message_addr_set_prefixlen(message, 64));
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:0:123::123", &u));
ASSERT_OK(sd_netlink_message_append_in6_addr(message, IFA_LOCAL, &u.in6));
ASSERT_OK(sd_netlink_message_append_u32(message, IFA_FLAGS, IFA_F_NODAD));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
assert_se(sd_rtnl_message_new_addr_update(rtnl, &message, ifindex, AF_INET6) >= 0);
assert_se(sd_rtnl_message_addr_set_scope(message, RT_SCOPE_UNIVERSE) >= 0);
assert_se(sd_rtnl_message_addr_set_prefixlen(message, 64) >= 0);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:1:123::123", &u) >= 0);
assert_se(sd_netlink_message_append_in6_addr(message, IFA_LOCAL, &u.in6) >= 0);
assert_se(sd_netlink_message_append_u32(message, IFA_FLAGS, IFA_F_NODAD) >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, NULL) >= 0);
ASSERT_OK(sd_rtnl_message_new_addr_update(rtnl, &message, ifindex, AF_INET6));
ASSERT_OK(sd_rtnl_message_addr_set_scope(message, RT_SCOPE_UNIVERSE));
ASSERT_OK(sd_rtnl_message_addr_set_prefixlen(message, 64));
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:1:123::123", &u));
ASSERT_OK(sd_netlink_message_append_in6_addr(message, IFA_LOCAL, &u.in6));
ASSERT_OK(sd_netlink_message_append_u32(message, IFA_FLAGS, IFA_F_NODAD));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
/* Add an IPv4 default gateway (RTA_GATEWAY) */
assert_se(sd_rtnl_message_new_route(rtnl, &message, RTM_NEWROUTE, AF_INET, RTPROT_STATIC) >= 0);
assert_se(sd_rtnl_message_route_set_scope(message, RT_SCOPE_UNIVERSE) >= 0);
assert_se(sd_rtnl_message_route_set_type(message, RTN_UNICAST) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN) >= 0);
assert_se(in_addr_from_string(AF_INET, "10.123.0.1", &u) >= 0);
assert_se(sd_netlink_message_append_in_addr(message, RTA_GATEWAY, &u.in) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_OIF, ifindex) >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, NULL) >= 0);
ASSERT_OK(sd_rtnl_message_new_route(rtnl, &message, RTM_NEWROUTE, AF_INET, RTPROT_STATIC));
ASSERT_OK(sd_rtnl_message_route_set_scope(message, RT_SCOPE_UNIVERSE));
ASSERT_OK(sd_rtnl_message_route_set_type(message, RTN_UNICAST));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN));
ASSERT_OK(in_addr_from_string(AF_INET, "10.123.0.1", &u));
ASSERT_OK(sd_netlink_message_append_in_addr(message, RTA_GATEWAY, &u.in));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_OIF, ifindex));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
/* Add an IPv4 default gateway (RTA_VIA) */
assert_se(sd_rtnl_message_new_route(rtnl, &message, RTM_NEWROUTE, AF_INET, RTPROT_STATIC) >= 0);
assert_se(sd_rtnl_message_route_set_scope(message, RT_SCOPE_UNIVERSE) >= 0);
assert_se(sd_rtnl_message_route_set_type(message, RTN_UNICAST) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN) >= 0);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:0:123::1", &u) >= 0);
assert_se(sd_netlink_message_append_data(message, RTA_VIA,
ASSERT_OK(sd_rtnl_message_new_route(rtnl, &message, RTM_NEWROUTE, AF_INET, RTPROT_STATIC));
ASSERT_OK(sd_rtnl_message_route_set_scope(message, RT_SCOPE_UNIVERSE));
ASSERT_OK(sd_rtnl_message_route_set_type(message, RTN_UNICAST));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN));
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:0:123::1", &u));
ASSERT_OK(sd_netlink_message_append_data(message, RTA_VIA,
&(RouteVia) {
.family = AF_INET6,
.address = u,
}, sizeof(RouteVia)) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_OIF, ifindex) >= 0);
r = sd_netlink_call(rtnl, message, 0, NULL);
if (r == -EINVAL)
log_debug_errno(r, "RTA_VIA is not supported, ignoring: %m");
else
assert_se(r >= 0);
support_rta_via = r >= 0;
}, sizeof(RouteVia)));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_OIF, ifindex));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
/* Add an IPv6 default gateway */
assert_se(sd_rtnl_message_new_route(rtnl, &message, RTM_NEWROUTE, AF_INET6, RTPROT_STATIC) >= 0);
assert_se(sd_rtnl_message_route_set_type(message, RTN_UNICAST) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN) >= 0);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:1:123::1", &u) >= 0);
assert_se(sd_netlink_message_append_in6_addr(message, RTA_GATEWAY, &u.in6) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_OIF, ifindex) >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, NULL) >= 0);
ASSERT_OK(sd_rtnl_message_new_route(rtnl, &message, RTM_NEWROUTE, AF_INET6, RTPROT_STATIC));
ASSERT_OK(sd_rtnl_message_route_set_type(message, RTN_UNICAST));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN));
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:1:123::1", &u));
ASSERT_OK(sd_netlink_message_append_in6_addr(message, RTA_GATEWAY, &u.in6));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_OIF, ifindex));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
/* Check */
@@ -320,36 +315,36 @@ TEST(local_addresses_with_dummy) {
check_local_outbounds(rtnl, ifindex, ifindex, AF_INET6, "2001:db8:1:123::123");
/* Add one more IPv6 address. */
assert_se(sd_rtnl_message_new_addr_update(rtnl, &message, ifindex, AF_INET6) >= 0);
assert_se(sd_rtnl_message_addr_set_scope(message, RT_SCOPE_UNIVERSE) >= 0);
assert_se(sd_rtnl_message_addr_set_prefixlen(message, 64) >= 0);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:1:123::124", &u) >= 0);
assert_se(sd_netlink_message_append_in6_addr(message, IFA_LOCAL, &u.in6) >= 0);
assert_se(sd_netlink_message_append_u32(message, IFA_FLAGS, IFA_F_NODAD) >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, NULL) >= 0);
ASSERT_OK(sd_rtnl_message_new_addr_update(rtnl, &message, ifindex, AF_INET6));
ASSERT_OK(sd_rtnl_message_addr_set_scope(message, RT_SCOPE_UNIVERSE));
ASSERT_OK(sd_rtnl_message_addr_set_prefixlen(message, 64));
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:1:123::124", &u));
ASSERT_OK(sd_netlink_message_append_in6_addr(message, IFA_LOCAL, &u.in6));
ASSERT_OK(sd_netlink_message_append_u32(message, IFA_FLAGS, IFA_F_NODAD));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
/* Replace the previous IPv6 default gateway with one with preferred source address. */
assert_se(sd_rtnl_message_new_route(rtnl, &message, RTM_DELROUTE, AF_INET6, RTPROT_STATIC) >= 0);
assert_se(sd_rtnl_message_route_set_type(message, RTN_UNICAST) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN) >= 0);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:1:123::1", &u) >= 0);
assert_se(sd_netlink_message_append_in6_addr(message, RTA_GATEWAY, &u.in6) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_OIF, ifindex) >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, NULL) >= 0);
ASSERT_OK(sd_rtnl_message_new_route(rtnl, &message, RTM_DELROUTE, AF_INET6, RTPROT_STATIC));
ASSERT_OK(sd_rtnl_message_route_set_type(message, RTN_UNICAST));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN));
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:1:123::1", &u));
ASSERT_OK(sd_netlink_message_append_in6_addr(message, RTA_GATEWAY, &u.in6));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_OIF, ifindex));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
assert_se(sd_rtnl_message_new_route(rtnl, &message, RTM_NEWROUTE, AF_INET6, RTPROT_STATIC) >= 0);
assert_se(sd_rtnl_message_route_set_type(message, RTN_UNICAST) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN) >= 0);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:1:123::1", &u) >= 0);
assert_se(sd_netlink_message_append_in6_addr(message, RTA_GATEWAY, &u.in6) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_OIF, ifindex) >= 0);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:1:123::123", &u) >= 0);
assert_se(sd_netlink_message_append_in6_addr(message, RTA_PREFSRC, &u.in6) >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, NULL) >= 0);
ASSERT_OK(sd_rtnl_message_new_route(rtnl, &message, RTM_NEWROUTE, AF_INET6, RTPROT_STATIC));
ASSERT_OK(sd_rtnl_message_route_set_type(message, RTN_UNICAST));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN));
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:1:123::1", &u));
ASSERT_OK(sd_netlink_message_append_in6_addr(message, RTA_GATEWAY, &u.in6));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_OIF, ifindex));
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:1:123::123", &u));
ASSERT_OK(sd_netlink_message_append_in6_addr(message, RTA_PREFSRC, &u.in6));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
/* Check again. */
@@ -361,28 +356,28 @@ TEST(local_addresses_with_dummy) {
check_local_outbounds(rtnl, ifindex, ifindex, AF_INET6, "2001:db8:1:123::123");
/* Replace the preferred source address. */
assert_se(sd_rtnl_message_new_route(rtnl, &message, RTM_DELROUTE, AF_INET6, RTPROT_STATIC) >= 0);
assert_se(sd_rtnl_message_route_set_type(message, RTN_UNICAST) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN) >= 0);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:1:123::1", &u) >= 0);
assert_se(sd_netlink_message_append_in6_addr(message, RTA_GATEWAY, &u.in6) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_OIF, ifindex) >= 0);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:1:123::123", &u) >= 0);
assert_se(sd_netlink_message_append_in6_addr(message, RTA_PREFSRC, &u.in6) >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, NULL) >= 0);
ASSERT_OK(sd_rtnl_message_new_route(rtnl, &message, RTM_DELROUTE, AF_INET6, RTPROT_STATIC));
ASSERT_OK(sd_rtnl_message_route_set_type(message, RTN_UNICAST));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN));
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:1:123::1", &u));
ASSERT_OK(sd_netlink_message_append_in6_addr(message, RTA_GATEWAY, &u.in6));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_OIF, ifindex));
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:1:123::123", &u));
ASSERT_OK(sd_netlink_message_append_in6_addr(message, RTA_PREFSRC, &u.in6));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
assert_se(sd_rtnl_message_new_route(rtnl, &message, RTM_NEWROUTE, AF_INET6, RTPROT_STATIC) >= 0);
assert_se(sd_rtnl_message_route_set_type(message, RTN_UNICAST) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN) >= 0);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:1:123::1", &u) >= 0);
assert_se(sd_netlink_message_append_in6_addr(message, RTA_GATEWAY, &u.in6) >= 0);
assert_se(sd_netlink_message_append_u32(message, RTA_OIF, ifindex) >= 0);
assert_se(in_addr_from_string(AF_INET6, "2001:db8:1:123::124", &u) >= 0);
assert_se(sd_netlink_message_append_in6_addr(message, RTA_PREFSRC, &u.in6) >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, NULL) >= 0);
ASSERT_OK(sd_rtnl_message_new_route(rtnl, &message, RTM_NEWROUTE, AF_INET6, RTPROT_STATIC));
ASSERT_OK(sd_rtnl_message_route_set_type(message, RTN_UNICAST));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_PRIORITY, 1234));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_TABLE, RT_TABLE_MAIN));
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:1:123::1", &u));
ASSERT_OK(sd_netlink_message_append_in6_addr(message, RTA_GATEWAY, &u.in6));
ASSERT_OK(sd_netlink_message_append_u32(message, RTA_OIF, ifindex));
ASSERT_OK(in_addr_from_string(AF_INET6, "2001:db8:1:123::124", &u));
ASSERT_OK(sd_netlink_message_append_in6_addr(message, RTA_PREFSRC, &u.in6));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
/* Check again. */
@@ -394,8 +389,8 @@ TEST(local_addresses_with_dummy) {
check_local_outbounds(rtnl, ifindex, ifindex, AF_INET6, "2001:db8:1:123::124");
/* Cleanup */
assert_se(sd_rtnl_message_new_link(rtnl, &message, RTM_DELLINK, ifindex) >= 0);
assert_se(sd_netlink_call(rtnl, message, 0, NULL) >= 0);
ASSERT_OK(sd_rtnl_message_new_link(rtnl, &message, RTM_DELLINK, ifindex));
ASSERT_OK(sd_netlink_call(rtnl, message, 0, NULL));
message = sd_netlink_message_unref(message);
}

12
test/test-network/systemd-networkd-tests.py
View File

@@ -239,17 +239,6 @@ def expectedFailureIfNexthopIsNotAvailable():
return f
def expectedFailureIfRTA_VIAIsNotSupported():
def f(func):
call_quiet('ip link add dummy98 type dummy')
call_quiet('ip link set up dev dummy98')
call_quiet('ip route add 2001:1234:5:8fff:ff:ff:ff:fe/128 dev dummy98')
rc = call_quiet('ip route add 10.10.10.10 via inet6 2001:1234:5:8fff:ff:ff:ff:fe dev dummy98')
remove_link('dummy98')
return func if rc == 0 else unittest.expectedFailure(func)
return f
def expectedFailureIfAlternativeNameIsNotAvailable():
def f(func):
call_quiet('ip link add dummy98 type dummy')
@@ -4510,7 +4499,6 @@ class NetworkdNetworkTests(unittest.TestCase, Utilities):
self.assertRegex(output, 'local fe80:[a-f0-9:]* table local proto kernel metric 0 pref medium', output)
self.assertIn('multicast ff00::/8 table local proto kernel metric 256 pref medium', output)
@expectedFailureIfRTA_VIAIsNotSupported()
def test_route_via_ipv6(self):
copy_network_unit('25-route-via-ipv6.network', '12-dummy.netdev')
start_networkd()