Debian Codegraph @

src/resolve/resolved-link.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <linux/if.h>
4 #include <unistd.h>
5
6 #include "sd-netlink.h"
7 #include "sd-network.h"
8
9 #include "alloc-util.h"
10 #include "dns-domain.h"
11 #include "dns-packet.h"
12 #include "dns-rr.h"
13 #include "env-file.h"
14 #include "extract-word.h"
15 #include "fd-util.h"
16 #include "fileio.h"
17 #include "fs-util.h"
18 #include "log-link.h"
19 #include "mkdir.h"
20 #include "netif-util.h"
21 #include "parse-util.h"
22 #include "resolved-dns-browse-services.h"
23 #include "resolved-dns-scope.h"
24 #include "resolved-dns-search-domain.h"
25 #include "resolved-dns-server.h"
26 #include "resolved-link.h"
27 #include "resolved-llmnr.h"
28 #include "resolved-manager.h"
29 #include "resolved-mdns.h"
30 #include "set.h"
31 #include "socket-netlink.h"
32 #include "stat-util.h"
33 #include "string-util.h"
34 #include "strv.h"
35 #include "tmpfile-util.h"
36
37 int link_new(Manager *m, Link **ret, int ifindex) {
38 _cleanup_(link_freep) Link *l = NULL;
39 int r;
40
41 assert(m);
42 assert(ifindex > 0);
43
44 l = new(Link, 1);
45 if (!l)
46 return -ENOMEM;
47
48 *l = (Link) {
49 .ifindex = ifindex,
50 .default_route = -1,
51 .llmnr_support = RESOLVE_SUPPORT_YES,
52 .mdns_support = RESOLVE_SUPPORT_YES,
53 .dnssec_mode = _DNSSEC_MODE_INVALID,
54 .dns_over_tls_mode = _DNS_OVER_TLS_MODE_INVALID,
55 .operstate = IF_OPER_UNKNOWN,
56 };
57
58 if (asprintf(&l->state_file, "/run/systemd/resolve/netif/%i", ifindex) < 0)
59 return -ENOMEM;
60
61 r = hashmap_ensure_put(&m->links, NULL, INT_TO_PTR(ifindex), l);
62 if (r < 0)
63 return r;
64
65 l->manager = m;
66
67 if (ret)
68 *ret = l;
69 TAKE_PTR(l);
70
71 return 0;
72 }
73
74 void link_flush_settings(Link *l) {
75 assert(l);
76
77 l->default_route = -1;
78 l->llmnr_support = RESOLVE_SUPPORT_YES;
79 l->mdns_support = RESOLVE_SUPPORT_YES;
80 l->dnssec_mode = _DNSSEC_MODE_INVALID;
81 l->dns_over_tls_mode = _DNS_OVER_TLS_MODE_INVALID;
82
83 dns_server_unlink_all(l->dns_servers);
84 dns_search_domain_unlink_all(l->search_domains);
85
86 l->dnssec_negative_trust_anchors = set_free(l->dnssec_negative_trust_anchors);
87 }
88
89 Link *link_free(Link *l) {
90 if (!l)
91 return NULL;
92
93 /* Send goodbye messages. */
94 dns_scope_announce(l->mdns_ipv4_scope, true);
95 dns_scope_announce(l->mdns_ipv6_scope, true);
96
97 link_flush_settings(l);
98
99 while (l->addresses)
100 (void) link_address_free(l->addresses);
101
102 if (l->manager)
103 hashmap_remove(l->manager->links, INT_TO_PTR(l->ifindex));
104
105 dns_scope_free(l->unicast_scope);
106 dns_scope_free(l->llmnr_ipv4_scope);
107 dns_scope_free(l->llmnr_ipv6_scope);
108 dns_scope_free(l->mdns_ipv4_scope);
109 dns_scope_free(l->mdns_ipv6_scope);
110
111 free(l->state_file);
112 free(l->ifname);
113
114 return mfree(l);
115 }
116
117 void link_allocate_scopes(Link *l) {
118 bool unicast_relevant;
119 int r;
120
121 assert(l);
122
123 /* If a link that used to be relevant is no longer, or a link that did not use to be relevant now becomes
124 * relevant, let's reinit the learnt global DNS server information, since we might talk to different servers
125 * now, even if they have the same addresses as before. */
126
127 unicast_relevant = link_relevant(l, AF_UNSPEC, false);
128 if (unicast_relevant != l->unicast_relevant) {
129 l->unicast_relevant = unicast_relevant;
130
131 dns_server_reset_features_all(l->manager->fallback_dns_servers);
132 dns_server_reset_features_all(l->manager->dns_servers);
133
134 /* Also, flush the global unicast scope, to deal with split horizon setups, where talking through one
135 * interface reveals different DNS zones than through others. */
136 if (l->manager->unicast_scope)
137 dns_cache_flush(&l->manager->unicast_scope->cache);
138 }
139
140 /* And now, allocate all scopes that makes sense now if we didn't have them yet, and drop those which we don't
141 * need anymore */
142
143 if (unicast_relevant && l->dns_servers) {
144 if (!l->unicast_scope) {
145 dns_server_reset_features_all(l->dns_servers);
146
147 r = dns_scope_new(l->manager, &l->unicast_scope, DNS_SCOPE_LINK, l, /* delegate= */ NULL, DNS_PROTOCOL_DNS, AF_UNSPEC);
148 if (r < 0)
149 log_link_warning_errno(l, r, "Failed to allocate DNS scope, ignoring: %m");
150 }
151 } else
152 l->unicast_scope = dns_scope_free(l->unicast_scope);
153
154 if (link_relevant(l, AF_INET, true) &&
155 link_get_llmnr_support(l) != RESOLVE_SUPPORT_NO) {
156 if (!l->llmnr_ipv4_scope) {
157 r = dns_scope_new(l->manager, &l->llmnr_ipv4_scope, DNS_SCOPE_LINK, l, /* delegate= */ NULL, DNS_PROTOCOL_LLMNR, AF_INET);
158 if (r < 0)
159 log_link_warning_errno(l, r, "Failed to allocate LLMNR IPv4 scope, ignoring: %m");
160 }
161 } else
162 l->llmnr_ipv4_scope = dns_scope_free(l->llmnr_ipv4_scope);
163
164 if (link_relevant(l, AF_INET6, true) &&
165 link_get_llmnr_support(l) != RESOLVE_SUPPORT_NO) {
166 if (!l->llmnr_ipv6_scope) {
167 r = dns_scope_new(l->manager, &l->llmnr_ipv6_scope, DNS_SCOPE_LINK, l, /* delegate= */ NULL, DNS_PROTOCOL_LLMNR, AF_INET6);
168 if (r < 0)
169 log_link_warning_errno(l, r, "Failed to allocate LLMNR IPv6 scope, ignoring: %m");
170 }
171 } else
172 l->llmnr_ipv6_scope = dns_scope_free(l->llmnr_ipv6_scope);
173
174 if (link_relevant(l, AF_INET, true) &&
175 link_get_mdns_support(l) != RESOLVE_SUPPORT_NO) {
176 if (!l->mdns_ipv4_scope) {
177 r = dns_scope_new(l->manager, &l->mdns_ipv4_scope, DNS_SCOPE_LINK, l, /* delegate= */ NULL, DNS_PROTOCOL_MDNS, AF_INET);
178 if (r < 0)
179 log_link_warning_errno(l, r, "Failed to allocate mDNS IPv4 scope, ignoring: %m");
180 dns_browse_services_restart(l->manager);
181 }
182 } else
183 l->mdns_ipv4_scope = dns_scope_free(l->mdns_ipv4_scope);
184
185 if (link_relevant(l, AF_INET6, true) &&
186 link_get_mdns_support(l) != RESOLVE_SUPPORT_NO) {
187 if (!l->mdns_ipv6_scope) {
188 r = dns_scope_new(l->manager, &l->mdns_ipv6_scope, DNS_SCOPE_LINK, l, /* delegate= */ NULL, DNS_PROTOCOL_MDNS, AF_INET6);
189 if (r < 0)
190 log_link_warning_errno(l, r, "Failed to allocate mDNS IPv6 scope, ignoring: %m");
191 dns_browse_services_restart(l->manager);
192 }
193 } else
194 l->mdns_ipv6_scope = dns_scope_free(l->mdns_ipv6_scope);
195 }
196
197 void link_add_rrs(Link *l, bool force_remove) {
198 int r;
199
200 LIST_FOREACH(addresses, a, l->addresses)
201 link_address_add_rrs(a, force_remove);
202
203 if (!force_remove &&
204 link_get_mdns_support(l) == RESOLVE_SUPPORT_YES) {
205
206 if (l->mdns_ipv4_scope) {
207 r = dns_scope_add_dnssd_registered_services(l->mdns_ipv4_scope);
208 if (r < 0)
209 log_link_warning_errno(l, r, "Failed to add IPv4 DNS-SD services, ignoring: %m");
210 }
211
212 if (l->mdns_ipv6_scope) {
213 r = dns_scope_add_dnssd_registered_services(l->mdns_ipv6_scope);
214 if (r < 0)
215 log_link_warning_errno(l, r, "Failed to add IPv6 DNS-SD services, ignoring: %m");
216 }
217
218 } else {
219
220 if (l->mdns_ipv4_scope) {
221 r = dns_scope_remove_dnssd_registered_services(l->mdns_ipv4_scope);
222 if (r < 0)
223 log_link_warning_errno(l, r, "Failed to remove IPv4 DNS-SD services, ignoring: %m");
224 }
225
226 if (l->mdns_ipv6_scope) {
227 r = dns_scope_remove_dnssd_registered_services(l->mdns_ipv6_scope);
228 if (r < 0)
229 log_link_warning_errno(l, r, "Failed to remove IPv6 DNS-SD services, ignoring: %m");
230 }
231 }
232 }
233
234 int link_process_rtnl(Link *l, sd_netlink_message *m) {
235 const char *n = NULL;
236 int r;
237
238 assert(l);
239 assert(m);
240
241 r = sd_rtnl_message_link_get_flags(m, &l->flags);
242 if (r < 0)
243 return r;
244
245 (void) sd_netlink_message_read_u32(m, IFLA_MTU, &l->mtu);
246 (void) sd_netlink_message_read_u8(m, IFLA_OPERSTATE, &l->operstate);
247
248 if (sd_netlink_message_read_string(m, IFLA_IFNAME, &n) >= 0 &&
249 !streq_ptr(l->ifname, n)) {
250 if (l->ifname)
251 log_link_debug(l, "Interface name change detected: %s -> %s", l->ifname, n);
252
253 r = free_and_strdup(&l->ifname, n);
254 if (r < 0)
255 return r;
256 }
257
258 return 0;
259 }
260
261 static int link_update_dns_server_one(Link *l, const char *str) {
262 _cleanup_free_ char *name = NULL;
263 int family, ifindex, r;
264 union in_addr_union a;
265 DnsServer *s;
266 uint16_t port;
267
268 assert(l);
269 assert(str);
270
271 r = in_addr_port_ifindex_name_from_string_auto(str, &family, &a, &port, &ifindex, &name);
272 if (r < 0)
273 return r;
274
275 if (ifindex != 0 && ifindex != l->ifindex)
276 return -EINVAL;
277
278 /* By default, the port number is determined with the transaction feature level.
279 * See dns_transaction_port() and dns_server_port(). */
280 if (IN_SET(port, 53, 853))
281 port = 0;
282
283 s = dns_server_find(l->dns_servers, family, &a, port, 0, name);
284 if (s) {
285 dns_server_move_back_and_unmark(s);
286 return 0;
287 }
288
289 return dns_server_new(l->manager, /* ret= */ NULL, DNS_SERVER_LINK, l, /* delegate= */ NULL, family, &a, port, 0, name, RESOLVE_CONFIG_SOURCE_NETWORKD);
290 }
291
292 static int link_update_dns_servers(Link *l) {
293 _cleanup_strv_free_ char **nameservers = NULL;
294 int r;
295
296 assert(l);
297
298 r = sd_network_link_get_dns(l->ifindex, &nameservers);
299 if (r == -ENODATA) {
300 r = 0;
301 goto clear;
302 }
303 if (r < 0)
304 goto clear;
305
306 dns_server_mark_all(l->dns_servers);
307
308 STRV_FOREACH(nameserver, nameservers) {
309 r = link_update_dns_server_one(l, *nameserver);
310 if (r < 0)
311 goto clear;
312 }
313
314 dns_server_unlink_marked(l->dns_servers);
315
316 dns_server_reset_accessible_all(l->dns_servers);
317
318 return 0;
319
320 clear:
321 dns_server_unlink_all(l->dns_servers);
322 return r;
323 }
324
325 static int link_update_default_route(Link *l) {
326 int r;
327
328 assert(l);
329
330 r = sd_network_link_get_dns_default_route(l->ifindex);
331 if (r == -ENODATA) {
332 r = 0;
333 goto clear;
334 }
335 if (r < 0)
336 goto clear;
337
338 link_set_default_route(l, r > 0);
339 return 0;
340
341 clear:
342 l->default_route = -1;
343 return r;
344 }
345
346 static int link_update_llmnr_support(Link *l) {
347 _cleanup_free_ char *b = NULL;
348 int r;
349
350 assert(l);
351
352 l->llmnr_support = RESOLVE_SUPPORT_YES; /* yes, yes, we set it twice which is ugly */
353
354 r = sd_network_link_get_llmnr(l->ifindex, &b);
355 if (r == -ENODATA)
356 return 0;
357 if (r < 0)
358 return r;
359
360 r = resolve_support_from_string(b);
361 if (r < 0)
362 return r;
363
364 l->llmnr_support = r;
365 return 0;
366 }
367
368 static int link_update_mdns_support(Link *l) {
369 _cleanup_free_ char *b = NULL;
370 int r;
371
372 assert(l);
373
374 l->mdns_support = RESOLVE_SUPPORT_YES;
375
376 r = sd_network_link_get_mdns(l->ifindex, &b);
377 if (r == -ENODATA)
378 return 0;
379 if (r < 0)
380 return r;
381
382 r = resolve_support_from_string(b);
383 if (r < 0)
384 return r;
385
386 l->mdns_support = r;
387 return 0;
388 }
389
390 void link_set_dns_over_tls_mode(Link *l, DnsOverTlsMode mode) {
391
392 assert(l);
393
394 #if ! ENABLE_DNS_OVER_TLS
395 if (mode != DNS_OVER_TLS_NO)
396 log_link_warning(l,
397 "DNS-over-TLS option for the link cannot be enabled or set to opportunistic "
398 "when systemd-resolved is built without DNS-over-TLS support. "
399 "Turning off DNS-over-TLS support.");
400 return;
401 #endif
402
403 l->dns_over_tls_mode = mode;
404 l->unicast_scope = dns_scope_free(l->unicast_scope);
405 }
406
407 static int link_update_dns_over_tls_mode(Link *l) {
408 _cleanup_free_ char *b = NULL;
409 int r;
410
411 assert(l);
412
413 l->dns_over_tls_mode = _DNS_OVER_TLS_MODE_INVALID;
414
415 r = sd_network_link_get_dns_over_tls(l->ifindex, &b);
416 if (r == -ENODATA)
417 return 0;
418 if (r < 0)
419 return r;
420
421 r = dns_over_tls_mode_from_string(b);
422 if (r < 0)
423 return r;
424
425 l->dns_over_tls_mode = r;
426 return 0;
427 }
428
429 void link_set_dnssec_mode(Link *l, DnssecMode mode) {
430
431 assert(l);
432
433 #if !HAVE_OPENSSL
434 if (IN_SET(mode, DNSSEC_YES, DNSSEC_ALLOW_DOWNGRADE))
435 log_link_warning(l,
436 "DNSSEC option for the link cannot be enabled or set to allow-downgrade "
437 "when systemd-resolved is built without openssl. "
438 "Turning off DNSSEC support.");
439 return;
440 #endif
441
442 if (l->dnssec_mode == mode)
443 return;
444
445 l->dnssec_mode = mode;
446 l->unicast_scope = dns_scope_free(l->unicast_scope);
447 }
448
449 static int link_update_dnssec_mode(Link *l) {
450 _cleanup_free_ char *m = NULL;
451 DnssecMode mode;
452 int r;
453
454 assert(l);
455
456 l->dnssec_mode = _DNSSEC_MODE_INVALID;
457
458 r = sd_network_link_get_dnssec(l->ifindex, &m);
459 if (r == -ENODATA)
460 return 0;
461 if (r < 0)
462 return r;
463
464 mode = dnssec_mode_from_string(m);
465 if (mode < 0)
466 return mode;
467
468 link_set_dnssec_mode(l, mode);
469 return 0;
470 }
471
472 static int link_update_dnssec_negative_trust_anchors(Link *l) {
473 _cleanup_strv_free_ char **ntas = NULL;
474 _cleanup_set_free_ Set *ns = NULL;
475 int r;
476
477 assert(l);
478
479 l->dnssec_negative_trust_anchors = set_free(l->dnssec_negative_trust_anchors);
480
481 r = sd_network_link_get_dnssec_negative_trust_anchors(l->ifindex, &ntas);
482 if (r == -ENODATA)
483 return 0;
484 if (r < 0)
485 return r;
486
487 r = set_put_strdupv_full(&ns, &dns_name_hash_ops_free, ntas);
488 if (r < 0)
489 return r;
490
491 l->dnssec_negative_trust_anchors = TAKE_PTR(ns);
492 return 0;
493 }
494
495 static int link_update_search_domain_one(Link *l, const char *name, bool route_only) {
496 DnsSearchDomain *d;
497 int r;
498
499 assert(l);
500 assert(name);
501
502 r = dns_search_domain_find(l->search_domains, name, &d);
503 if (r < 0)
504 return r;
505 if (r > 0)
506 dns_search_domain_move_back_and_unmark(d);
507 else {
508 r = dns_search_domain_new(l->manager, &d, DNS_SEARCH_DOMAIN_LINK, l, /* delegate= */ NULL, name);
509 if (r < 0)
510 return r;
511 }
512
513 d->route_only = route_only;
514 return 0;
515 }
516
517 static int link_update_search_domains(Link *l) {
518 _cleanup_strv_free_ char **sdomains = NULL, **rdomains = NULL;
519 int r, q;
520
521 assert(l);
522
523 r = sd_network_link_get_search_domains(l->ifindex, &sdomains);
524 if (r < 0 && r != -ENODATA)
525 goto clear;
526
527 q = sd_network_link_get_route_domains(l->ifindex, &rdomains);
528 if (q < 0 && q != -ENODATA) {
529 r = q;
530 goto clear;
531 }
532
533 if (r == -ENODATA && q == -ENODATA) {
534 /* networkd knows nothing about this interface, and that's fine. */
535 r = 0;
536 goto clear;
537 }
538
539 dns_search_domain_mark_all(l->search_domains);
540
541 STRV_FOREACH(i, sdomains) {
542 r = link_update_search_domain_one(l, *i, false);
543 if (r < 0)
544 goto clear;
545 }
546
547 STRV_FOREACH(i, rdomains) {
548 r = link_update_search_domain_one(l, *i, true);
549 if (r < 0)
550 goto clear;
551 }
552
553 dns_search_domain_unlink_marked(l->search_domains);
554 return 0;
555
556 clear:
557 dns_search_domain_unlink_all(l->search_domains);
558 return r;
559 }
560
561 static int link_is_managed(Link *l) {
562 _cleanup_free_ char *state = NULL;
563 int r;
564
565 assert(l);
566
567 r = sd_network_link_get_setup_state(l->ifindex, &state);
568 if (r == -ENODATA)
569 return 0;
570 if (r < 0)
571 return r;
572
573 return !STR_IN_SET(state, "pending", "initialized", "unmanaged");
574 }
575
576 static void link_enter_unmanaged(Link *l) {
577 assert(l);
578
579 /* If this link used to be managed, but is now unmanaged, flush all our settings — but only once. */
580 if (l->is_managed)
581 link_flush_settings(l);
582
583 l->is_managed = false;
584 }
585
586 static void link_read_settings(Link *l) {
587 struct stat st;
588 int r;
589
590 assert(l);
591
592 /* Read settings from networkd, except when networkd is not managing this interface. */
593
594 r = sd_network_link_get_stat(l->ifindex, &st);
595 if (r == -ENOENT)
596 return link_enter_unmanaged(l);
597 if (r < 0)
598 return (void) log_link_warning_errno(l, r, "Failed to stat() networkd's link state file, ignoring: %m");
599
600 if (stat_inode_unmodified(&l->networkd_state_file_stat, &st))
601 /* The state file is unmodified. Not necessary to re-read settings. */
602 return;
603
604 /* Save the new stat for the next event. */
605 l->networkd_state_file_stat = st;
606
607 r = link_is_managed(l);
608 if (r < 0)
609 return (void) log_link_warning_errno(l, r, "Failed to determine whether the interface is managed, ignoring: %m");
610 if (r == 0)
611 return link_enter_unmanaged(l);
612
613 l->is_managed = true;
614
615 r = network_link_get_operational_state(l->ifindex, &l->networkd_operstate);
616 if (r < 0)
617 log_link_warning_errno(l, r, "Failed to read networkd's link operational state, ignoring: %m");
618
619 r = link_update_dns_servers(l);
620 if (r < 0)
621 log_link_warning_errno(l, r, "Failed to read DNS servers for the interface, ignoring: %m");
622
623 r = link_update_llmnr_support(l);
624 if (r < 0)
625 log_link_warning_errno(l, r, "Failed to read LLMNR support for the interface, ignoring: %m");
626
627 r = link_update_mdns_support(l);
628 if (r < 0)
629 log_link_warning_errno(l, r, "Failed to read mDNS support for the interface, ignoring: %m");
630
631 r = link_update_dns_over_tls_mode(l);
632 if (r < 0)
633 log_link_warning_errno(l, r, "Failed to read DNS-over-TLS mode for the interface, ignoring: %m");
634
635 r = link_update_dnssec_mode(l);
636 if (r < 0)
637 log_link_warning_errno(l, r, "Failed to read DNSSEC mode for the interface, ignoring: %m");
638
639 r = link_update_dnssec_negative_trust_anchors(l);
640 if (r < 0)
641 log_link_warning_errno(l, r, "Failed to read DNSSEC negative trust anchors for the interface, ignoring: %m");
642
643 r = link_update_search_domains(l);
644 if (r < 0)
645 log_link_warning_errno(l, r, "Failed to read search domains for the interface, ignoring: %m");
646
647 r = link_update_default_route(l);
648 if (r < 0)
649 log_link_warning_errno(l, r, "Failed to read default route setting for the interface, proceeding anyway: %m");
650 }
651
652 int link_update(Link *l) {
653 int r;
654
655 assert(l);
656
657 link_read_settings(l);
658 r = link_load_user(l);
659 if (r < 0)
660 return r;
661
662 if (link_get_llmnr_support(l) != RESOLVE_SUPPORT_NO) {
663 r = manager_llmnr_start(l->manager);
664 if (r < 0)
665 return r;
666 }
667
668 if (link_get_mdns_support(l) != RESOLVE_SUPPORT_NO) {
669 r = manager_mdns_start(l->manager);
670 if (r < 0)
671 return r;
672 }
673
674 link_allocate_scopes(l);
675 link_add_rrs(l, false);
676
677 return 0;
678 }
679
680 static bool link_has_link_local_dns(Link *l, int family) {
681
682 /* Check if the link has a link-local dns server for the specified family */
683
684 LIST_FOREACH(servers, s, l->dns_servers)
685 if ((family == AF_UNSPEC || s->family == family) &&
686 in_addr_is_link_local(s->family, &s->address))
687 return true;
688
689 return false;
690 }
691
692 bool link_relevant(Link *l, int family, bool local_multicast) {
693 bool allow_link_local;
694
695 assert(l);
696
697 /*
698 * A link is relevant if:
699 * - it isn't a loopback device
700 * - has a link beat
701 * - for multicast traffic:
702 * - can do multicast
703 * - has at least one link-local (or better) IP address.
704 * - for non-multicast traffic:
705 * - has at least one address that must be:
706 * - At least link-local, if using a link-local dns server to this interface.
707 * - Better than link-local.
708 */
709
710 if ((l->flags & (IFF_LOOPBACK | IFF_DORMANT)) != 0)
711 return false;
712
713 if (!FLAGS_SET(l->flags, IFF_UP | IFF_LOWER_UP))
714 return false;
715
716 if (local_multicast &&
717 !FLAGS_SET(l->flags, IFF_MULTICAST))
718 return false;
719
720 if (!netif_has_carrier(l->operstate, l->flags))
721 return false;
722
723 if (l->is_managed &&
724 !IN_SET(l->networkd_operstate, LINK_OPERSTATE_DEGRADED_CARRIER, LINK_OPERSTATE_DEGRADED, LINK_OPERSTATE_ROUTABLE))
725 return false;
726
727 allow_link_local = local_multicast || link_has_link_local_dns(l, family);
728
729 LIST_FOREACH(addresses, a, l->addresses)
730 if ((family == AF_UNSPEC || a->family == family) &&
731 link_address_relevant(a, allow_link_local))
732 return true;
733
734 return false;
735 }
736
737 LinkAddress *link_find_address(Link *l, int family, const union in_addr_union *in_addr) {
738 assert(l);
739
740 if (!IN_SET(family, AF_INET, AF_INET6))
741 return NULL;
742
743 if (!in_addr)
744 return NULL;
745
746 LIST_FOREACH(addresses, a, l->addresses)
747 if (a->family == family && in_addr_equal(family, &a->in_addr, in_addr))
748 return a;
749
750 return NULL;
751 }
752
753 DnsServer* link_set_dns_server(Link *l, DnsServer *s) {
754 assert(l);
755
756 if (l->current_dns_server == s)
757 return s;
758
759 if (s)
760 log_link_debug(l, "Switching to DNS server %s.", strna(dns_server_string_full(s)));
761
762 dns_server_unref(l->current_dns_server);
763 l->current_dns_server = dns_server_ref(s);
764
765 /* Skip flushing the cache if server stale feature is enabled. */
766 if (l->unicast_scope && l->manager->stale_retention_usec == 0)
767 dns_cache_flush(&l->unicast_scope->cache);
768
769 return s;
770 }
771
772 DnsServer *link_get_dns_server(Link *l) {
773 assert(l);
774
775 if (!l->current_dns_server)
776 link_set_dns_server(l, l->dns_servers);
777
778 return l->current_dns_server;
779 }
780
781 void link_next_dns_server(Link *l, DnsServer *if_current) {
782 assert(l);
783
784 /* If the current server of the transaction is specified, and we already are at a different one,
785 * don't do anything */
786 if (if_current && l->current_dns_server != if_current)
787 return;
788
789 /* If currently have no DNS server, then don't do anything, we'll pick it lazily the next time a DNS
790 * server is needed. */
791 if (!l->current_dns_server)
792 return;
793
794 /* Change to the next one, but make sure to follow the linked list only if this server is actually
795 * still linked. */
796 if (l->current_dns_server->linked && l->current_dns_server->servers_next) {
797 link_set_dns_server(l, l->current_dns_server->servers_next);
798 return;
799 }
800
801 /* Pick the first one again, after we reached the end */
802 link_set_dns_server(l, l->dns_servers);
803 }
804
805 void link_set_default_route(Link *l, bool b) {
806 assert(l);
807
808 if (l->default_route == b)
809 return;
810
811 l->default_route = b;
812
813 /* If we are currently using the fallback servers, changing a link to be default-route means
814 * we should reconsider whether or not the fallback servers are necessary. */
815 if (b && dns_server_is_fallback(l->manager->current_dns_server))
816 manager_set_dns_server(l->manager, NULL);
817 }
818
819 DnsOverTlsMode link_get_dns_over_tls_mode(Link *l) {
820 assert(l);
821
822 if (l->dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID)
823 return l->dns_over_tls_mode;
824
825 return manager_get_dns_over_tls_mode(l->manager);
826 }
827
828 DnssecMode link_get_dnssec_mode(Link *l) {
829 assert(l);
830
831 if (l->dnssec_mode != _DNSSEC_MODE_INVALID)
832 return l->dnssec_mode;
833
834 return manager_get_dnssec_mode(l->manager);
835 }
836
837 bool link_dnssec_supported(Link *l) {
838 DnsServer *server;
839
840 assert(l);
841
842 if (link_get_dnssec_mode(l) == DNSSEC_NO)
843 return false;
844
845 server = link_get_dns_server(l);
846 if (server)
847 return dns_server_dnssec_supported(server);
848
849 return true;
850 }
851
852 ResolveSupport link_get_llmnr_support(Link *link) {
853 assert(link);
854 assert(link->manager);
855
856 /* This provides the effective LLMNR support level for the link, instead of the 'internal' per-link setting. */
857
858 return MIN(link->llmnr_support, link->manager->llmnr_support);
859 }
860
861 ResolveSupport link_get_mdns_support(Link *link) {
862 assert(link);
863 assert(link->manager);
864
865 /* This provides the effective mDNS support level for the link, instead of the 'internal' per-link setting. */
866
867 return MIN(link->mdns_support, link->manager->mdns_support);
868 }
869
870 bool link_get_default_route(Link *l) {
871 assert(l);
872
873 /* Return what is configured, if there's something configured */
874 if (l->default_route >= 0)
875 return l->default_route;
876
877 /* Otherwise report what is in effect */
878 if (l->unicast_scope)
879 return dns_scope_is_default_route(l->unicast_scope);
880
881 return false;
882 }
883
884 int link_address_new(Link *l,
885 LinkAddress **ret,
886 int family,
887 const union in_addr_union *in_addr,
888 const union in_addr_union *in_addr_broadcast) {
889 LinkAddress *a;
890
891 assert(l);
892 assert(in_addr);
893 assert(in_addr_broadcast);
894
895 a = new(LinkAddress, 1);
896 if (!a)
897 return -ENOMEM;
898
899 *a = (LinkAddress) {
900 .family = family,
901 .in_addr = *in_addr,
902 .in_addr_broadcast = *in_addr_broadcast,
903 .link = l,
904 .prefixlen = UCHAR_MAX,
905 };
906
907 LIST_PREPEND(addresses, l->addresses, a);
908 l->n_addresses++;
909
910 if (ret)
911 *ret = a;
912
913 return 0;
914 }
915
916 LinkAddress *link_address_free(LinkAddress *a) {
917 if (!a)
918 return NULL;
919
920 if (a->link) {
921 LIST_REMOVE(addresses, a->link->addresses, a);
922
923 assert(a->link->n_addresses > 0);
924 a->link->n_addresses--;
925
926 if (a->llmnr_address_rr) {
927 if (a->family == AF_INET && a->link->llmnr_ipv4_scope)
928 dns_zone_remove_rr(&a->link->llmnr_ipv4_scope->zone, a->llmnr_address_rr);
929 else if (a->family == AF_INET6 && a->link->llmnr_ipv6_scope)
930 dns_zone_remove_rr(&a->link->llmnr_ipv6_scope->zone, a->llmnr_address_rr);
931 }
932
933 if (a->llmnr_ptr_rr) {
934 if (a->family == AF_INET && a->link->llmnr_ipv4_scope)
935 dns_zone_remove_rr(&a->link->llmnr_ipv4_scope->zone, a->llmnr_ptr_rr);
936 else if (a->family == AF_INET6 && a->link->llmnr_ipv6_scope)
937 dns_zone_remove_rr(&a->link->llmnr_ipv6_scope->zone, a->llmnr_ptr_rr);
938 }
939
940 if (a->mdns_address_rr) {
941 if (a->family == AF_INET && a->link->mdns_ipv4_scope)
942 dns_zone_remove_rr(&a->link->mdns_ipv4_scope->zone, a->mdns_address_rr);
943 else if (a->family == AF_INET6 && a->link->mdns_ipv6_scope)
944 dns_zone_remove_rr(&a->link->mdns_ipv6_scope->zone, a->mdns_address_rr);
945 }
946
947 if (a->mdns_ptr_rr) {
948 if (a->family == AF_INET && a->link->mdns_ipv4_scope)
949 dns_zone_remove_rr(&a->link->mdns_ipv4_scope->zone, a->mdns_ptr_rr);
950 else if (a->family == AF_INET6 && a->link->mdns_ipv6_scope)
951 dns_zone_remove_rr(&a->link->mdns_ipv6_scope->zone, a->mdns_ptr_rr);
952 }
953 }
954
955 dns_resource_record_unref(a->llmnr_address_rr);
956 dns_resource_record_unref(a->llmnr_ptr_rr);
957 dns_resource_record_unref(a->mdns_address_rr);
958 dns_resource_record_unref(a->mdns_ptr_rr);
959
960 return mfree(a);
961 }
962
963 void link_address_add_rrs(LinkAddress *a, bool force_remove) {
964 int r;
965
966 assert(a);
967
968 if (a->family == AF_INET) {
969
970 if (!force_remove &&
971 link_address_relevant(a, true) &&
972 a->link->llmnr_ipv4_scope &&
973 link_get_llmnr_support(a->link) == RESOLVE_SUPPORT_YES) {
974
975 if (!a->link->manager->llmnr_host_ipv4_key) {
976 a->link->manager->llmnr_host_ipv4_key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, a->link->manager->llmnr_hostname);
977 if (!a->link->manager->llmnr_host_ipv4_key) {
978 r = -ENOMEM;
979 goto fail;
980 }
981 }
982
983 if (!a->llmnr_address_rr) {
984 a->llmnr_address_rr = dns_resource_record_new(a->link->manager->llmnr_host_ipv4_key);
985 if (!a->llmnr_address_rr) {
986 r = -ENOMEM;
987 goto fail;
988 }
989
990 a->llmnr_address_rr->a.in_addr = a->in_addr.in;
991 a->llmnr_address_rr->ttl = LLMNR_DEFAULT_TTL;
992 }
993
994 if (!a->llmnr_ptr_rr) {
995 r = dns_resource_record_new_reverse(&a->llmnr_ptr_rr, a->family, &a->in_addr, a->link->manager->llmnr_hostname);
996 if (r < 0)
997 goto fail;
998
999 a->llmnr_ptr_rr->ttl = LLMNR_DEFAULT_TTL;
1000 }
1001
1002 r = dns_zone_put(&a->link->llmnr_ipv4_scope->zone, a->link->llmnr_ipv4_scope, a->llmnr_address_rr, true);
1003 if (r < 0)
1004 log_link_warning_errno(a->link, r, "Failed to add A record to LLMNR zone, ignoring: %m");
1005
1006 r = dns_zone_put(&a->link->llmnr_ipv4_scope->zone, a->link->llmnr_ipv4_scope, a->llmnr_ptr_rr, false);
1007 if (r < 0)
1008 log_link_warning_errno(a->link, r, "Failed to add IPv4 PTR record to LLMNR zone, ignoring: %m");
1009 } else {
1010 if (a->llmnr_address_rr) {
1011 if (a->link->llmnr_ipv4_scope)
1012 dns_zone_remove_rr(&a->link->llmnr_ipv4_scope->zone, a->llmnr_address_rr);
1013 a->llmnr_address_rr = dns_resource_record_unref(a->llmnr_address_rr);
1014 }
1015
1016 if (a->llmnr_ptr_rr) {
1017 if (a->link->llmnr_ipv4_scope)
1018 dns_zone_remove_rr(&a->link->llmnr_ipv4_scope->zone, a->llmnr_ptr_rr);
1019 a->llmnr_ptr_rr = dns_resource_record_unref(a->llmnr_ptr_rr);
1020 }
1021 }
1022
1023 if (!force_remove &&
1024 link_address_relevant(a, true) &&
1025 a->link->mdns_ipv4_scope &&
1026 link_get_mdns_support(a->link) == RESOLVE_SUPPORT_YES) {
1027 if (!a->link->manager->mdns_host_ipv4_key) {
1028 a->link->manager->mdns_host_ipv4_key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, a->link->manager->mdns_hostname);
1029 if (!a->link->manager->mdns_host_ipv4_key) {
1030 r = -ENOMEM;
1031 goto fail;
1032 }
1033 }
1034
1035 if (!a->mdns_address_rr) {
1036 a->mdns_address_rr = dns_resource_record_new(a->link->manager->mdns_host_ipv4_key);
1037 if (!a->mdns_address_rr) {
1038 r = -ENOMEM;
1039 goto fail;
1040 }
1041
1042 a->mdns_address_rr->a.in_addr = a->in_addr.in;
1043 a->mdns_address_rr->ttl = MDNS_DEFAULT_TTL;
1044 }
1045
1046 if (!a->mdns_ptr_rr) {
1047 r = dns_resource_record_new_reverse(&a->mdns_ptr_rr, a->family, &a->in_addr, a->link->manager->mdns_hostname);
1048 if (r < 0)
1049 goto fail;
1050
1051 a->mdns_ptr_rr->ttl = MDNS_DEFAULT_TTL;
1052 }
1053
1054 r = dns_zone_put(&a->link->mdns_ipv4_scope->zone, a->link->mdns_ipv4_scope, a->mdns_address_rr, true);
1055 if (r < 0)
1056 log_link_warning_errno(a->link, r, "Failed to add A record to MDNS zone, ignoring: %m");
1057
1058 r = dns_zone_put(&a->link->mdns_ipv4_scope->zone, a->link->mdns_ipv4_scope, a->mdns_ptr_rr, false);
1059 if (r < 0)
1060 log_link_warning_errno(a->link, r, "Failed to add IPv4 PTR record to MDNS zone, ignoring: %m");
1061 } else {
1062 if (a->mdns_address_rr) {
1063 if (a->link->mdns_ipv4_scope)
1064 dns_zone_remove_rr(&a->link->mdns_ipv4_scope->zone, a->mdns_address_rr);
1065 a->mdns_address_rr = dns_resource_record_unref(a->mdns_address_rr);
1066 }
1067
1068 if (a->mdns_ptr_rr) {
1069 if (a->link->mdns_ipv4_scope)
1070 dns_zone_remove_rr(&a->link->mdns_ipv4_scope->zone, a->mdns_ptr_rr);
1071 a->mdns_ptr_rr = dns_resource_record_unref(a->mdns_ptr_rr);
1072 }
1073 }
1074 }
1075
1076 if (a->family == AF_INET6) {
1077
1078 if (!force_remove &&
1079 link_address_relevant(a, true) &&
1080 a->link->llmnr_ipv6_scope &&
1081 link_get_llmnr_support(a->link) == RESOLVE_SUPPORT_YES) {
1082
1083 if (!a->link->manager->llmnr_host_ipv6_key) {
1084 a->link->manager->llmnr_host_ipv6_key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_AAAA, a->link->manager->llmnr_hostname);
1085 if (!a->link->manager->llmnr_host_ipv6_key) {
1086 r = -ENOMEM;
1087 goto fail;
1088 }
1089 }
1090
1091 if (!a->llmnr_address_rr) {
1092 a->llmnr_address_rr = dns_resource_record_new(a->link->manager->llmnr_host_ipv6_key);
1093 if (!a->llmnr_address_rr) {
1094 r = -ENOMEM;
1095 goto fail;
1096 }
1097
1098 a->llmnr_address_rr->aaaa.in6_addr = a->in_addr.in6;
1099 a->llmnr_address_rr->ttl = LLMNR_DEFAULT_TTL;
1100 }
1101
1102 if (!a->llmnr_ptr_rr) {
1103 r = dns_resource_record_new_reverse(&a->llmnr_ptr_rr, a->family, &a->in_addr, a->link->manager->llmnr_hostname);
1104 if (r < 0)
1105 goto fail;
1106
1107 a->llmnr_ptr_rr->ttl = LLMNR_DEFAULT_TTL;
1108 }
1109
1110 r = dns_zone_put(&a->link->llmnr_ipv6_scope->zone, a->link->llmnr_ipv6_scope, a->llmnr_address_rr, true);
1111 if (r < 0)
1112 log_link_warning_errno(a->link, r, "Failed to add AAAA record to LLMNR zone, ignoring: %m");
1113
1114 r = dns_zone_put(&a->link->llmnr_ipv6_scope->zone, a->link->llmnr_ipv6_scope, a->llmnr_ptr_rr, false);
1115 if (r < 0)
1116 log_link_warning_errno(a->link, r, "Failed to add IPv6 PTR record to LLMNR zone, ignoring: %m");
1117 } else {
1118 if (a->llmnr_address_rr) {
1119 if (a->link->llmnr_ipv6_scope)
1120 dns_zone_remove_rr(&a->link->llmnr_ipv6_scope->zone, a->llmnr_address_rr);
1121 a->llmnr_address_rr = dns_resource_record_unref(a->llmnr_address_rr);
1122 }
1123
1124 if (a->llmnr_ptr_rr) {
1125 if (a->link->llmnr_ipv6_scope)
1126 dns_zone_remove_rr(&a->link->llmnr_ipv6_scope->zone, a->llmnr_ptr_rr);
1127 a->llmnr_ptr_rr = dns_resource_record_unref(a->llmnr_ptr_rr);
1128 }
1129 }
1130
1131 if (!force_remove &&
1132 link_address_relevant(a, true) &&
1133 a->link->mdns_ipv6_scope &&
1134 link_get_mdns_support(a->link) == RESOLVE_SUPPORT_YES) {
1135
1136 if (!a->link->manager->mdns_host_ipv6_key) {
1137 a->link->manager->mdns_host_ipv6_key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_AAAA, a->link->manager->mdns_hostname);
1138 if (!a->link->manager->mdns_host_ipv6_key) {
1139 r = -ENOMEM;
1140 goto fail;
1141 }
1142 }
1143
1144 if (!a->mdns_address_rr) {
1145 a->mdns_address_rr = dns_resource_record_new(a->link->manager->mdns_host_ipv6_key);
1146 if (!a->mdns_address_rr) {
1147 r = -ENOMEM;
1148 goto fail;
1149 }
1150
1151 a->mdns_address_rr->aaaa.in6_addr = a->in_addr.in6;
1152 a->mdns_address_rr->ttl = MDNS_DEFAULT_TTL;
1153 }
1154
1155 if (!a->mdns_ptr_rr) {
1156 r = dns_resource_record_new_reverse(&a->mdns_ptr_rr, a->family, &a->in_addr, a->link->manager->mdns_hostname);
1157 if (r < 0)
1158 goto fail;
1159
1160 a->mdns_ptr_rr->ttl = MDNS_DEFAULT_TTL;
1161 }
1162
1163 r = dns_zone_put(&a->link->mdns_ipv6_scope->zone, a->link->mdns_ipv6_scope, a->mdns_address_rr, true);
1164 if (r < 0)
1165 log_link_warning_errno(a->link, r, "Failed to add AAAA record to MDNS zone, ignoring: %m");
1166
1167 r = dns_zone_put(&a->link->mdns_ipv6_scope->zone, a->link->mdns_ipv6_scope, a->mdns_ptr_rr, false);
1168 if (r < 0)
1169 log_link_warning_errno(a->link, r, "Failed to add IPv6 PTR record to MDNS zone, ignoring: %m");
1170 } else {
1171 if (a->mdns_address_rr) {
1172 if (a->link->mdns_ipv6_scope)
1173 dns_zone_remove_rr(&a->link->mdns_ipv6_scope->zone, a->mdns_address_rr);
1174 a->mdns_address_rr = dns_resource_record_unref(a->mdns_address_rr);
1175 }
1176
1177 if (a->mdns_ptr_rr) {
1178 if (a->link->mdns_ipv6_scope)
1179 dns_zone_remove_rr(&a->link->mdns_ipv6_scope->zone, a->mdns_ptr_rr);
1180 a->mdns_ptr_rr = dns_resource_record_unref(a->mdns_ptr_rr);
1181 }
1182 }
1183 }
1184
1185 return;
1186
1187 fail:
1188 log_link_debug_errno(a->link, r, "Failed to update address RRs, ignoring: %m");
1189 }
1190
1191 int link_address_update_rtnl(LinkAddress *a, sd_netlink_message *m) {
1192 int r;
1193
1194 assert(a);
1195 assert(m);
1196
1197 r = sd_netlink_message_read_u32(m, IFA_FLAGS, &a->flags);
1198 if (r < 0)
1199 return r;
1200
1201 (void) sd_rtnl_message_addr_get_prefixlen(m, &a->prefixlen);
1202 (void) sd_rtnl_message_addr_get_scope(m, &a->scope);
1203
1204 link_allocate_scopes(a->link);
1205 link_add_rrs(a->link, false);
1206
1207 return 0;
1208 }
1209
1210 bool link_address_relevant(LinkAddress *a, bool allow_link_local) {
1211 assert(a);
1212
1213 if (a->flags & (IFA_F_DEPRECATED|IFA_F_TENTATIVE))
1214 return false;
1215
1216 if (a->scope >= (allow_link_local ? RT_SCOPE_HOST : RT_SCOPE_LINK))
1217 return false;
1218
1219 return true;
1220 }
1221
1222 static bool link_needs_save(Link *l) {
1223 assert(l);
1224
1225 /* Returns true if any of the settings where set different from the default */
1226
1227 if (l->is_managed)
1228 return false;
1229
1230 if (l->llmnr_support != RESOLVE_SUPPORT_YES ||
1231 l->mdns_support != RESOLVE_SUPPORT_YES ||
1232 l->dnssec_mode != _DNSSEC_MODE_INVALID ||
1233 l->dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID)
1234 return true;
1235
1236 if (l->dns_servers ||
1237 l->search_domains)
1238 return true;
1239
1240 if (!set_isempty(l->dnssec_negative_trust_anchors))
1241 return true;
1242
1243 if (l->default_route >= 0)
1244 return true;
1245
1246 return false;
1247 }
1248
1249 int link_save_user(Link *l) {
1250 _cleanup_(unlink_and_freep) char *temp_path = NULL;
1251 _cleanup_fclose_ FILE *f = NULL;
1252 const char *v;
1253 int r;
1254
1255 assert(l);
1256 assert(l->state_file);
1257
1258 if (!link_needs_save(l)) {
1259 (void) unlink(l->state_file);
1260 return 0;
1261 }
1262
1263 r = mkdir_parents(l->state_file, 0700);
1264 if (r < 0)
1265 goto fail;
1266
1267 r = fopen_temporary(l->state_file, &f, &temp_path);
1268 if (r < 0)
1269 goto fail;
1270
1271 (void) fchmod(fileno(f), 0644);
1272
1273 fputs("# This is private data. Do not parse.\n", f);
1274
1275 v = resolve_support_to_string(l->llmnr_support);
1276 if (v)
1277 fprintf(f, "LLMNR=%s\n", v);
1278
1279 v = resolve_support_to_string(l->mdns_support);
1280 if (v)
1281 fprintf(f, "MDNS=%s\n", v);
1282
1283 v = dnssec_mode_to_string(l->dnssec_mode);
1284 if (v)
1285 fprintf(f, "DNSSEC=%s\n", v);
1286
1287 v = dns_over_tls_mode_to_string(l->dns_over_tls_mode);
1288 if (v)
1289 fprintf(f, "DNSOVERTLS=%s\n", v);
1290
1291 if (l->default_route >= 0)
1292 fprintf(f, "DEFAULT_ROUTE=%s\n", yes_no(l->default_route));
1293
1294 if (l->dns_servers) {
1295 fputs("SERVERS=", f);
1296 LIST_FOREACH(servers, server, l->dns_servers) {
1297
1298 if (server != l->dns_servers)
1299 fputc(' ', f);
1300
1301 v = dns_server_string_full(server);
1302 if (!v) {
1303 r = -ENOMEM;
1304 goto fail;
1305 }
1306
1307 fputs(v, f);
1308 }
1309 fputc('\n', f);
1310 }
1311
1312 if (l->search_domains) {
1313 fputs("DOMAINS=", f);
1314 LIST_FOREACH(domains, domain, l->search_domains) {
1315
1316 if (domain != l->search_domains)
1317 fputc(' ', f);
1318
1319 if (domain->route_only)
1320 fputc('~', f);
1321
1322 fputs(DNS_SEARCH_DOMAIN_NAME(domain), f);
1323 }
1324 fputc('\n', f);
1325 }
1326
1327 if (!set_isempty(l->dnssec_negative_trust_anchors)) {
1328 bool space = false;
1329 char *nta;
1330
1331 fputs("NTAS=", f);
1332 SET_FOREACH(nta, l->dnssec_negative_trust_anchors) {
1333
1334 if (space)
1335 fputc(' ', f);
1336
1337 fputs(nta, f);
1338 space = true;
1339 }
1340 fputc('\n', f);
1341 }
1342
1343 r = fflush_and_check(f);
1344 if (r < 0)
1345 goto fail;
1346
1347 if (rename(temp_path, l->state_file) < 0) {
1348 r = -errno;
1349 goto fail;
1350 }
1351
1352 temp_path = mfree(temp_path);
1353
1354 return 0;
1355
1356 fail:
1357 (void) unlink(l->state_file);
1358
1359 return log_link_error_errno(l, r, "Failed to save link data %s: %m", l->state_file);
1360 }
1361
1362 int link_load_user(Link *l) {
1363 _cleanup_free_ char
1364 *llmnr = NULL,
1365 *mdns = NULL,
1366 *dnssec = NULL,
1367 *dns_over_tls = NULL,
1368 *servers = NULL,
1369 *domains = NULL,
1370 *ntas = NULL,
1371 *default_route = NULL;
1372
1373 ResolveSupport s;
1374 const char *p;
1375 int r;
1376
1377 assert(l);
1378 assert(l->state_file);
1379
1380 /* Try to load only a single time */
1381 if (l->loaded)
1382 return 0;
1383 l->loaded = true;
1384
1385 if (l->is_managed)
1386 return 0; /* if the device is managed, then networkd is our configuration source, not the bus API */
1387
1388 r = parse_env_file(NULL, l->state_file,
1389 "LLMNR", &llmnr,
1390 "MDNS", &mdns,
1391 "DNSSEC", &dnssec,
1392 "DNSOVERTLS", &dns_over_tls,
1393 "SERVERS", &servers,
1394 "DOMAINS", &domains,
1395 "NTAS", &ntas,
1396 "DEFAULT_ROUTE", &default_route);
1397 if (r == -ENOENT)
1398 return 0;
1399 if (r < 0)
1400 goto fail;
1401
1402 link_flush_settings(l);
1403
1404 /* If we can't recognize the LLMNR or MDNS setting we don't override the default */
1405 s = resolve_support_from_string(llmnr);
1406 if (s >= 0)
1407 l->llmnr_support = s;
1408
1409 s = resolve_support_from_string(mdns);
1410 if (s >= 0)
1411 l->mdns_support = s;
1412
1413 r = parse_boolean(default_route);
1414 if (r >= 0)
1415 l->default_route = r;
1416
1417 /* If we can't recognize the DNSSEC setting, then set it to invalid, so that the daemon default is used. */
1418 l->dnssec_mode = dnssec_mode_from_string(dnssec);
1419
1420 /* Same for DNSOverTLS */
1421 l->dns_over_tls_mode = dns_over_tls_mode_from_string(dns_over_tls);
1422
1423 for (p = servers;;) {
1424 _cleanup_free_ char *word = NULL;
1425
1426 r = extract_first_word(&p, &word, NULL, 0);
1427 if (r < 0)
1428 goto fail;
1429 if (r == 0)
1430 break;
1431
1432 r = link_update_dns_server_one(l, word);
1433 if (r < 0) {
1434 log_link_debug_errno(l, r, "Failed to load DNS server '%s', ignoring: %m", word);
1435 continue;
1436 }
1437 }
1438
1439 for (p = domains;;) {
1440 _cleanup_free_ char *word = NULL;
1441 const char *n;
1442 bool is_route;
1443
1444 r = extract_first_word(&p, &word, NULL, 0);
1445 if (r < 0)
1446 goto fail;
1447 if (r == 0)
1448 break;
1449
1450 is_route = word[0] == '~';
1451 n = is_route ? word + 1 : word;
1452
1453 r = link_update_search_domain_one(l, n, is_route);
1454 if (r < 0) {
1455 log_link_debug_errno(l, r, "Failed to load search domain '%s', ignoring: %m", word);
1456 continue;
1457 }
1458 }
1459
1460 if (ntas) {
1461 _cleanup_set_free_ Set *ns = NULL;
1462
1463 ns = set_new(&dns_name_hash_ops_free);
1464 if (!ns) {
1465 r = -ENOMEM;
1466 goto fail;
1467 }
1468
1469 r = set_put_strsplit(ns, ntas, NULL, 0);
1470 if (r < 0)
1471 goto fail;
1472
1473 l->dnssec_negative_trust_anchors = TAKE_PTR(ns);
1474 }
1475
1476 return 0;
1477
1478 fail:
1479 return log_link_error_errno(l, r, "Failed to load link data %s: %m", l->state_file);
1480 }
1481
1482 void link_remove_user(Link *l) {
1483 assert(l);
1484 assert(l->state_file);
1485
1486 (void) unlink(l->state_file);
1487 }
1488
1489 bool link_negative_trust_anchor_lookup(Link *l, const char *name) {
1490 int r;
1491
1492 assert(l);
1493 assert(name);
1494
1495 /* Checks whether the specified domain (or any of its parent domains) are listed as per-link NTA. */
1496
1497 for (;;) {
1498 if (set_contains(l->dnssec_negative_trust_anchors, name))
1499 return true;
1500
1501 /* And now, let's look at the parent, and check that too */
1502 r = dns_name_parent(&name);
1503 if (r < 0)
1504 return r;
1505 if (r == 0)
1506 break;
1507 }
1508
1509 return false;
1510 }