14630481637

Committed 23 Apr 2025 07:04PM UTC coverage: 72.178% (-0.002%) from 72.18%

Build # 14630481637

Build Type

push

github

Committed by

DaanDeMeyer

Commit Message

mkosi: Run clangd within the tools tree instead of the build container

Running within the build sandbox has a number of disadvantages:
- We have a separate clangd cache for each distribution/release combo
- It requires to build the full image before clangd can be used
- It breaks every time the image becomes out of date and requires a
  rebuild
- We can't look at system headers as we don't have the knowledge to map
  them from inside the build sandbox to the corresponding path on the host

Instead, let's have mkosi.clangd run clangd within the tools tree. We
already require building systemd for both the host and the target anyway,
and all the dependencies to build systemd are installed in the tools tree
already for that, as well as clangd since it's installed together with the
other clang tooling we install in the tools tree. Unlike the previous approach,
this approach only requires the mkosi tools tree to be built upfront, which has
a much higher chance of not invalidating its cache. We can also trivially map
system header lookups from within the sandbox to the path within mkosi.tools
on the host so that starts working as well.

Coverage Stats

297054 of 411557 relevant lines covered (72.18%)

686269.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.52

/src/resolve/test-resolved-link.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <net/if.h>
#include <linux/if.h>

#include "netlink-internal.h"
#include "resolved-dns-packet.h"
#include "resolved-dns-scope.h"
#include "resolved-dns-server.h"
#include "resolved-link.h"
#include "resolved-manager.h"

#include "log.h"
#include "tests.h"

DEFINE_TRIVIAL_CLEANUP_FUNC(LinkAddress*, link_address_free);

/* ================================================================
 * link_new()
 * ================================================================ */

TEST(link_new) {
        Manager manager = {};
        _cleanup_(link_freep) Link *link = NULL;

        ASSERT_OK(link_new(&manager, &link, 1));
        ASSERT_NOT_NULL(link);
}

/* ================================================================
 * link_process_rtnl()
 * ================================================================ */

TEST(link_process_rtnl) {
        Manager manager = {};
        _cleanup_(link_freep) Link *link = NULL;
        _cleanup_(sd_netlink_unrefp) sd_netlink *nl = NULL;
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *msg = NULL;

        ASSERT_OK(link_new(&manager, &link, 1));
        ASSERT_NOT_NULL(link);

        ASSERT_OK(netlink_open_family(&nl, AF_INET));
        nl->protocol = NETLINK_ROUTE;

        ASSERT_OK(sd_rtnl_message_new_link(nl, &msg, RTM_NEWLINK, 1));
        ASSERT_NOT_NULL(msg);
        message_seal(msg);

        ASSERT_OK(link_process_rtnl(link, msg));
}

/* ================================================================
 * link_relevant()
 * ================================================================ */

TEST(link_relevant) {
        Manager manager = {};
        _cleanup_(link_freep) Link *link = NULL;
        _cleanup_(link_address_freep) LinkAddress *address = NULL;

        ASSERT_OK(link_new(&manager, &link, 1));
        ASSERT_NOT_NULL(link);

        link->flags = IFF_LOOPBACK;
        ASSERT_FALSE(link_relevant(link, AF_INET, true));
        ASSERT_FALSE(link_relevant(link, AF_INET, false));

        link->flags = IFF_UP;
        ASSERT_FALSE(link_relevant(link, AF_INET, true));
        ASSERT_FALSE(link_relevant(link, AF_INET, false));

        link->flags = IFF_UP | IFF_LOWER_UP;
        ASSERT_FALSE(link_relevant(link, AF_INET, true));
        ASSERT_FALSE(link_relevant(link, AF_INET, false));

        link->flags = IFF_UP | IFF_LOWER_UP | IFF_MULTICAST;
        link->operstate = IF_OPER_UP;

        ASSERT_FALSE(link_relevant(link, AF_INET, true));
        ASSERT_FALSE(link_relevant(link, AF_INET, false));

        union in_addr_union ip = { .in.s_addr = htobe32(0xc0a84301) };
        union in_addr_union bcast = { .in.s_addr = htobe32(0xc0a843ff) };

        ASSERT_OK(link_address_new(link, &address, AF_INET, &ip, &bcast));
        ASSERT_NOT_NULL(address);

        ASSERT_TRUE(link_relevant(link, AF_INET, true));
        ASSERT_TRUE(link_relevant(link, AF_INET, false));

        link->flags = IFF_UP | IFF_LOWER_UP;
        ASSERT_FALSE(link_relevant(link, AF_INET, true));
        ASSERT_TRUE(link_relevant(link, AF_INET, false));

        link->is_managed = true;
        ASSERT_FALSE(link_relevant(link, AF_INET, false));

        link->networkd_operstate = LINK_OPERSTATE_DEGRADED_CARRIER;
        ASSERT_TRUE(link_relevant(link, AF_INET, false));
}

/* ================================================================
 * link_find_address()
 * ================================================================ */

TEST(link_find_address) {
        Manager manager = {};
        _cleanup_(link_freep) Link *link = NULL;
        _cleanup_(link_address_freep) LinkAddress *v4addr = NULL, *v6addr = NULL, *ret_addr = NULL;

        union in_addr_union ipv4 = { .in.s_addr = htobe32(0xc0a84301) };
        union in_addr_union ipv6 = { .in6.s6_addr = { 0xf2, 0x34, 0x32, 0x2e, 0xb8, 0x25, 0x38, 0x35, 0x2f, 0xd7, 0xdb, 0x7b, 0x28, 0x7e, 0x60, 0xbb } };

        ASSERT_OK(link_new(&manager, &link, 1));
        ASSERT_NOT_NULL(link);

        ASSERT_OK(link_address_new(link, &v4addr, AF_INET, &ipv4, &ipv4));
        ASSERT_NOT_NULL(v4addr);
        ASSERT_OK(link_address_new(link, &v6addr, AF_INET6, &ipv6, &ipv6));
        ASSERT_NOT_NULL(v6addr);

        ret_addr = link_find_address(link, AF_INET, &ipv4);
        ASSERT_TRUE(ret_addr == v4addr);

        ret_addr = link_find_address(link, AF_INET6, &ipv6);
        ASSERT_TRUE(ret_addr == v6addr);

        ret_addr = link_find_address(link, AF_INET6, &ipv4);
        ASSERT_NULL(ret_addr);
}

/* ================================================================
 * link_allocate_scopes()
 * ================================================================ */

typedef struct LinkAllocEnv {
        Manager manager;
        int ifindex;
        Link *link;
        union in_addr_union ip_addr;
        LinkAddress *address;
        DnsServerType server_type;
        union in_addr_union server_addr;
        char *server_name;
        uint16_t server_port;
        DnsServer *server;
} LinkAllocEnv;

static void link_alloc_env_teardown(LinkAllocEnv *env) {
        ASSERT_NOT_NULL(env);

        free(env->server_name);
        link_address_free(env->address);
        dns_server_unref(env->server);
        sd_event_unref(env->manager.event);
}

static void link_alloc_env_setup(LinkAllocEnv *env, int family, DnsServerType server_type) {
        Link *link = NULL;

        ASSERT_NOT_NULL(env);

        env->manager = (Manager) {};
        env->ifindex = 1;

        ASSERT_OK(sd_event_new(&env->manager.event));
        ASSERT_NOT_NULL(env->manager.event);

        ASSERT_OK(link_new(&env->manager, &env->link, env->ifindex));
        ASSERT_NOT_NULL(env->link);
        env->link->flags = IFF_UP | IFF_LOWER_UP;
        env->link->operstate = IF_OPER_UP;

        env->ip_addr.in.s_addr = htobe32(0xc0a84301);
        ASSERT_OK(link_address_new(env->link, &env->address, family, &env->ip_addr, &env->ip_addr));
        ASSERT_NOT_NULL(env->address);

        env->server_type = server_type;
        env->server_addr.in.s_addr = htobe32(0x7f000001);
        env->server_name = strdup("localhost");
        env->server_port = 53;

        if (server_type == DNS_SERVER_LINK)
                link = env->link;

        ASSERT_OK(dns_server_new(&env->manager, &env->server, env->server_type,
                        link, family, &env->server_addr, env->server_port,
                        env->ifindex, env->server_name, RESOLVE_CONFIG_SOURCE_DBUS));

        ASSERT_NOT_NULL(env->server);
}

TEST(link_allocate_scopes_resets_manager_dns_server) {
        _cleanup_(link_alloc_env_teardown) LinkAllocEnv env = {};

        link_alloc_env_setup(&env, AF_INET, DNS_SERVER_SYSTEM);

        env.link->unicast_relevant = false;
        env.manager.dns_servers->verified_feature_level = DNS_SERVER_FEATURE_LEVEL_EDNS0;
        env.manager.dns_servers->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_DO;
        env.manager.dns_servers->received_udp_fragment_max = 1024u;

        link_allocate_scopes(env.link);

        ASSERT_TRUE(env.link->unicast_relevant);
        ASSERT_EQ(env.manager.dns_servers->verified_feature_level, _DNS_SERVER_FEATURE_LEVEL_INVALID);
        ASSERT_EQ(env.manager.dns_servers->possible_feature_level, DNS_SERVER_FEATURE_LEVEL_BEST);
        ASSERT_EQ(env.manager.dns_servers->received_udp_fragment_max, DNS_PACKET_UNICAST_SIZE_MAX);

        ASSERT_FALSE(env.manager.dns_servers->packet_bad_opt);
        ASSERT_FALSE(env.manager.dns_servers->packet_rrsig_missing);
        ASSERT_FALSE(env.manager.dns_servers->packet_do_off);
        ASSERT_FALSE(env.manager.dns_servers->warned_downgrade);

        ASSERT_NULL(env.link->unicast_scope);
        ASSERT_NULL(env.link->llmnr_ipv4_scope);
        ASSERT_NULL(env.link->llmnr_ipv6_scope);
        ASSERT_NULL(env.link->mdns_ipv4_scope);
        ASSERT_NULL(env.link->mdns_ipv6_scope);
}

TEST(link_allocate_scopes_unicast) {
        _cleanup_(link_alloc_env_teardown) LinkAllocEnv env = {};

        link_alloc_env_setup(&env, AF_INET, DNS_SERVER_LINK);

        env.link->unicast_relevant = true;
        env.link->dns_servers->verified_feature_level = DNS_SERVER_FEATURE_LEVEL_EDNS0;
        env.link->dns_servers->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_DO;
        env.link->dns_servers->received_udp_fragment_max = 1024u;

        link_allocate_scopes(env.link);

        ASSERT_TRUE(env.link->unicast_relevant);
        ASSERT_EQ(env.link->dns_servers->verified_feature_level, _DNS_SERVER_FEATURE_LEVEL_INVALID);
        ASSERT_EQ(env.link->dns_servers->possible_feature_level, DNS_SERVER_FEATURE_LEVEL_BEST);
        ASSERT_EQ(env.link->dns_servers->received_udp_fragment_max, DNS_PACKET_UNICAST_SIZE_MAX);

        ASSERT_FALSE(env.link->dns_servers->packet_bad_opt);
        ASSERT_FALSE(env.link->dns_servers->packet_rrsig_missing);
        ASSERT_FALSE(env.link->dns_servers->packet_do_off);
        ASSERT_FALSE(env.link->dns_servers->warned_downgrade);

        ASSERT_NULL(env.link->llmnr_ipv4_scope);
        ASSERT_NULL(env.link->llmnr_ipv6_scope);
        ASSERT_NULL(env.link->mdns_ipv4_scope);
        ASSERT_NULL(env.link->mdns_ipv6_scope);

        ASSERT_TRUE(env.link->unicast_scope->link == env.link);
        ASSERT_EQ(env.link->unicast_scope->protocol, DNS_PROTOCOL_DNS);
        ASSERT_EQ(env.link->unicast_scope->family, AF_UNSPEC);
}

TEST(link_allocate_scopes_llmnr_ipv4) {
        _cleanup_(link_alloc_env_teardown) LinkAllocEnv env = {};

        link_alloc_env_setup(&env, AF_INET, DNS_SERVER_LINK);

        env.link->flags |= IFF_MULTICAST;
        env.link->llmnr_support = RESOLVE_SUPPORT_YES;
        env.manager.llmnr_support = RESOLVE_SUPPORT_YES;

        link_allocate_scopes(env.link);

        ASSERT_NOT_NULL(env.link->unicast_scope);
        ASSERT_NULL(env.link->llmnr_ipv6_scope);
        ASSERT_NULL(env.link->mdns_ipv4_scope);
        ASSERT_NULL(env.link->mdns_ipv6_scope);

        ASSERT_TRUE(env.link->llmnr_ipv4_scope->link == env.link);
        ASSERT_EQ(env.link->llmnr_ipv4_scope->protocol, DNS_PROTOCOL_LLMNR);
        ASSERT_EQ(env.link->llmnr_ipv4_scope->family, AF_INET);
}

TEST(link_allocate_scopes_llmnr_ipv6) {
        _cleanup_(link_alloc_env_teardown) LinkAllocEnv env = {};

        link_alloc_env_setup(&env, AF_INET6, DNS_SERVER_LINK);

        env.link->flags |= IFF_MULTICAST;
        env.link->llmnr_support = RESOLVE_SUPPORT_YES;
        env.manager.llmnr_support = RESOLVE_SUPPORT_YES;

        link_allocate_scopes(env.link);

        ASSERT_NOT_NULL(env.link->unicast_scope);
        ASSERT_NULL(env.link->llmnr_ipv4_scope);
        ASSERT_NULL(env.link->mdns_ipv4_scope);
        ASSERT_NULL(env.link->mdns_ipv6_scope);

        ASSERT_TRUE(env.link->llmnr_ipv6_scope->link == env.link);
        ASSERT_EQ(env.link->llmnr_ipv6_scope->protocol, DNS_PROTOCOL_LLMNR);
        ASSERT_EQ(env.link->llmnr_ipv6_scope->family, AF_INET6);
}

TEST(link_allocate_scopes_mdns_ipv4) {
        _cleanup_(link_alloc_env_teardown) LinkAllocEnv env = {};

        link_alloc_env_setup(&env, AF_INET, DNS_SERVER_LINK);

        env.link->flags |= IFF_MULTICAST;
        env.link->mdns_support = RESOLVE_SUPPORT_YES;
        env.manager.mdns_support = RESOLVE_SUPPORT_YES;

        link_allocate_scopes(env.link);

        ASSERT_NOT_NULL(env.link->unicast_scope);
        ASSERT_NULL(env.link->llmnr_ipv4_scope);
        ASSERT_NULL(env.link->llmnr_ipv6_scope);
        ASSERT_NULL(env.link->mdns_ipv6_scope);

        ASSERT_TRUE(env.link->mdns_ipv4_scope->link == env.link);
        ASSERT_EQ(env.link->mdns_ipv4_scope->protocol, DNS_PROTOCOL_MDNS);
        ASSERT_EQ(env.link->mdns_ipv4_scope->family, AF_INET);
}

TEST(link_allocate_scopes_mdns_ipv6) {
        _cleanup_(link_alloc_env_teardown) LinkAllocEnv env = {};

        link_alloc_env_setup(&env, AF_INET6, DNS_SERVER_LINK);

        env.link->flags |= IFF_MULTICAST;
        env.link->mdns_support = RESOLVE_SUPPORT_YES;
        env.manager.mdns_support = RESOLVE_SUPPORT_YES;

        link_allocate_scopes(env.link);

        ASSERT_NOT_NULL(env.link->unicast_scope);
        ASSERT_NULL(env.link->llmnr_ipv4_scope);
        ASSERT_NULL(env.link->llmnr_ipv6_scope);
        ASSERT_NULL(env.link->mdns_ipv4_scope);

        ASSERT_TRUE(env.link->mdns_ipv6_scope->link == env.link);
        ASSERT_EQ(env.link->mdns_ipv6_scope->protocol, DNS_PROTOCOL_MDNS);
        ASSERT_EQ(env.link->mdns_ipv6_scope->family, AF_INET6);
}

DEFINE_TEST_MAIN(LOG_DEBUG)

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include <net/if.h>
4	#include <linux/if.h>
5
6	#include "netlink-internal.h"
7	#include "resolved-dns-packet.h"
8	#include "resolved-dns-scope.h"
9	#include "resolved-dns-server.h"
10	#include "resolved-link.h"
11	#include "resolved-manager.h"
12
13	#include "log.h"
14	#include "tests.h"
15
16	DEFINE_TRIVIAL_CLEANUP_FUNC(LinkAddress*, link_address_free);	4✔
17
18	/* ================================================================
19	* link_new()
20	* ================================================================ */
21
22	TEST(link_new) {	1✔
23	Manager manager = {};	1✔
24	_cleanup_(link_freep) Link *link = NULL;	1✔
25
26	ASSERT_OK(link_new(&manager, &link, 1));	1✔
27	ASSERT_NOT_NULL(link);	1✔
28	}	1✔
29
30	/* ================================================================
31	* link_process_rtnl()
32	* ================================================================ */
33
34	TEST(link_process_rtnl) {	1✔
35	Manager manager = {};	1✔
36	_cleanup_(link_freep) Link *link = NULL;	×
37	_cleanup_(sd_netlink_unrefp) sd_netlink *nl = NULL;	1✔
38	_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *msg = NULL;	1✔
39
40	ASSERT_OK(link_new(&manager, &link, 1));	1✔
41	ASSERT_NOT_NULL(link);	1✔
42
43	ASSERT_OK(netlink_open_family(&nl, AF_INET));	1✔
44	nl->protocol = NETLINK_ROUTE;	1✔
45
46	ASSERT_OK(sd_rtnl_message_new_link(nl, &msg, RTM_NEWLINK, 1));	1✔
47	ASSERT_NOT_NULL(msg);	1✔
48	message_seal(msg);	1✔
49
50	ASSERT_OK(link_process_rtnl(link, msg));	1✔
51	}	1✔
52
53	/* ================================================================
54	* link_relevant()
55	* ================================================================ */
56
57	TEST(link_relevant) {	1✔
58	Manager manager = {};	1✔
59	_cleanup_(link_freep) Link *link = NULL;	1✔
60	_cleanup_(link_address_freep) LinkAddress *address = NULL;	1✔
61
62	ASSERT_OK(link_new(&manager, &link, 1));	1✔
63	ASSERT_NOT_NULL(link);	1✔
64
65	link->flags = IFF_LOOPBACK;	1✔
66	ASSERT_FALSE(link_relevant(link, AF_INET, true));	1✔
67	ASSERT_FALSE(link_relevant(link, AF_INET, false));	1✔
68
69	link->flags = IFF_UP;	1✔
70	ASSERT_FALSE(link_relevant(link, AF_INET, true));	1✔
71	ASSERT_FALSE(link_relevant(link, AF_INET, false));	1✔
72
73	link->flags = IFF_UP \| IFF_LOWER_UP;	1✔
74	ASSERT_FALSE(link_relevant(link, AF_INET, true));	1✔
75	ASSERT_FALSE(link_relevant(link, AF_INET, false));	1✔
76
77	link->flags = IFF_UP \| IFF_LOWER_UP \| IFF_MULTICAST;	1✔
78	link->operstate = IF_OPER_UP;	1✔
79
80	ASSERT_FALSE(link_relevant(link, AF_INET, true));	1✔
81	ASSERT_FALSE(link_relevant(link, AF_INET, false));	1✔
82
83	union in_addr_union ip = { .in.s_addr = htobe32(0xc0a84301) };	1✔
84	union in_addr_union bcast = { .in.s_addr = htobe32(0xc0a843ff) };	1✔
85
86	ASSERT_OK(link_address_new(link, &address, AF_INET, &ip, &bcast));	1✔
87	ASSERT_NOT_NULL(address);	1✔
88
89	ASSERT_TRUE(link_relevant(link, AF_INET, true));	1✔
90	ASSERT_TRUE(link_relevant(link, AF_INET, false));	1✔
91
92	link->flags = IFF_UP \| IFF_LOWER_UP;	1✔
93	ASSERT_FALSE(link_relevant(link, AF_INET, true));	1✔
94	ASSERT_TRUE(link_relevant(link, AF_INET, false));	1✔
95
96	link->is_managed = true;	1✔
97	ASSERT_FALSE(link_relevant(link, AF_INET, false));	1✔
98
99	link->networkd_operstate = LINK_OPERSTATE_DEGRADED_CARRIER;	1✔
100	ASSERT_TRUE(link_relevant(link, AF_INET, false));	1✔
101	}	1✔
102
103	/* ================================================================
104	* link_find_address()
105	* ================================================================ */
106
107	TEST(link_find_address) {	1✔
108	Manager manager = {};	1✔
109	_cleanup_(link_freep) Link *link = NULL;	1✔
110	_cleanup_(link_address_freep) LinkAddress v4addr = NULL, v6addr = NULL, *ret_addr = NULL;	1✔
111
112	union in_addr_union ipv4 = { .in.s_addr = htobe32(0xc0a84301) };	1✔
113	union in_addr_union ipv6 = { .in6.s6_addr = { 0xf2, 0x34, 0x32, 0x2e, 0xb8, 0x25, 0x38, 0x35, 0x2f, 0xd7, 0xdb, 0x7b, 0x28, 0x7e, 0x60, 0xbb } };	1✔
114
115	ASSERT_OK(link_new(&manager, &link, 1));	1✔
116	ASSERT_NOT_NULL(link);	1✔
117
118	ASSERT_OK(link_address_new(link, &v4addr, AF_INET, &ipv4, &ipv4));	1✔
119	ASSERT_NOT_NULL(v4addr);	1✔
120	ASSERT_OK(link_address_new(link, &v6addr, AF_INET6, &ipv6, &ipv6));	1✔
121	ASSERT_NOT_NULL(v6addr);	1✔
122
123	ret_addr = link_find_address(link, AF_INET, &ipv4);	1✔
124	ASSERT_TRUE(ret_addr == v4addr);	1✔
125
126	ret_addr = link_find_address(link, AF_INET6, &ipv6);	1✔
127	ASSERT_TRUE(ret_addr == v6addr);	1✔
128
129	ret_addr = link_find_address(link, AF_INET6, &ipv4);	1✔
130	ASSERT_NULL(ret_addr);	1✔
131	}	1✔
132
133	/* ================================================================
134	* link_allocate_scopes()
135	* ================================================================ */
136
137	typedef struct LinkAllocEnv {
138	Manager manager;
139	int ifindex;
140	Link *link;
141	union in_addr_union ip_addr;
142	LinkAddress *address;
143	DnsServerType server_type;
144	union in_addr_union server_addr;
145	char *server_name;
146	uint16_t server_port;
147	DnsServer *server;
148	} LinkAllocEnv;
149
150	static void link_alloc_env_teardown(LinkAllocEnv *env) {	6✔
151	ASSERT_NOT_NULL(env);	6✔
152
153	free(env->server_name);	6✔
154	link_address_free(env->address);	6✔
155	dns_server_unref(env->server);	6✔
156	sd_event_unref(env->manager.event);	6✔
157	}	6✔
158
159	static void link_alloc_env_setup(LinkAllocEnv *env, int family, DnsServerType server_type) {	6✔
160	Link *link = NULL;	6✔
161
162	ASSERT_NOT_NULL(env);	6✔
163
164	env->manager = (Manager) {};	6✔
165	env->ifindex = 1;	6✔
166
167	ASSERT_OK(sd_event_new(&env->manager.event));	6✔
168	ASSERT_NOT_NULL(env->manager.event);	6✔
169
170	ASSERT_OK(link_new(&env->manager, &env->link, env->ifindex));	6✔
171	ASSERT_NOT_NULL(env->link);	6✔
172	env->link->flags = IFF_UP \| IFF_LOWER_UP;	6✔
173	env->link->operstate = IF_OPER_UP;	6✔
174
175	env->ip_addr.in.s_addr = htobe32(0xc0a84301);	6✔
176	ASSERT_OK(link_address_new(env->link, &env->address, family, &env->ip_addr, &env->ip_addr));	6✔
177	ASSERT_NOT_NULL(env->address);	6✔
178
179	env->server_type = server_type;	6✔
180	env->server_addr.in.s_addr = htobe32(0x7f000001);	6✔
181	env->server_name = strdup("localhost");	6✔
182	env->server_port = 53;	6✔
183
184	if (server_type == DNS_SERVER_LINK)	6✔
185	link = env->link;	5✔
186
187	ASSERT_OK(dns_server_new(&env->manager, &env->server, env->server_type,	6✔
188	link, family, &env->server_addr, env->server_port,
189	env->ifindex, env->server_name, RESOLVE_CONFIG_SOURCE_DBUS));
190
191	ASSERT_NOT_NULL(env->server);	6✔
192	}	6✔
193
194	TEST(link_allocate_scopes_resets_manager_dns_server) {	1✔
195	_cleanup_(link_alloc_env_teardown) LinkAllocEnv env = {};	1✔
196
197	link_alloc_env_setup(&env, AF_INET, DNS_SERVER_SYSTEM);	1✔
198
199	env.link->unicast_relevant = false;	1✔
200	env.manager.dns_servers->verified_feature_level = DNS_SERVER_FEATURE_LEVEL_EDNS0;	1✔
201	env.manager.dns_servers->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_DO;	1✔
202	env.manager.dns_servers->received_udp_fragment_max = 1024u;	1✔
203
204	link_allocate_scopes(env.link);	1✔
205
206	ASSERT_TRUE(env.link->unicast_relevant);	1✔
207	ASSERT_EQ(env.manager.dns_servers->verified_feature_level, _DNS_SERVER_FEATURE_LEVEL_INVALID);	1✔
208	ASSERT_EQ(env.manager.dns_servers->possible_feature_level, DNS_SERVER_FEATURE_LEVEL_BEST);	1✔
209	ASSERT_EQ(env.manager.dns_servers->received_udp_fragment_max, DNS_PACKET_UNICAST_SIZE_MAX);	1✔
210
211	ASSERT_FALSE(env.manager.dns_servers->packet_bad_opt);	1✔
212	ASSERT_FALSE(env.manager.dns_servers->packet_rrsig_missing);	1✔
213	ASSERT_FALSE(env.manager.dns_servers->packet_do_off);	1✔
214	ASSERT_FALSE(env.manager.dns_servers->warned_downgrade);	1✔
215
216	ASSERT_NULL(env.link->unicast_scope);	1✔
217	ASSERT_NULL(env.link->llmnr_ipv4_scope);	1✔
218	ASSERT_NULL(env.link->llmnr_ipv6_scope);	1✔
219	ASSERT_NULL(env.link->mdns_ipv4_scope);	1✔
220	ASSERT_NULL(env.link->mdns_ipv6_scope);	1✔
221	}	1✔
222
223	TEST(link_allocate_scopes_unicast) {	1✔
224	_cleanup_(link_alloc_env_teardown) LinkAllocEnv env = {};	1✔
225
226	link_alloc_env_setup(&env, AF_INET, DNS_SERVER_LINK);	1✔
227
228	env.link->unicast_relevant = true;	1✔
229	env.link->dns_servers->verified_feature_level = DNS_SERVER_FEATURE_LEVEL_EDNS0;	1✔
230	env.link->dns_servers->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_DO;	1✔
231	env.link->dns_servers->received_udp_fragment_max = 1024u;	1✔
232
233	link_allocate_scopes(env.link);	1✔
234
235	ASSERT_TRUE(env.link->unicast_relevant);	1✔
236	ASSERT_EQ(env.link->dns_servers->verified_feature_level, _DNS_SERVER_FEATURE_LEVEL_INVALID);	1✔
237	ASSERT_EQ(env.link->dns_servers->possible_feature_level, DNS_SERVER_FEATURE_LEVEL_BEST);	1✔
238	ASSERT_EQ(env.link->dns_servers->received_udp_fragment_max, DNS_PACKET_UNICAST_SIZE_MAX);	1✔
239
240	ASSERT_FALSE(env.link->dns_servers->packet_bad_opt);	1✔
241	ASSERT_FALSE(env.link->dns_servers->packet_rrsig_missing);	1✔
242	ASSERT_FALSE(env.link->dns_servers->packet_do_off);	1✔
243	ASSERT_FALSE(env.link->dns_servers->warned_downgrade);	1✔
244
245	ASSERT_NULL(env.link->llmnr_ipv4_scope);	1✔
246	ASSERT_NULL(env.link->llmnr_ipv6_scope);	1✔
247	ASSERT_NULL(env.link->mdns_ipv4_scope);	1✔
248	ASSERT_NULL(env.link->mdns_ipv6_scope);	1✔
249
250	ASSERT_TRUE(env.link->unicast_scope->link == env.link);	1✔
251	ASSERT_EQ(env.link->unicast_scope->protocol, DNS_PROTOCOL_DNS);	1✔
252	ASSERT_EQ(env.link->unicast_scope->family, AF_UNSPEC);	1✔
253	}	1✔
254
255	TEST(link_allocate_scopes_llmnr_ipv4) {	1✔
256	_cleanup_(link_alloc_env_teardown) LinkAllocEnv env = {};	1✔
257
258	link_alloc_env_setup(&env, AF_INET, DNS_SERVER_LINK);	1✔
259
260	env.link->flags \|= IFF_MULTICAST;	1✔
261	env.link->llmnr_support = RESOLVE_SUPPORT_YES;	1✔
262	env.manager.llmnr_support = RESOLVE_SUPPORT_YES;	1✔
263
264	link_allocate_scopes(env.link);	1✔
265
266	ASSERT_NOT_NULL(env.link->unicast_scope);	1✔
267	ASSERT_NULL(env.link->llmnr_ipv6_scope);	1✔
268	ASSERT_NULL(env.link->mdns_ipv4_scope);	1✔
269	ASSERT_NULL(env.link->mdns_ipv6_scope);	1✔
270
271	ASSERT_TRUE(env.link->llmnr_ipv4_scope->link == env.link);	1✔
272	ASSERT_EQ(env.link->llmnr_ipv4_scope->protocol, DNS_PROTOCOL_LLMNR);	1✔
273	ASSERT_EQ(env.link->llmnr_ipv4_scope->family, AF_INET);	1✔
274	}	1✔
275
276	TEST(link_allocate_scopes_llmnr_ipv6) {	1✔
277	_cleanup_(link_alloc_env_teardown) LinkAllocEnv env = {};	1✔
278
279	link_alloc_env_setup(&env, AF_INET6, DNS_SERVER_LINK);	1✔
280
281	env.link->flags \|= IFF_MULTICAST;	1✔
282	env.link->llmnr_support = RESOLVE_SUPPORT_YES;	1✔
283	env.manager.llmnr_support = RESOLVE_SUPPORT_YES;	1✔
284
285	link_allocate_scopes(env.link);	1✔
286
287	ASSERT_NOT_NULL(env.link->unicast_scope);	1✔
288	ASSERT_NULL(env.link->llmnr_ipv4_scope);	1✔
289	ASSERT_NULL(env.link->mdns_ipv4_scope);	1✔
290	ASSERT_NULL(env.link->mdns_ipv6_scope);	1✔
291
292	ASSERT_TRUE(env.link->llmnr_ipv6_scope->link == env.link);	1✔
293	ASSERT_EQ(env.link->llmnr_ipv6_scope->protocol, DNS_PROTOCOL_LLMNR);	1✔
294	ASSERT_EQ(env.link->llmnr_ipv6_scope->family, AF_INET6);	1✔
295	}	1✔
296
297	TEST(link_allocate_scopes_mdns_ipv4) {	1✔
298	_cleanup_(link_alloc_env_teardown) LinkAllocEnv env = {};	1✔
299
300	link_alloc_env_setup(&env, AF_INET, DNS_SERVER_LINK);	1✔
301
302	env.link->flags \|= IFF_MULTICAST;	1✔
303	env.link->mdns_support = RESOLVE_SUPPORT_YES;	1✔
304	env.manager.mdns_support = RESOLVE_SUPPORT_YES;	1✔
305
306	link_allocate_scopes(env.link);	1✔
307
308	ASSERT_NOT_NULL(env.link->unicast_scope);	1✔
309	ASSERT_NULL(env.link->llmnr_ipv4_scope);	1✔
310	ASSERT_NULL(env.link->llmnr_ipv6_scope);	1✔
311	ASSERT_NULL(env.link->mdns_ipv6_scope);	1✔
312
313	ASSERT_TRUE(env.link->mdns_ipv4_scope->link == env.link);	1✔
314	ASSERT_EQ(env.link->mdns_ipv4_scope->protocol, DNS_PROTOCOL_MDNS);	1✔
315	ASSERT_EQ(env.link->mdns_ipv4_scope->family, AF_INET);	1✔
316	}	1✔
317
318	TEST(link_allocate_scopes_mdns_ipv6) {	1✔
319	_cleanup_(link_alloc_env_teardown) LinkAllocEnv env = {};	1✔
320
321	link_alloc_env_setup(&env, AF_INET6, DNS_SERVER_LINK);	1✔
322
323	env.link->flags \|= IFF_MULTICAST;	1✔
324	env.link->mdns_support = RESOLVE_SUPPORT_YES;	1✔
325	env.manager.mdns_support = RESOLVE_SUPPORT_YES;	1✔
326
327	link_allocate_scopes(env.link);	1✔
328
329	ASSERT_NOT_NULL(env.link->unicast_scope);	1✔
330	ASSERT_NULL(env.link->llmnr_ipv4_scope);	1✔
331	ASSERT_NULL(env.link->llmnr_ipv6_scope);	1✔
332	ASSERT_NULL(env.link->mdns_ipv4_scope);	1✔
333
334	ASSERT_TRUE(env.link->mdns_ipv6_scope->link == env.link);	1✔
335	ASSERT_EQ(env.link->mdns_ipv6_scope->protocol, DNS_PROTOCOL_MDNS);	1✔
336	ASSERT_EQ(env.link->mdns_ipv6_scope->family, AF_INET6);	1✔
337	}	1✔
338
339	DEFINE_TEST_MAIN(LOG_DEBUG)	1✔

systemd / systemd / 14630481637

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous