Debian Codegraph @

src/resolve/resolved-dns-server.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "sd-event.h"
4 #include "sd-messages.h"
5
6 #include "alloc-util.h"
7 #include "dns-domain.h"
8 #include "dns-packet.h"
9 #include "errno-util.h"
10 #include "extract-word.h"
11 #include "fd-util.h"
12 #include "hash-funcs.h"
13 #include "json-util.h"
14 #include "resolved-bus.h"
15 #include "resolved-dns-cache.h"
16 #include "resolved-dns-delegate.h"
17 #include "resolved-dns-scope.h"
18 #include "resolved-dns-search-domain.h"
19 #include "resolved-dns-server.h"
20 #include "resolved-link.h"
21 #include "resolved-manager.h"
22 #include "resolved-resolv-conf.h"
23 #include "siphash24.h"
24 #include "socket-netlink.h"
25 #include "socket-util.h"
26 #include "string-table.h"
27 #include "string-util.h"
28 #include "time-util.h"
29
30 /* The amount of time to wait before retrying with a full feature set */
31 #define DNS_SERVER_FEATURE_GRACE_PERIOD_MAX_USEC (6 * USEC_PER_HOUR)
32 #define DNS_SERVER_FEATURE_GRACE_PERIOD_MIN_USEC (5 * USEC_PER_MINUTE)
33
34 /* The number of times we will attempt a certain feature set before degrading */
35 #define DNS_SERVER_FEATURE_RETRY_ATTEMPTS 3
36
37 int dns_server_new(
38 Manager *m,
39 DnsServer **ret,
40 DnsServerType type,
41 Link *link,
42 DnsDelegate *delegate,
43 int family,
44 const union in_addr_union *in_addr,
45 uint16_t port,
46 int ifindex,
47 const char *server_name,
48 ResolveConfigSource config_source) {
49
50 _cleanup_free_ char *name = NULL;
51 DnsServer *s;
52
53 assert(m);
54 assert((type == DNS_SERVER_LINK) == !!link);
55 assert((type == DNS_SERVER_DELEGATE) == !!delegate);
56 assert(in_addr);
57
58 if (!IN_SET(family, AF_INET, AF_INET6))
59 return -EAFNOSUPPORT;
60
61 if (link) {
62 if (link->n_dns_servers >= LINK_DNS_SERVERS_MAX)
63 return -E2BIG;
64 } else if (delegate) {
65 if (delegate->n_dns_servers >= DELEGATE_DNS_SERVERS_MAX)
66 return -E2BIG;
67 } else {
68 if (m->n_dns_servers >= MANAGER_DNS_SERVERS_MAX)
69 return -E2BIG;
70 }
71
72 if (!isempty(server_name)) {
73 name = strdup(server_name);
74 if (!name)
75 return -ENOMEM;
76 }
77
78 s = new(DnsServer, 1);
79 if (!s)
80 return -ENOMEM;
81
82 *s = (DnsServer) {
83 .n_ref = 1,
84 .manager = m,
85 .type = type,
86 .family = family,
87 .address = *in_addr,
88 .port = port,
89 .ifindex = ifindex,
90 .server_name = TAKE_PTR(name),
91 .config_source = config_source,
92 .accessible = -1,
93 };
94
95 dns_server_reset_features(s);
96
97 switch (type) {
98
99 case DNS_SERVER_LINK:
100 s->link = link;
101 LIST_APPEND(servers, link->dns_servers, s);
102 link->n_dns_servers++;
103 break;
104
105 case DNS_SERVER_SYSTEM:
106 LIST_APPEND(servers, m->dns_servers, s);
107 m->n_dns_servers++;
108 break;
109
110 case DNS_SERVER_FALLBACK:
111 LIST_APPEND(servers, m->fallback_dns_servers, s);
112 m->n_dns_servers++;
113 break;
114
115 case DNS_SERVER_DELEGATE:
116 s->delegate = delegate;
117 LIST_APPEND(servers, delegate->dns_servers, s);
118 delegate->n_dns_servers++;
119 break;
120 default:
121 assert_not_reached();
122 }
123
124 s->linked = true;
125
126 /* A new non-fallback DNS server is added and the one we used so far was a fallback one? Then
127 * let's try to pick the new one */
128 if (type == DNS_SERVER_SYSTEM && dns_server_is_fallback(m->current_dns_server))
129 manager_set_dns_server(m, NULL);
130
131 if (ret)
132 *ret = s;
133
134 return 0;
135 }
136
137 static DnsServer* dns_server_free(DnsServer *s) {
138 assert(s);
139
140 dns_server_unref_stream(s);
141
142 #if ENABLE_DNS_OVER_TLS
143 dnstls_server_free(s);
144 #endif
145
146 free(s->server_string);
147 free(s->server_string_full);
148 free(s->server_name);
149 return mfree(s);
150 }
151
152 DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsServer, dns_server, dns_server_free);
153
154 void dns_server_unlink(DnsServer *s) {
155 assert(s);
156 assert(s->manager);
157
158 /* This removes the specified server from the linked list of
159 * servers, but any server might still stay around if it has
160 * refs, for example from an ongoing transaction. */
161
162 if (!s->linked)
163 return;
164
165 switch (s->type) {
166
167 case DNS_SERVER_LINK:
168 assert(s->link);
169 assert(s->link->n_dns_servers > 0);
170 LIST_REMOVE(servers, s->link->dns_servers, s);
171 s->link->n_dns_servers--;
172 break;
173
174 case DNS_SERVER_SYSTEM:
175 assert(s->manager->n_dns_servers > 0);
176 LIST_REMOVE(servers, s->manager->dns_servers, s);
177 s->manager->n_dns_servers--;
178 break;
179
180 case DNS_SERVER_FALLBACK:
181 assert(s->manager->n_dns_servers > 0);
182 LIST_REMOVE(servers, s->manager->fallback_dns_servers, s);
183 s->manager->n_dns_servers--;
184 break;
185
186 case DNS_SERVER_DELEGATE:
187 assert(s->delegate);
188 assert(s->delegate->n_dns_servers > 0);
189 LIST_REMOVE(servers, s->delegate->dns_servers, s);
190 s->delegate->n_dns_servers--;
191 break;
192
193 default:
194 assert_not_reached();
195 }
196
197 s->linked = false;
198
199 if (s->link && s->link->current_dns_server == s)
200 link_set_dns_server(s->link, NULL);
201
202 if (s->manager->current_dns_server == s)
203 manager_set_dns_server(s->manager, NULL);
204
205 if (s->delegate && s->delegate->current_dns_server == s)
206 dns_delegate_set_dns_server(s->delegate, NULL);
207
208 /* No need to keep a default stream around anymore */
209 dns_server_unref_stream(s);
210
211 dns_server_unref(s);
212 }
213
214 void dns_server_move_back_and_unmark(DnsServer *s) {
215 DnsServer *tail;
216
217 assert(s);
218
219 if (!s->marked)
220 return;
221
222 s->marked = false;
223
224 if (!s->linked || !s->servers_next)
225 return;
226
227 /* Move us to the end of the list, so that the order is strictly kept, if we are not at the end
228 * anyway. */
229
230 switch (s->type) {
231
232 case DNS_SERVER_LINK:
233 assert(s->link);
234 tail = LIST_FIND_TAIL(servers, s);
235 LIST_REMOVE(servers, s->link->dns_servers, s);
236 LIST_INSERT_AFTER(servers, s->link->dns_servers, tail, s);
237 break;
238
239 case DNS_SERVER_SYSTEM:
240 tail = LIST_FIND_TAIL(servers, s);
241 LIST_REMOVE(servers, s->manager->dns_servers, s);
242 LIST_INSERT_AFTER(servers, s->manager->dns_servers, tail, s);
243 break;
244
245 case DNS_SERVER_FALLBACK:
246 tail = LIST_FIND_TAIL(servers, s);
247 LIST_REMOVE(servers, s->manager->fallback_dns_servers, s);
248 LIST_INSERT_AFTER(servers, s->manager->fallback_dns_servers, tail, s);
249 break;
250
251 case DNS_SERVER_DELEGATE:
252 assert(s->delegate);
253 tail = LIST_FIND_TAIL(servers, s);
254 LIST_REMOVE(servers, s->delegate->dns_servers, s);
255 LIST_INSERT_AFTER(servers, s->delegate->dns_servers, tail, s);
256 break;
257
258 default:
259 assert_not_reached();
260 }
261 }
262
263 static void dns_server_verified(DnsServer *s, DnsServerFeatureLevel level) {
264 assert(s);
265
266 if (s->verified_feature_level > level)
267 return;
268
269 if (s->verified_feature_level != level) {
270 log_debug("Verified we get a response at feature level %s from DNS server %s.",
271 dns_server_feature_level_to_string(level),
272 strna(dns_server_string_full(s)));
273 s->verified_feature_level = level;
274 }
275
276 assert_se(sd_event_now(s->manager->event, CLOCK_BOOTTIME, &s->verified_usec) >= 0);
277 }
278
279 static void dns_server_reset_counters(DnsServer *s) {
280 assert(s);
281
282 s->n_failed_udp = 0;
283 s->n_failed_tcp = 0;
284 s->n_failed_tls = 0;
285 s->packet_truncated = false;
286 s->packet_invalid = false;
287 s->verified_usec = 0;
288
289 /* Note that we do not reset s->packet_bad_opt and s->packet_rrsig_missing here. We reset them only when the
290 * grace period ends, but not when lowering the possible feature level, as a lower level feature level should
291 * not make RRSIGs appear or OPT appear, but rather make them disappear. If the reappear anyway, then that's
292 * indication for a differently broken OPT/RRSIG implementation, and we really don't want to support that
293 * either.
294 *
295 * This is particularly important to deal with certain Belkin routers which break OPT for certain lookups (A),
296 * but pass traffic through for others (AAAA). If we detect the broken behaviour on one lookup we should not
297 * re-enable it for another, because we cannot validate things anyway, given that the RRSIG/OPT data will be
298 * incomplete. */
299 }
300
301 void dns_server_packet_received(DnsServer *s, int protocol, DnsServerFeatureLevel level, size_t fragsize) {
302 assert(s);
303
304 if (protocol == IPPROTO_UDP) {
305 if (s->possible_feature_level == level)
306 s->n_failed_udp = 0;
307 } else if (protocol == IPPROTO_TCP) {
308 if (DNS_SERVER_FEATURE_LEVEL_IS_TLS(level)) {
309 if (s->possible_feature_level == level)
310 s->n_failed_tls = 0;
311 } else {
312 if (s->possible_feature_level == level)
313 s->n_failed_tcp = 0;
314
315 /* Successful TCP connections are only useful to verify the TCP feature level. */
316 level = DNS_SERVER_FEATURE_LEVEL_TCP;
317 }
318 }
319
320 /* If the RRSIG data is missing, then we can only validate EDNS0 at max */
321 if (s->packet_rrsig_missing && level >= DNS_SERVER_FEATURE_LEVEL_DO)
322 level = DNS_SERVER_FEATURE_LEVEL_IS_TLS(level) ? DNS_SERVER_FEATURE_LEVEL_TLS_PLAIN : DNS_SERVER_FEATURE_LEVEL_EDNS0;
323
324 /* If the OPT RR got lost, then we can only validate UDP at max */
325 if (s->packet_bad_opt && level >= DNS_SERVER_FEATURE_LEVEL_EDNS0)
326 level = DNS_SERVER_FEATURE_LEVEL_EDNS0 - 1;
327
328 dns_server_verified(s, level);
329
330 /* Remember the size of the largest UDP packet fragment we received from a server, we know that we
331 * can always announce support for packets with at least this size. */
332 if (protocol == IPPROTO_UDP && s->received_udp_fragment_max < fragsize)
333 s->received_udp_fragment_max = fragsize;
334 }
335
336 void dns_server_packet_lost(DnsServer *s, int protocol, DnsServerFeatureLevel level) {
337 assert(s);
338 assert(s->manager);
339
340 if (s->possible_feature_level != level)
341 return;
342
343 if (protocol == IPPROTO_UDP)
344 s->n_failed_udp++;
345 else if (protocol == IPPROTO_TCP) {
346 if (DNS_SERVER_FEATURE_LEVEL_IS_TLS(level))
347 s->n_failed_tls++;
348 else
349 s->n_failed_tcp++;
350 }
351 }
352
353 void dns_server_packet_truncated(DnsServer *s, DnsServerFeatureLevel level) {
354 assert(s);
355
356 /* Invoked whenever we get a packet with TC bit set. */
357
358 if (s->possible_feature_level != level)
359 return;
360
361 s->packet_truncated = true;
362 }
363
364 void dns_server_packet_rrsig_missing(DnsServer *s, DnsServerFeatureLevel level) {
365 assert(s);
366
367 if (level < DNS_SERVER_FEATURE_LEVEL_DO)
368 return;
369
370 /* If the RRSIG RRs are missing, we have to downgrade what we previously verified */
371 if (s->verified_feature_level >= DNS_SERVER_FEATURE_LEVEL_DO)
372 s->verified_feature_level = DNS_SERVER_FEATURE_LEVEL_IS_TLS(level) ? DNS_SERVER_FEATURE_LEVEL_TLS_PLAIN : DNS_SERVER_FEATURE_LEVEL_EDNS0;
373
374 s->packet_rrsig_missing = true;
375 }
376
377 void dns_server_packet_bad_opt(DnsServer *s, DnsServerFeatureLevel level) {
378 assert(s);
379
380 if (level < DNS_SERVER_FEATURE_LEVEL_EDNS0)
381 return;
382
383 /* If the OPT RR got lost, we have to downgrade what we previously verified */
384 if (s->verified_feature_level >= DNS_SERVER_FEATURE_LEVEL_EDNS0)
385 s->verified_feature_level = DNS_SERVER_FEATURE_LEVEL_EDNS0-1;
386
387 s->packet_bad_opt = true;
388 }
389
390 void dns_server_packet_rcode_downgrade(DnsServer *s, DnsServerFeatureLevel level) {
391 assert(s);
392
393 /* Invoked whenever we got a FORMERR, SERVFAIL or NOTIMP rcode from a server and downgrading the feature level
394 * for the transaction made it go away. In this case we immediately downgrade to the feature level that made
395 * things work. */
396
397 if (s->verified_feature_level > level)
398 s->verified_feature_level = level;
399
400 if (s->possible_feature_level > level) {
401 s->possible_feature_level = level;
402 dns_server_reset_counters(s);
403 log_debug("Downgrading transaction feature level fixed an RCODE error, downgrading server %s too.", strna(dns_server_string_full(s)));
404 }
405 }
406
407 void dns_server_packet_invalid(DnsServer *s, DnsServerFeatureLevel level) {
408 assert(s);
409
410 /* Invoked whenever we got a packet we couldn't parse at all */
411
412 if (s->possible_feature_level != level)
413 return;
414
415 s->packet_invalid = true;
416 }
417
418 void dns_server_packet_do_off(DnsServer *s, DnsServerFeatureLevel level) {
419 assert(s);
420
421 /* Invoked whenever the DO flag was not copied from our request to the response. */
422
423 if (s->possible_feature_level != level)
424 return;
425
426 s->packet_do_off = true;
427 }
428
429 void dns_server_packet_udp_fragmented(DnsServer *s, size_t fragsize) {
430 assert(s);
431
432 /* Invoked whenever we got a fragmented UDP packet. Let's do two things: keep track of the largest
433 * fragment we ever received from the server, and remember this, so that we can use it to lower the
434 * advertised packet size in EDNS0 */
435
436 if (s->received_udp_fragment_max < fragsize)
437 s->received_udp_fragment_max = fragsize;
438
439 s->packet_fragmented = true;
440 }
441
442 static bool dns_server_grace_period_expired(DnsServer *s) {
443 usec_t ts;
444
445 assert(s);
446 assert(s->manager);
447
448 if (s->verified_usec == 0)
449 return false;
450
451 assert_se(sd_event_now(s->manager->event, CLOCK_BOOTTIME, &ts) >= 0);
452
453 if (s->verified_usec + s->features_grace_period_usec > ts)
454 return false;
455
456 s->features_grace_period_usec = MIN(s->features_grace_period_usec * 2, DNS_SERVER_FEATURE_GRACE_PERIOD_MAX_USEC);
457
458 return true;
459 }
460
461 DnsServerFeatureLevel dns_server_possible_feature_level(DnsServer *s) {
462 DnsServerFeatureLevel best;
463
464 assert(s);
465
466 /* Determine the best feature level we care about. If DNSSEC mode is off there's no point in using anything
467 * better than EDNS0, hence don't even try. */
468 if (dns_server_get_dnssec_mode(s) != DNSSEC_NO)
469 best = dns_server_get_dns_over_tls_mode(s) == DNS_OVER_TLS_NO ?
470 DNS_SERVER_FEATURE_LEVEL_DO :
471 DNS_SERVER_FEATURE_LEVEL_TLS_DO;
472 else
473 best = dns_server_get_dns_over_tls_mode(s) == DNS_OVER_TLS_NO ?
474 DNS_SERVER_FEATURE_LEVEL_EDNS0 :
475 DNS_SERVER_FEATURE_LEVEL_TLS_PLAIN;
476
477 /* Clamp the feature level the highest level we care about. The DNSSEC mode might have changed since the last
478 * time, hence let's downgrade if we are still at a higher level. */
479 if (s->possible_feature_level > best)
480 s->possible_feature_level = best;
481
482 if (s->possible_feature_level < best && dns_server_grace_period_expired(s)) {
483
484 s->possible_feature_level = best;
485
486 dns_server_reset_counters(s);
487
488 s->packet_bad_opt = false;
489 s->packet_rrsig_missing = false;
490
491 log_info("Grace period over, resuming full feature set (%s) for DNS server %s.",
492 dns_server_feature_level_to_string(s->possible_feature_level),
493 strna(dns_server_string_full(s)));
494
495 dns_server_flush_cache(s);
496
497 } else if (s->possible_feature_level <= s->verified_feature_level)
498 s->possible_feature_level = s->verified_feature_level;
499 else {
500 DnsServerFeatureLevel p = s->possible_feature_level;
501 int log_level = LOG_WARNING;
502
503 if (s->n_failed_tcp >= DNS_SERVER_FEATURE_RETRY_ATTEMPTS &&
504 s->possible_feature_level == DNS_SERVER_FEATURE_LEVEL_TCP) {
505
506 /* We are at the TCP (lowest) level, and we tried a couple of TCP connections, and it didn't
507 * work. Upgrade back to UDP again. */
508 log_debug("Reached maximum number of failed TCP connection attempts, trying UDP again...");
509 s->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_UDP;
510
511 } else if (s->n_failed_tls > 0 &&
512 DNS_SERVER_FEATURE_LEVEL_IS_TLS(s->possible_feature_level) &&
513 dns_server_get_dns_over_tls_mode(s) != DNS_OVER_TLS_YES) {
514
515 /* We tried to connect using DNS-over-TLS, and it didn't work. Downgrade to plaintext UDP
516 * if we don't require DNS-over-TLS */
517
518 log_debug("Server doesn't support DNS-over-TLS, downgrading protocol...");
519 s->possible_feature_level--;
520
521 } else if (s->packet_invalid &&
522 s->possible_feature_level > DNS_SERVER_FEATURE_LEVEL_UDP &&
523 s->possible_feature_level != DNS_SERVER_FEATURE_LEVEL_TLS_PLAIN) {
524
525 /* Downgrade from DO to EDNS0 + from EDNS0 to UDP, from TLS+DO to plain TLS. Or in
526 * other words, if we receive a packet we cannot parse jump to the next lower feature
527 * level that actually has an influence on the packet layout (and not just the
528 * transport). */
529
530 log_debug("Got invalid packet from server, downgrading protocol...");
531 s->possible_feature_level =
532 s->possible_feature_level == DNS_SERVER_FEATURE_LEVEL_TLS_DO ? DNS_SERVER_FEATURE_LEVEL_TLS_PLAIN :
533 DNS_SERVER_FEATURE_LEVEL_IS_DNSSEC(s->possible_feature_level) ? DNS_SERVER_FEATURE_LEVEL_EDNS0 :
534 DNS_SERVER_FEATURE_LEVEL_UDP;
535
536 } else if (s->packet_bad_opt &&
537 DNS_SERVER_FEATURE_LEVEL_IS_EDNS0(s->possible_feature_level) &&
538 dns_server_get_dnssec_mode(s) != DNSSEC_YES &&
539 dns_server_get_dns_over_tls_mode(s) != DNS_OVER_TLS_YES) {
540
541 /* A reply to one of our EDNS0 queries didn't carry a valid OPT RR, then downgrade to
542 * below EDNS0 levels. After all, some servers generate different responses with and
543 * without OPT RR in the request. Example:
544 *
545 * https://open.nlnetlabs.nl/pipermail/dnssec-trigger/2014-November/000376.html
546 *
547 * If we are in strict DNSSEC or DoT mode, we don't do this kind of downgrade
548 * however, as both modes imply EDNS0 to work (DNSSEC strictly requires it, and DoT
549 * only in our implementation). */
550
551 log_debug("Server doesn't support EDNS(0) properly, downgrading feature level...");
552 s->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_UDP;
553
554 /* Users often don't control the DNS server they use so let's not complain too loudly
555 * when we can't use EDNS because the DNS server doesn't support it. */
556 log_level = LOG_NOTICE;
557
558 } else if (s->packet_do_off &&
559 DNS_SERVER_FEATURE_LEVEL_IS_DNSSEC(s->possible_feature_level) &&
560 dns_server_get_dnssec_mode(s) != DNSSEC_YES) {
561
562 /* The server didn't copy the DO bit from request to response, thus DNSSEC is not
563 * correctly implemented, let's downgrade if that's allowed. */
564
565 log_debug("Detected server didn't copy DO flag from request to response, downgrading feature level...");
566 s->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_IS_TLS(s->possible_feature_level) ? DNS_SERVER_FEATURE_LEVEL_TLS_PLAIN :
567 DNS_SERVER_FEATURE_LEVEL_EDNS0;
568
569 } else if (s->packet_rrsig_missing &&
570 DNS_SERVER_FEATURE_LEVEL_IS_DNSSEC(s->possible_feature_level) &&
571 dns_server_get_dnssec_mode(s) != DNSSEC_YES) {
572
573 /* RRSIG data was missing on an EDNS0 packet with DO bit set. This means the server
574 * doesn't augment responses with DNSSEC RRs. If so, let's better not ask the server
575 * for it anymore, after all some servers generate different replies depending if an
576 * OPT RR is in the query or not. If we are in strict DNSSEC mode, don't allow such
577 * downgrades however, since a DNSSEC feature level is a requirement for strict
578 * DNSSEC mode. */
579
580 log_debug("Detected server responses lack RRSIG records, downgrading feature level...");
581 s->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_IS_TLS(s->possible_feature_level) ? DNS_SERVER_FEATURE_LEVEL_TLS_PLAIN :
582 DNS_SERVER_FEATURE_LEVEL_EDNS0;
583
584 } else if (s->n_failed_udp >= DNS_SERVER_FEATURE_RETRY_ATTEMPTS &&
585 DNS_SERVER_FEATURE_LEVEL_IS_UDP(s->possible_feature_level) &&
586 ((s->possible_feature_level != DNS_SERVER_FEATURE_LEVEL_DO) || dns_server_get_dnssec_mode(s) != DNSSEC_YES)) {
587
588 /* We lost too many UDP packets in a row, and are on a UDP feature level. If the
589 * packets are lost, maybe the server cannot parse them, hence downgrading sounds
590 * like a good idea. We might downgrade all the way down to TCP this way.
591 *
592 * If strict DNSSEC mode is used we won't downgrade below DO level however, as packet loss
593 * might have many reasons, a broken DNSSEC implementation being only one reason. And if the
594 * user is strict on DNSSEC, then let's assume that DNSSEC is not the fault here. */
595
596 log_debug("Lost too many UDP packets, downgrading feature level...");
597 if (s->possible_feature_level == DNS_SERVER_FEATURE_LEVEL_DO) /* skip over TLS_PLAIN */
598 s->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_EDNS0;
599 else
600 s->possible_feature_level--;
601
602 } else if (s->n_failed_tcp >= DNS_SERVER_FEATURE_RETRY_ATTEMPTS &&
603 s->packet_truncated &&
604 s->possible_feature_level > DNS_SERVER_FEATURE_LEVEL_UDP &&
605 DNS_SERVER_FEATURE_LEVEL_IS_UDP(s->possible_feature_level) &&
606 (!DNS_SERVER_FEATURE_LEVEL_IS_DNSSEC(s->possible_feature_level) || dns_server_get_dnssec_mode(s) != DNSSEC_YES)) {
607
608 /* We got too many TCP connection failures in a row, we had at least one truncated
609 * packet, and are on feature level above UDP. By downgrading things and getting rid
610 * of DNSSEC or EDNS0 data we hope to make the packet smaller, so that it still
611 * works via UDP given that TCP appears not to be a fallback. Note that if we are
612 * already at the lowest UDP level, we don't go further down, since that's TCP, and
613 * TCP failed too often after all. */
614
615 log_debug("Got too many failed TCP connection failures and truncated UDP packets, downgrading feature level...");
616
617 if (DNS_SERVER_FEATURE_LEVEL_IS_DNSSEC(s->possible_feature_level))
618 s->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_EDNS0; /* Go DNSSEC → EDNS0 */
619 else
620 s->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_UDP; /* Go EDNS0 → UDP */
621 }
622
623 if (p != s->possible_feature_level) {
624
625 /* We changed the feature level, reset the counting */
626 dns_server_reset_counters(s);
627
628 log_full(log_level, "Using degraded feature set %s instead of %s for DNS server %s.",
629 dns_server_feature_level_to_string(s->possible_feature_level),
630 dns_server_feature_level_to_string(p), strna(dns_server_string_full(s)));
631 }
632 }
633
634 return s->possible_feature_level;
635 }
636
637 int dns_server_adjust_opt(DnsServer *server, DnsPacket *packet, DnsServerFeatureLevel level) {
638 size_t packet_size, udp_size;
639 bool edns_do;
640 int r;
641
642 assert(server);
643 assert(packet);
644 assert(packet->protocol == DNS_PROTOCOL_DNS);
645
646 /* Fix the OPT field in the packet to match our current feature level. */
647
648 r = dns_packet_truncate_opt(packet);
649 if (r < 0)
650 return r;
651
652 if (level < DNS_SERVER_FEATURE_LEVEL_EDNS0)
653 return 0;
654
655 edns_do = level >= DNS_SERVER_FEATURE_LEVEL_DO;
656
657 udp_size = udp_header_size(server->family);
658
659 if (in_addr_is_localhost(server->family, &server->address) > 0)
660 packet_size = 65536 - udp_size; /* force linux loopback MTU if localhost address */
661 else {
662 /* Use the MTU pointing to the server, subtract the IP/UDP header size */
663 packet_size = LESS_BY(dns_server_get_mtu(server), udp_size);
664
665 /* On the Internet we want to avoid fragmentation for security reasons. If we saw
666 * fragmented packets, the above was too large, let's clamp it to the largest
667 * fragment we saw */
668 if (server->packet_fragmented)
669 packet_size = MIN(server->received_udp_fragment_max, packet_size);
670
671 /* Let's not pick ridiculously large sizes, i.e. not more than 4K. No one appears
672 * to ever use such large sized on the Internet IRL, hence let's not either. */
673 packet_size = MIN(packet_size, 4096U);
674 }
675
676 /* Strictly speaking we quite possibly can receive larger datagrams than the MTU (since the
677 * MTU is for egress, not for ingress), but more often than not the value is symmetric, and
678 * we want something that does the right thing in the majority of cases, and not just in the
679 * theoretical edge case. */
680
681 /* Safety clamp, never advertise less than 512 or more than 65535 */
682 packet_size = CLAMP(packet_size,
683 DNS_PACKET_UNICAST_SIZE_MAX,
684 DNS_PACKET_SIZE_MAX);
685
686 log_debug("Announcing packet size %zu in egress EDNS(0) packet.", packet_size);
687
688 return dns_packet_append_opt(packet, packet_size, edns_do, /* include_rfc6975= */ true, NULL, 0, NULL);
689 }
690
691 int dns_server_ifindex(const DnsServer *s) {
692 assert(s);
693
694 /* For loopback addresses, go via the loopback interface, regardless which interface this is linked
695 * to. */
696 if (in_addr_is_localhost(s->family, &s->address))
697 return LOOPBACK_IFINDEX;
698
699 /* The link ifindex always takes precedence */
700 if (s->link)
701 return s->link->ifindex;
702
703 if (s->ifindex > 0)
704 return s->ifindex;
705
706 return 0;
707 }
708
709 uint16_t dns_server_port(const DnsServer *s) {
710 assert(s);
711
712 if (s->port > 0)
713 return s->port;
714
715 return 53;
716 }
717
718 const char* dns_server_string(DnsServer *server) {
719 assert(server);
720
721 if (!server->server_string)
722 (void) in_addr_ifindex_to_string(server->family, &server->address, dns_server_ifindex(server), &server->server_string);
723
724 return server->server_string;
725 }
726
727 const char* dns_server_string_full(DnsServer *server) {
728 assert(server);
729
730 if (!server->server_string_full)
731 (void) in_addr_port_ifindex_name_to_string(
732 server->family,
733 &server->address,
734 server->port,
735 dns_server_ifindex(server),
736 server->server_name,
737 &server->server_string_full);
738
739 return server->server_string_full;
740 }
741
742 bool dns_server_dnssec_supported(DnsServer *server) {
743 assert(server);
744
745 /* Returns whether the server supports DNSSEC according to what we know about it */
746
747 if (dns_server_get_dnssec_mode(server) == DNSSEC_YES) /* If strict DNSSEC mode is enabled, always assume DNSSEC mode is supported. */
748 return true;
749
750 if (server->packet_bad_opt)
751 return false;
752
753 if (server->packet_rrsig_missing)
754 return false;
755
756 if (server->packet_do_off)
757 return false;
758
759 /* DNSSEC servers need to support TCP properly (see RFC5966), if they don't, we assume DNSSEC is borked too */
760 if (server->n_failed_tcp >= DNS_SERVER_FEATURE_RETRY_ATTEMPTS)
761 return false;
762
763 return true;
764 }
765
766 void dns_server_warn_downgrade(DnsServer *server) {
767 assert(server);
768
769 if (server->warned_downgrade)
770 return;
771
772 log_struct(LOG_NOTICE,
773 LOG_MESSAGE_ID(SD_MESSAGE_DNSSEC_DOWNGRADE_STR),
774 LOG_MESSAGE("Server %s does not support DNSSEC, downgrading to non-DNSSEC mode.",
775 strna(dns_server_string_full(server))),
776 LOG_ITEM("DNS_SERVER=%s", strna(dns_server_string_full(server))),
777 LOG_ITEM("DNS_SERVER_FEATURE_LEVEL=%s", dns_server_feature_level_to_string(server->possible_feature_level)));
778
779 server->warned_downgrade = true;
780 }
781
782 size_t dns_server_get_mtu(DnsServer *s) {
783 assert(s);
784
785 if (s->link && s->link->mtu != 0)
786 return s->link->mtu;
787
788 return manager_find_mtu(s->manager);
789 }
790
791 static void dns_server_hash_func(const DnsServer *s, struct siphash *state) {
792 assert(s);
793
794 siphash24_compress_typesafe(s->family, state);
795 in_addr_hash_func(&s->address, s->family, state);
796 siphash24_compress_typesafe(s->port, state);
797 siphash24_compress_typesafe(s->ifindex, state);
798 siphash24_compress_string(s->server_name, state);
799 }
800
801 static int dns_server_compare_func(const DnsServer *x, const DnsServer *y) {
802 int r;
803
804 r = CMP(x->family, y->family);
805 if (r != 0)
806 return r;
807
808 r = memcmp(&x->address, &y->address, FAMILY_ADDRESS_SIZE(x->family));
809 if (r != 0)
810 return r;
811
812 r = CMP(x->port, y->port);
813 if (r != 0)
814 return r;
815
816 r = CMP(x->ifindex, y->ifindex);
817 if (r != 0)
818 return r;
819
820 return strcmp_ptr(x->server_name, y->server_name);
821 }
822
823 DEFINE_HASH_OPS(dns_server_hash_ops, DnsServer, dns_server_hash_func, dns_server_compare_func);
824
825 void dns_server_unlink_all(DnsServer *first) {
826 DnsServer *next;
827
828 if (!first)
829 return;
830
831 next = first->servers_next;
832 dns_server_unlink(first);
833
834 dns_server_unlink_all(next);
835 }
836
837 void dns_server_unlink_on_reload(DnsServer *server) {
838 while (server) {
839 DnsServer *next = server->servers_next;
840
841 if (server->config_source == RESOLVE_CONFIG_SOURCE_FILE)
842 dns_server_unlink(server);
843
844 server = next;
845 }
846 }
847
848 bool dns_server_unlink_marked(DnsServer *server) {
849 bool changed = false;
850
851 while (server) {
852 DnsServer *next;
853
854 next = server->servers_next;
855
856 if (server->marked) {
857 dns_server_unlink(server);
858 changed = true;
859 }
860
861 server = next;
862 }
863
864 return changed;
865 }
866
867 void dns_server_mark_all(DnsServer *server) {
868 while (server) {
869 server->marked = true;
870 server = server->servers_next;
871 }
872 }
873
874 DnsServer *dns_server_find(DnsServer *first, int family, const union in_addr_union *in_addr, uint16_t port, int ifindex, const char *name) {
875 LIST_FOREACH(servers, s, first)
876 if (s->family == family &&
877 in_addr_equal(family, &s->address, in_addr) > 0 &&
878 s->port == port &&
879 s->ifindex == ifindex &&
880 streq_ptr(s->server_name, name))
881 return s;
882
883 return NULL;
884 }
885
886 static int manager_add_dns_server_by_string(Manager *m, DnsServerType type, const char *word) {
887 _cleanup_free_ char *server_name = NULL;
888 union in_addr_union address;
889 int family, r, ifindex = 0;
890 uint16_t port;
891 DnsServer *s;
892
893 assert(m);
894 assert(word);
895
896 r = in_addr_port_ifindex_name_from_string_auto(word, &family, &address, &port, &ifindex, &server_name);
897 if (r < 0)
898 return r;
899
900 /* Silently filter out 0.0.0.0, 127.0.0.53, 127.0.0.54 (our own stub DNS listener) */
901 if (!dns_server_address_valid(family, &address))
902 return 0;
903
904 /* By default, the port number is determined with the transaction feature level.
905 * See dns_transaction_port() and dns_server_port(). */
906 if (IN_SET(port, 53, 853))
907 port = 0;
908
909 /* Filter out duplicates */
910 s = dns_server_find(manager_get_first_dns_server(m, type), family, &address, port, ifindex, server_name);
911 if (s) {
912 /* Drop the marker. This is used to find the servers that ceased to exist, see
913 * manager_mark_dns_servers() and manager_flush_marked_dns_servers(). */
914 dns_server_move_back_and_unmark(s);
915 return 0;
916 }
917
918 return dns_server_new(
919 m,
920 /* ret= */ NULL,
921 type,
922 /* link= */ NULL,
923 /* delegate= */ NULL,
924 family,
925 &address,
926 port,
927 ifindex,
928 server_name,
929 RESOLVE_CONFIG_SOURCE_FILE);
930 }
931
932 int manager_parse_dns_server_string_and_warn(Manager *m, DnsServerType type, const char *string) {
933 int r;
934
935 assert(m);
936 assert(string);
937
938 for (;;) {
939 _cleanup_free_ char *word = NULL;
940
941 r = extract_first_word(&string, &word, NULL, 0);
942 if (r <= 0)
943 return r;
944
945 r = manager_add_dns_server_by_string(m, type, word);
946 if (r < 0)
947 log_warning_errno(r, "Failed to add DNS server address '%s', ignoring: %m", word);
948 }
949 }
950
951 static int manager_add_search_domain_by_string(Manager *m, const char *domain) {
952 DnsSearchDomain *d;
953 bool route_only;
954 int r;
955
956 assert(m);
957 assert(domain);
958
959 route_only = *domain == '~';
960 if (route_only)
961 domain++;
962
963 if (dns_name_is_root(domain) || streq(domain, "*")) {
964 route_only = true;
965 domain = ".";
966 }
967
968 r = dns_search_domain_find(m->search_domains, domain, &d);
969 if (r < 0)
970 return r;
971 if (r > 0)
972 dns_search_domain_move_back_and_unmark(d);
973 else {
974 r = dns_search_domain_new(
975 m,
976 &d,
977 DNS_SEARCH_DOMAIN_SYSTEM,
978 /* link= */ NULL,
979 /* delegate= */ NULL,
980 domain);
981 if (r < 0)
982 return r;
983 }
984
985 d->route_only = route_only;
986 return 0;
987 }
988
989 int manager_parse_search_domains_and_warn(Manager *m, const char *string) {
990 int r;
991
992 assert(m);
993 assert(string);
994
995 for (;;) {
996 _cleanup_free_ char *word = NULL;
997
998 r = extract_first_word(&string, &word, NULL, EXTRACT_UNQUOTE);
999 if (r <= 0)
1000 return r;
1001
1002 r = manager_add_search_domain_by_string(m, word);
1003 if (r < 0)
1004 log_warning_errno(r, "Failed to add search domain '%s', ignoring: %m", word);
1005 }
1006 }
1007
1008 DnsServer *manager_get_first_dns_server(Manager *m, DnsServerType t) {
1009 assert(m);
1010
1011 switch (t) {
1012
1013 case DNS_SERVER_SYSTEM:
1014 return m->dns_servers;
1015
1016 case DNS_SERVER_FALLBACK:
1017 return m->fallback_dns_servers;
1018
1019 default:
1020 return NULL;
1021 }
1022 }
1023
1024 DnsServer *manager_set_dns_server(Manager *m, DnsServer *s) {
1025 assert(m);
1026
1027 if (m->current_dns_server == s)
1028 return s;
1029
1030 /* Let's log about the server switch, at debug level. Except if we switch from a non-fallback server
1031 * to a fallback server or back, since that is noteworthy and possibly a configuration issue */
1032 if (s)
1033 log_full((s->type == DNS_SERVER_FALLBACK) != (m->current_dns_server && m->current_dns_server->type == DNS_SERVER_FALLBACK) ? LOG_NOTICE : LOG_DEBUG,
1034 "Switching to %s DNS server %s.", dns_server_type_to_string(s->type), strna(dns_server_string_full(s)));
1035
1036 dns_server_unref(m->current_dns_server);
1037 m->current_dns_server = dns_server_ref(s);
1038
1039 /* Skip flushing the cache if server stale feature is enabled. */
1040 if (m->unicast_scope && m->stale_retention_usec == 0)
1041 dns_cache_flush(&m->unicast_scope->cache);
1042
1043 (void) manager_send_changed(m, "CurrentDNSServer");
1044 (void) manager_send_dns_configuration_changed(m, NULL, /* reset= */ false);
1045
1046 return s;
1047 }
1048
1049 static bool manager_search_default_route_dns_server(Manager *m) {
1050 assert(m);
1051
1052 LIST_FOREACH(scopes, scope, m->dns_scopes) {
1053 /* Ignore the global scope, it's handled separately */
1054 if (scope->origin == DNS_SCOPE_GLOBAL)
1055 continue;
1056
1057 /* Scope has no DNS server? */
1058 if (dns_scope_get_n_dns_servers(scope) == 0)
1059 continue;
1060
1061 /* If this is suitable as default route, we found what we are looking for */
1062 if (dns_scope_is_default_route(scope))
1063 return true;
1064 }
1065
1066 return false;
1067 }
1068
1069 DnsServer *manager_get_dns_server(Manager *m) {
1070 assert(m);
1071
1072 /* Try to read updates resolv.conf */
1073 manager_read_resolv_conf(m);
1074
1075 /* If no DNS server was chosen so far, pick the first one */
1076 if (!m->current_dns_server ||
1077 /* In case m->current_dns_server != m->dns_servers */
1078 manager_server_is_stub(m, m->current_dns_server))
1079 manager_set_dns_server(m, m->dns_servers);
1080
1081 while (m->current_dns_server &&
1082 manager_server_is_stub(m, m->current_dns_server)) {
1083 manager_next_dns_server(m, NULL);
1084 if (m->current_dns_server == m->dns_servers)
1085 manager_set_dns_server(m, NULL);
1086 }
1087
1088 /* If no DNS servers are configured, let's see if there are any on any links or delegates. If not, we
1089 * use the fallback servers */
1090 if (!m->current_dns_server && !manager_search_default_route_dns_server(m))
1091 manager_set_dns_server(m, m->fallback_dns_servers);
1092
1093 return m->current_dns_server;
1094 }
1095
1096 void manager_next_dns_server(Manager *m, DnsServer *if_current) {
1097 assert(m);
1098
1099 /* If the DNS server is already a different one than the one specified in 'if_current' don't do anything */
1100 if (if_current && m->current_dns_server != if_current)
1101 return;
1102
1103 /* If there's currently no DNS server set, then the next manager_get_dns_server() will find one */
1104 if (!m->current_dns_server)
1105 return;
1106
1107 /* Change to the next one, but make sure to follow the linked list only if the server is still
1108 * linked. */
1109 if (m->current_dns_server->linked && m->current_dns_server->servers_next) {
1110 manager_set_dns_server(m, m->current_dns_server->servers_next);
1111 return;
1112 }
1113
1114 /* If there was no next one, then start from the beginning of the list */
1115 if (m->current_dns_server->type == DNS_SERVER_FALLBACK)
1116 manager_set_dns_server(m, m->fallback_dns_servers);
1117 else
1118 manager_set_dns_server(m, m->dns_servers);
1119 }
1120
1121 DnssecMode dns_server_get_dnssec_mode(DnsServer *s) {
1122 assert(s);
1123
1124 if (s->link)
1125 return link_get_dnssec_mode(s->link);
1126
1127 return manager_get_dnssec_mode(s->manager);
1128 }
1129
1130 DnsOverTlsMode dns_server_get_dns_over_tls_mode(DnsServer *s) {
1131 assert(s);
1132
1133 if (s->link)
1134 return link_get_dns_over_tls_mode(s->link);
1135
1136 return manager_get_dns_over_tls_mode(s->manager);
1137 }
1138
1139 void dns_server_flush_cache(DnsServer *s) {
1140 DnsServer *current;
1141 DnsScope *scope;
1142
1143 assert(s);
1144
1145 /* Flush the cache of the scope this server belongs to */
1146
1147 current = s->link ? s->link->current_dns_server :
1148 s->delegate ? s->delegate->current_dns_server :
1149 s->manager->current_dns_server;
1150 if (current != s)
1151 return;
1152
1153 scope = s->link ? s->link->unicast_scope :
1154 s->delegate ? s->delegate->scope :
1155 s->manager->unicast_scope;
1156 if (!scope)
1157 return;
1158
1159 /* Skip flushing the cache if server stale feature is enabled. */
1160 if (s->manager->stale_retention_usec > 0)
1161 return;
1162
1163 dns_cache_flush(&scope->cache);
1164 }
1165
1166 void dns_server_reset_features(DnsServer *s) {
1167 assert(s);
1168
1169 s->verified_feature_level = _DNS_SERVER_FEATURE_LEVEL_INVALID;
1170 s->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_BEST;
1171
1172 s->received_udp_fragment_max = DNS_PACKET_UNICAST_SIZE_MAX;
1173
1174 s->packet_bad_opt = false;
1175 s->packet_rrsig_missing = false;
1176 s->packet_do_off = false;
1177
1178 s->features_grace_period_usec = DNS_SERVER_FEATURE_GRACE_PERIOD_MIN_USEC;
1179
1180 s->warned_downgrade = false;
1181
1182 dns_server_reset_counters(s);
1183
1184 /* Let's close the default stream, so that we reprobe with the new features */
1185 dns_server_unref_stream(s);
1186 }
1187
1188 void dns_server_reset_features_all(DnsServer *s) {
1189 LIST_FOREACH(servers, i, s)
1190 dns_server_reset_features(i);
1191 }
1192
1193 void dns_server_dump(DnsServer *s, FILE *f) {
1194 assert(s);
1195
1196 if (!f)
1197 f = stdout;
1198
1199 fputs("[Server ", f);
1200 fputs(strna(dns_server_string_full(s)), f);
1201 fputs(" type=", f);
1202 fputs(dns_server_type_to_string(s->type), f);
1203
1204 if (s->type == DNS_SERVER_LINK) {
1205 assert(s->link);
1206
1207 fputs(" interface=", f);
1208 fputs(s->link->ifname, f);
1209 }
1210
1211 fputs("]\n", f);
1212
1213 fputs("\tVerified feature level: ", f);
1214 fputs(strna(dns_server_feature_level_to_string(s->verified_feature_level)), f);
1215 fputc('\n', f);
1216
1217 fputs("\tPossible feature level: ", f);
1218 fputs(strna(dns_server_feature_level_to_string(s->possible_feature_level)), f);
1219 fputc('\n', f);
1220
1221 fputs("\tDNSSEC Mode: ", f);
1222 fputs(strna(dnssec_mode_to_string(dns_server_get_dnssec_mode(s))), f);
1223 fputc('\n', f);
1224
1225 fputs("\tCan do DNSSEC: ", f);
1226 fputs(yes_no(dns_server_dnssec_supported(s)), f);
1227 fputc('\n', f);
1228
1229 fprintf(f,
1230 "\tMaximum UDP fragment size received: %zu\n"
1231 "\tFailed UDP attempts: %u\n"
1232 "\tFailed TCP attempts: %u\n"
1233 "\tSeen truncated packet: %s\n"
1234 "\tSeen OPT RR getting lost: %s\n"
1235 "\tSeen RRSIG RR missing: %s\n"
1236 "\tSeen invalid packet: %s\n"
1237 "\tServer dropped DO flag: %s\n",
1238 s->received_udp_fragment_max,
1239 s->n_failed_udp,
1240 s->n_failed_tcp,
1241 yes_no(s->packet_truncated),
1242 yes_no(s->packet_bad_opt),
1243 yes_no(s->packet_rrsig_missing),
1244 yes_no(s->packet_invalid),
1245 yes_no(s->packet_do_off));
1246 }
1247
1248 void dns_server_unref_stream(DnsServer *s) {
1249 DnsStream *ref;
1250
1251 assert(s);
1252
1253 /* Detaches the default stream of this server. Some special care needs to be taken here, as that stream and
1254 * this server reference each other. First, take the stream out of the server. It's destructor will check if it
1255 * is registered with us, hence let's invalidate this separately, so that it is already unregistered. */
1256 ref = TAKE_PTR(s->stream);
1257
1258 /* And then, unref it */
1259 dns_stream_unref(ref);
1260 }
1261
1262 DnsScope *dns_server_scope(DnsServer *s) {
1263 assert(s);
1264 assert(s->linked);
1265 assert((s->type == DNS_SERVER_LINK) == !!s->link);
1266 assert((s->type == DNS_SERVER_DELEGATE) == !!s->delegate);
1267
1268 if (s->link)
1269 return s->link->unicast_scope;
1270 if (s->delegate)
1271 return s->delegate->scope;
1272
1273 return s->manager->unicast_scope;
1274 }
1275
1276 static const char* const dns_server_type_table[_DNS_SERVER_TYPE_MAX] = {
1277 [DNS_SERVER_SYSTEM] = "system",
1278 [DNS_SERVER_FALLBACK] = "fallback",
1279 [DNS_SERVER_LINK] = "link",
1280 };
1281 DEFINE_STRING_TABLE_LOOKUP(dns_server_type, DnsServerType);
1282
1283 static const char* const dns_server_feature_level_table[_DNS_SERVER_FEATURE_LEVEL_MAX] = {
1284 [DNS_SERVER_FEATURE_LEVEL_TCP] = "TCP",
1285 [DNS_SERVER_FEATURE_LEVEL_UDP] = "UDP",
1286 [DNS_SERVER_FEATURE_LEVEL_EDNS0] = "UDP+EDNS0",
1287 [DNS_SERVER_FEATURE_LEVEL_TLS_PLAIN] = "TLS+EDNS0",
1288 [DNS_SERVER_FEATURE_LEVEL_DO] = "UDP+EDNS0+DO",
1289 [DNS_SERVER_FEATURE_LEVEL_TLS_DO] = "TLS+EDNS0+DO",
1290 };
1291 DEFINE_STRING_TABLE_LOOKUP(dns_server_feature_level, DnsServerFeatureLevel);
1292
1293 int dns_server_dump_state_to_json(DnsServer *server, sd_json_variant **ret) {
1294
1295 assert(server);
1296 assert(ret);
1297
1298 return sd_json_buildo(
1299 ret,
1300 SD_JSON_BUILD_PAIR_STRING("Server", strna(dns_server_string_full(server))),
1301 SD_JSON_BUILD_PAIR_STRING("Type", strna(dns_server_type_to_string(server->type))),
1302 SD_JSON_BUILD_PAIR_CONDITION(server->type == DNS_SERVER_LINK, "Interface", SD_JSON_BUILD_STRING(server->link ? server->link->ifname : NULL)),
1303 SD_JSON_BUILD_PAIR_CONDITION(server->type == DNS_SERVER_LINK, "InterfaceIndex", SD_JSON_BUILD_UNSIGNED(server->link ? server->link->ifindex : 0)),
1304 SD_JSON_BUILD_PAIR_STRING("VerifiedFeatureLevel", strna(dns_server_feature_level_to_string(server->verified_feature_level))),
1305 SD_JSON_BUILD_PAIR_STRING("PossibleFeatureLevel", strna(dns_server_feature_level_to_string(server->possible_feature_level))),
1306 SD_JSON_BUILD_PAIR_STRING("DNSSECMode", strna(dnssec_mode_to_string(dns_server_get_dnssec_mode(server)))),
1307 SD_JSON_BUILD_PAIR_BOOLEAN("DNSSECSupported", dns_server_dnssec_supported(server)),
1308 SD_JSON_BUILD_PAIR_UNSIGNED("ReceivedUDPFragmentMax", server->received_udp_fragment_max),
1309 SD_JSON_BUILD_PAIR_UNSIGNED("FailedUDPAttempts", server->n_failed_udp),
1310 SD_JSON_BUILD_PAIR_UNSIGNED("FailedTCPAttempts", server->n_failed_tcp),
1311 SD_JSON_BUILD_PAIR_BOOLEAN("PacketTruncated", server->packet_truncated),
1312 SD_JSON_BUILD_PAIR_BOOLEAN("PacketBadOpt", server->packet_bad_opt),
1313 SD_JSON_BUILD_PAIR_BOOLEAN("PacketRRSIGMissing", server->packet_rrsig_missing),
1314 SD_JSON_BUILD_PAIR_BOOLEAN("PacketInvalid", server->packet_invalid),
1315 SD_JSON_BUILD_PAIR_BOOLEAN("PacketDoOff", server->packet_do_off));
1316 }
1317
1318 int dns_server_is_accessible(DnsServer *s) {
1319 _cleanup_close_ int fd = -EBADF;
1320 union sockaddr_union sa;
1321 int r;
1322
1323 assert(s);
1324
1325 if (s->accessible >= 0)
1326 return s->accessible;
1327
1328 r = sockaddr_set_in_addr(&sa, s->family, &s->address, dns_server_port(s));
1329 if (r < 0)
1330 return r;
1331
1332 fd = socket(s->family, SOCK_DGRAM|SOCK_CLOEXEC, 0);
1333 if (fd < 0)
1334 return -errno;
1335
1336 if (s->family == AF_INET6 && in_addr_is_link_local(AF_INET6, &s->address)) {
1337 /* Connecting to ipv6 link-local requires binding to an interface. */
1338 r = socket_bind_to_ifindex(fd, dns_server_ifindex(s));
1339 if (r < 0)
1340 return r;
1341 }
1342
1343 r = RET_NERRNO(connect(fd, &sa.sa, sockaddr_len(&sa)));
1344 if (!IN_SET(r,
1345 0,
1346 -ENETUNREACH,
1347 -EHOSTDOWN,
1348 -EHOSTUNREACH,
1349 -ENETDOWN,
1350 -ENETRESET,
1351 -ENONET))
1352 /* If we did not receive one of the expected return values,
1353 * then leave the accessible flag untouched. */
1354 return r;
1355
1356 return (s->accessible = r >= 0);
1357 }
1358
1359 void dns_server_reset_accessible_all(DnsServer *first) {
1360 LIST_FOREACH(servers, s, first)
1361 dns_server_reset_accessible(s);
1362 }
1363
1364 int dns_server_dump_configuration_to_json(DnsServer *server, sd_json_variant **ret) {
1365 bool accessible = false;
1366 int ifindex, r;
1367
1368 assert(server);
1369 assert(ret);
1370
1371 ifindex = dns_server_ifindex(server);
1372
1373 r = dns_server_is_accessible(server);
1374 if (r < 0)
1375 log_debug_errno(r, "Failed to check if %s is accessible, assume not: %m", dns_server_string_full(server));
1376 else
1377 accessible = r;
1378
1379 return sd_json_buildo(
1380 ret,
1381 JSON_BUILD_PAIR_STRING_NON_EMPTY("addressString", dns_server_string(server)),
1382 JSON_BUILD_PAIR_IN_ADDR("address", server->family, &server->address),
1383 SD_JSON_BUILD_PAIR_INTEGER("family", server->family),
1384 SD_JSON_BUILD_PAIR_UNSIGNED("port", dns_server_port(server)),
1385 SD_JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", SD_JSON_BUILD_UNSIGNED(ifindex)),
1386 JSON_BUILD_PAIR_STRING_NON_EMPTY("name", server->server_name),
1387 SD_JSON_BUILD_PAIR_BOOLEAN("accessible", accessible));
1388 }