Debian Codegraph @

src/resolve/resolvectl.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <locale.h>
4 #include <net/if.h>
5
6 #include "sd-bus.h"
7 #include "sd-daemon.h"
8 #include "sd-event.h"
9 #include "sd-json.h"
10 #include "sd-netlink.h"
11 #include "sd-varlink.h"
12
13 #include "af-list.h"
14 #include "alloc-util.h"
15 #include "ansi-color.h"
16 #include "argv-util.h"
17 #include "build.h"
18 #include "bus-common-errors.h"
19 #include "bus-error.h"
20 #include "bus-locator.h"
21 #include "bus-message-util.h"
22 #include "bus-util.h"
23 #include "crypto-util.h"
24 #include "dns-configuration.h"
25 #include "dns-domain.h"
26 #include "dns-packet.h"
27 #include "dns-rr.h"
28 #include "errno-list.h"
29 #include "errno-util.h"
30 #include "escape.h"
31 #include "format-ifname.h"
32 #include "format-table.h"
33 #include "glyph-util.h"
34 #include "help-util.h"
35 #include "hostname-util.h"
36 #include "json-util.h"
37 #include "main-func.h"
38 #include "missing-network.h"
39 #include "netlink-util.h"
40 #include "options.h"
41 #include "ordered-set.h"
42 #include "pager.h"
43 #include "parse-argument.h"
44 #include "parse-util.h"
45 #include "polkit-agent.h"
46 #include "resolvconf-compat.h"
47 #include "resolve-util.h"
48 #include "resolvectl.h"
49 #include "resolved-def.h"
50 #include "resolved-util.h"
51 #include "set.h"
52 #include "socket-netlink.h"
53 #include "string-table.h"
54 #include "string-util.h"
55 #include "strv.h"
56 #include "terminal-util.h"
57 #include "time-util.h"
58 #include "utf8.h"
59 #include "varlink-util.h"
60 #include "verb-log-control.h"
61 #include "verbs.h"
62
63 static int arg_family = AF_UNSPEC;
64 static int arg_ifindex = 0;
65 static char *arg_ifname = NULL;
66 static uint16_t arg_type = 0;
67 static uint16_t arg_class = 0;
68 static bool arg_legend = true;
69 static uint64_t arg_flags = 0;
70 static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
71 static PagerFlags arg_pager_flags = 0;
72 bool arg_ifindex_permissive = false; /* If true, don't generate an error if the specified interface index doesn't exist */
73 static const char *arg_service_family = NULL;
74 static bool arg_ask_password = true;
75
76 typedef enum RawType {
77 RAW_NONE,
78 RAW_PAYLOAD,
79 RAW_PACKET,
80 } RawType;
81 static RawType arg_raw = RAW_NONE;
82
83 /* Used by compat interfaces: systemd-resolve and resolvconf. */
84 ExecutionMode arg_mode = MODE_RESOLVE_HOST;
85 char **arg_set_dns = NULL;
86 char **arg_set_domain = NULL;
87 bool arg_disable_default_route = false;
88 static const char *arg_set_llmnr = NULL;
89 static const char *arg_set_mdns = NULL;
90 static const char *arg_set_dns_over_tls = NULL;
91 static const char *arg_set_dnssec = NULL;
92 static char **arg_set_nta = NULL;
93
94 STATIC_DESTRUCTOR_REGISTER(arg_ifname, freep);
95 STATIC_DESTRUCTOR_REGISTER(arg_set_dns, strv_freep);
96 STATIC_DESTRUCTOR_REGISTER(arg_set_domain, strv_freep);
97 STATIC_DESTRUCTOR_REGISTER(arg_set_nta, strv_freep);
98
99 typedef enum StatusMode {
100 STATUS_ALL,
101 STATUS_DNS,
102 STATUS_DOMAIN,
103 STATUS_DEFAULT_ROUTE,
104 STATUS_LLMNR,
105 STATUS_MDNS,
106 STATUS_DNS_OVER_TLS,
107 STATUS_DNSSEC,
108 STATUS_NTA,
109 _STATUS_MAX,
110 _STATUS_INVALID = -EINVAL,
111 } StatusMode;
112
113 static const char* const status_mode_json_field_table[_STATUS_MAX] = {
114 [STATUS_ALL] = NULL,
115 [STATUS_DNS] = "servers",
116 [STATUS_DOMAIN] = "searchDomains",
117 [STATUS_DEFAULT_ROUTE] = "defaultRoute",
118 [STATUS_LLMNR] = "llmnr",
119 [STATUS_MDNS] = "mDNS",
120 [STATUS_DNS_OVER_TLS] = "dnsOverTLS",
121 [STATUS_DNSSEC] = "dnssec",
122 [STATUS_NTA] = "negativeTrustAnchors",
123 };
124
125 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(status_mode_json_field, StatusMode);
126
127 static int strv_extend_extended_bool(char ***strv, const char *name, const char *value) {
128 int r;
129
130 if (value) {
131 r = parse_boolean(value);
132 if (r >= 0)
133 return strv_extendf(strv, "%s%s", plus_minus(r), name);
134 }
135
136 return strv_extendf(strv, "%s=%s", name, value ?: "???");
137 }
138
139 static int acquire_bus(sd_bus **ret) {
140 _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
141 int r;
142
143 assert(ret);
144
145 r = sd_bus_open_system(&bus);
146 if (r < 0)
147 return log_error_errno(r, "sd_bus_open_system: %m");
148
149 (void) sd_bus_set_allow_interactive_authorization(bus, arg_ask_password);
150
151 *ret = TAKE_PTR(bus);
152 return 0;
153 }
154
155 int ifname_mangle_full(const char *s, bool drop_protocol_specifier) {
156 _cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
157 _cleanup_strv_free_ char **found = NULL;
158 int r;
159
160 assert(s);
161
162 if (drop_protocol_specifier) {
163 _cleanup_free_ char *buf = NULL;
164 int ifindex_longest_name = -ENODEV;
165
166 /* When invoked as resolvconf, drop the protocol specifier(s) at the end. */
167
168 buf = strdup(s);
169 if (!buf)
170 return log_oom();
171
172 for (;;) {
173 r = rtnl_resolve_interface(&rtnl, buf);
174 if (r > 0) {
175 if (ifindex_longest_name <= 0)
176 ifindex_longest_name = r;
177
178 r = strv_extend(&found, buf);
179 if (r < 0)
180 return log_oom();
181 }
182
183 char *dot = strrchr(buf, '.');
184 if (!dot)
185 break;
186
187 *dot = '\0';
188 }
189
190 unsigned n = strv_length(found);
191 if (n > 1) {
192 _cleanup_free_ char *joined = NULL;
193
194 joined = strv_join(found, ", ");
195 log_warning("Found multiple interfaces (%s) matching with '%s'. Using '%s' (ifindex=%i).",
196 strna(joined), s, found[0], ifindex_longest_name);
197
198 } else if (n == 1) {
199 const char *proto;
200
201 proto = ASSERT_PTR(startswith(s, found[0]));
202 if (!isempty(proto))
203 log_info("Dropped protocol specifier '%s' from '%s'. Using '%s' (ifindex=%i).",
204 proto, s, found[0], ifindex_longest_name);
205 }
206
207 r = ifindex_longest_name;
208 } else
209 r = rtnl_resolve_interface(&rtnl, s);
210 if (r < 0) {
211 if (ERRNO_IS_DEVICE_ABSENT(r) && arg_ifindex_permissive) {
212 log_debug_errno(r, "Interface '%s' not found, but -f specified, ignoring: %m", s);
213 return 0; /* done */
214 }
215 return log_error_errno(r, "Failed to resolve interface \"%s\": %m", s);
216 }
217
218 if (arg_ifindex > 0 && arg_ifindex != r)
219 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Specified multiple different interfaces. Refusing.");
220
221 arg_ifindex = r;
222 return free_and_strdup_warn(&arg_ifname, found ? found[0] : s); /* found */
223 }
224
225 static void print_source(uint64_t flags, usec_t rtt) {
226 if (!arg_legend)
227 return;
228
229 if (sd_json_format_enabled(arg_json_format_flags))
230 return;
231
232 if (flags == 0)
233 return;
234
235 printf("\n%s-- Information acquired via", ansi_grey());
236
237 printf(" protocol%s%s%s%s%s",
238 flags & SD_RESOLVED_DNS ? " DNS" :"",
239 flags & SD_RESOLVED_LLMNR_IPV4 ? " LLMNR/IPv4" : "",
240 flags & SD_RESOLVED_LLMNR_IPV6 ? " LLMNR/IPv6" : "",
241 flags & SD_RESOLVED_MDNS_IPV4 ? " mDNS/IPv4" : "",
242 flags & SD_RESOLVED_MDNS_IPV6 ? " mDNS/IPv6" : "");
243
244 printf(" in %s.%s\n"
245 "%s-- Data is authenticated: %s; Data was acquired via local or encrypted transport: %s%s\n",
246 FORMAT_TIMESPAN(rtt, 100),
247 ansi_normal(),
248 ansi_grey(),
249 yes_no(flags & SD_RESOLVED_AUTHENTICATED),
250 yes_no(flags & SD_RESOLVED_CONFIDENTIAL),
251 ansi_normal());
252
253 if ((flags & (SD_RESOLVED_FROM_MASK|SD_RESOLVED_SYNTHETIC)) != 0)
254 printf("%s-- Data from:%s%s%s%s%s%s%s\n",
255 ansi_grey(),
256 FLAGS_SET(flags, SD_RESOLVED_SYNTHETIC) ? " synthetic" : "",
257 FLAGS_SET(flags, SD_RESOLVED_FROM_CACHE) ? " cache" : "",
258 FLAGS_SET(flags, SD_RESOLVED_FROM_ZONE) ? " zone" : "",
259 FLAGS_SET(flags, SD_RESOLVED_FROM_TRUST_ANCHOR) ? " trust-anchor" : "",
260 FLAGS_SET(flags, SD_RESOLVED_FROM_NETWORK) ? " network" : "",
261 FLAGS_SET(flags, SD_RESOLVED_FROM_HOOK) ? " hook" : "",
262 ansi_normal());
263 }
264
265 static void print_ifindex_comment(int printed_so_far, int ifindex) {
266 char ifname[IF_NAMESIZE];
267 int r;
268
269 if (ifindex <= 0)
270 return;
271
272 r = format_ifname(ifindex, ifname);
273 if (r < 0)
274 return (void) log_warning_errno(r, "Failed to resolve interface name for index %i, ignoring: %m", ifindex);
275
276 printf("%*s%s-- link: %s%s",
277 60 > printed_so_far ? 60 - printed_so_far : 0, " ", /* Align comment to the 60th column */
278 ansi_grey(), ifname, ansi_normal());
279 }
280
281 static int resolve_host_error(const char *name, int r, const sd_bus_error *error) {
282 if (sd_bus_error_has_name(error, BUS_ERROR_DNS_NXDOMAIN))
283 return log_error_errno(r, "%s: %s", name, bus_error_message(error, r));
284
285 return log_error_errno(r, "%s: resolve call failed: %s", name, bus_error_message(error, r));
286 }
287
288 static int resolve_host(sd_bus *bus, const char *name) {
289 _cleanup_(sd_bus_message_unrefp) sd_bus_message *req = NULL, *reply = NULL;
290 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
291 const char *canonical = NULL;
292 unsigned c = 0;
293 uint64_t flags;
294 usec_t ts;
295 int r;
296
297 assert(name);
298
299 if (sd_json_format_enabled(arg_json_format_flags))
300 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Use --json=pretty with --type=A or --type=AAAA to acquire address record information in JSON format.");
301
302 log_debug("Resolving %s (family %s, interface %s).", name, af_to_name(arg_family) ?: "*", isempty(arg_ifname) ? "*" : arg_ifname);
303
304 r = bus_message_new_method_call(bus, &req, bus_resolve_mgr, "ResolveHostname");
305 if (r < 0)
306 return bus_log_create_error(r);
307
308 r = sd_bus_message_append(req, "isit", arg_ifindex, name, arg_family, arg_flags);
309 if (r < 0)
310 return bus_log_create_error(r);
311
312 ts = now(CLOCK_MONOTONIC);
313
314 r = sd_bus_call(bus, req, SD_RESOLVED_QUERY_TIMEOUT_USEC, &error, &reply);
315 if (r < 0)
316 return resolve_host_error(name, r, &error);
317
318 ts = now(CLOCK_MONOTONIC) - ts;
319
320 r = sd_bus_message_enter_container(reply, 'a', "(iiay)");
321 if (r < 0)
322 return bus_log_parse_error(r);
323
324 while ((r = sd_bus_message_enter_container(reply, 'r', "iiay")) > 0) {
325 _cleanup_free_ char *pretty = NULL;
326 int ifindex, family, k;
327 union in_addr_union a;
328
329 assert_cc(sizeof(int) == sizeof(int32_t));
330
331 r = sd_bus_message_read(reply, "i", &ifindex);
332 if (r < 0)
333 return bus_log_parse_error(r);
334
335 sd_bus_error_free(&error);
336 r = bus_message_read_in_addr_auto(reply, &error, &family, &a);
337 if (r < 0 && !sd_bus_error_has_name(&error, SD_BUS_ERROR_INVALID_ARGS))
338 return log_error_errno(r, "%s: systemd-resolved returned invalid result: %s", name, bus_error_message(&error, r));
339
340 r = sd_bus_message_exit_container(reply);
341 if (r < 0)
342 return bus_log_parse_error(r);
343
344 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_INVALID_ARGS)) {
345 log_debug_errno(r, "%s: systemd-resolved returned invalid result, ignoring: %s", name, bus_error_message(&error, r));
346 continue;
347 }
348
349 r = in_addr_ifindex_to_string(family, &a, ifindex, &pretty);
350 if (r < 0)
351 return log_error_errno(r, "Failed to print address for %s: %m", name);
352
353 k = printf("%*s%s %s%s%s",
354 (int) strlen(name), c == 0 ? name : "", c == 0 ? ":" : " ",
355 ansi_highlight(), pretty, ansi_normal());
356
357 print_ifindex_comment(k, ifindex);
358 fputc('\n', stdout);
359
360 c++;
361 }
362 if (r < 0)
363 return bus_log_parse_error(r);
364
365 r = sd_bus_message_exit_container(reply);
366 if (r < 0)
367 return bus_log_parse_error(r);
368
369 r = sd_bus_message_read(reply, "st", &canonical, &flags);
370 if (r < 0)
371 return bus_log_parse_error(r);
372
373 if (!streq(name, canonical))
374 printf("%*s%s (%s)\n",
375 (int) strlen(name), c == 0 ? name : "", c == 0 ? ":" : " ",
376 canonical);
377
378 if (c == 0)
379 return log_error_errno(SYNTHETIC_ERRNO(ESRCH),
380 "%s: no addresses found", name);
381
382 print_source(flags, ts);
383
384 return 0;
385 }
386
387 static int resolve_address(sd_bus *bus, int family, const union in_addr_union *address, int ifindex) {
388 _cleanup_(sd_bus_message_unrefp) sd_bus_message *req = NULL, *reply = NULL;
389 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
390 _cleanup_free_ char *pretty = NULL;
391 uint64_t flags;
392 unsigned c = 0;
393 usec_t ts;
394 int r;
395
396 assert(bus);
397 assert(IN_SET(family, AF_INET, AF_INET6));
398 assert(address);
399
400 if (sd_json_format_enabled(arg_json_format_flags))
401 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Use --json=pretty with --type= to acquire resource record information in JSON format.");
402
403 if (ifindex <= 0)
404 ifindex = arg_ifindex;
405
406 r = in_addr_ifindex_to_string(family, address, ifindex, &pretty);
407 if (r < 0)
408 return log_oom();
409
410 log_debug("Resolving %s.", pretty);
411
412 r = bus_message_new_method_call(bus, &req, bus_resolve_mgr, "ResolveAddress");
413 if (r < 0)
414 return bus_log_create_error(r);
415
416 r = sd_bus_message_append(req, "ii", ifindex, family);
417 if (r < 0)
418 return bus_log_create_error(r);
419
420 r = sd_bus_message_append_array(req, 'y', address, FAMILY_ADDRESS_SIZE(family));
421 if (r < 0)
422 return bus_log_create_error(r);
423
424 r = sd_bus_message_append(req, "t", arg_flags);
425 if (r < 0)
426 return bus_log_create_error(r);
427
428 ts = now(CLOCK_MONOTONIC);
429
430 r = sd_bus_call(bus, req, SD_RESOLVED_QUERY_TIMEOUT_USEC, &error, &reply);
431 if (r < 0)
432 return log_error_errno(r, "%s: resolve call failed: %s", pretty, bus_error_message(&error, r));
433
434 ts = now(CLOCK_MONOTONIC) - ts;
435
436 r = sd_bus_message_enter_container(reply, 'a', "(is)");
437 if (r < 0)
438 return bus_log_create_error(r);
439
440 while ((r = sd_bus_message_enter_container(reply, 'r', "is")) > 0) {
441 const char *n;
442 int k;
443
444 assert_cc(sizeof(int) == sizeof(int32_t));
445
446 r = sd_bus_message_read(reply, "is", &ifindex, &n);
447 if (r < 0)
448 return r;
449
450 r = sd_bus_message_exit_container(reply);
451 if (r < 0)
452 return r;
453
454 k = printf("%*s%s %s%s%s",
455 (int) strlen(pretty), c == 0 ? pretty : "",
456 c == 0 ? ":" : " ",
457 ansi_highlight(), n, ansi_normal());
458
459 print_ifindex_comment(k, ifindex);
460 fputc('\n', stdout);
461
462 c++;
463 }
464 if (r < 0)
465 return bus_log_parse_error(r);
466
467 r = sd_bus_message_exit_container(reply);
468 if (r < 0)
469 return bus_log_parse_error(r);
470
471 r = sd_bus_message_read(reply, "t", &flags);
472 if (r < 0)
473 return bus_log_parse_error(r);
474
475 if (c == 0)
476 return log_error_errno(SYNTHETIC_ERRNO(ESRCH),
477 "%s: no names found", pretty);
478
479 print_source(flags, ts);
480
481 return 0;
482 }
483
484 static int output_rr_packet(const void *d, size_t l, int ifindex) {
485 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
486 int r;
487
488 assert(d || l == 0);
489
490 r = dns_resource_record_new_from_raw(&rr, d, l);
491 if (r < 0)
492 return log_error_errno(r, "Failed to parse RR: %m");
493
494 if (sd_json_format_enabled(arg_json_format_flags)) {
495 _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
496 r = dns_resource_record_to_json(rr, &j);
497 if (r < 0)
498 return log_error_errno(r, "Failed to convert RR to JSON: %m");
499
500 if (!j)
501 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "JSON formatting for records of type %s (%u) not available.", dns_type_to_string(rr->key->type), rr->key->type);
502
503 r = sd_json_variant_dump(j, arg_json_format_flags, NULL, NULL);
504 if (r < 0)
505 return r;
506
507 } else if (arg_raw == RAW_PAYLOAD) {
508 const void *data;
509 ssize_t k;
510
511 k = dns_resource_record_payload(rr, &data);
512 if (k == -EINVAL)
513 return log_error_errno(k, "Dumping of binary payload not available for RRs of this type: %s", dns_type_to_string(rr->key->type));
514 if (k < 0)
515 return log_error_errno(k, "Cannot dump RR: %m");
516 fwrite(data, 1, k, stdout);
517 } else {
518 const char *s;
519 int k;
520
521 s = dns_resource_record_to_string(rr);
522 if (!s)
523 return log_oom();
524
525 k = printf("%s", s);
526 print_ifindex_comment(k, ifindex);
527 fputc('\n', stdout);
528 }
529
530 return 0;
531 }
532
533 static int idna_candidate(const char *name, char **ret) {
534 _cleanup_free_ char *idnafied = NULL;
535 int r;
536
537 assert(name);
538 assert(ret);
539
540 r = dns_name_apply_idna(name, &idnafied);
541 if (r < 0)
542 return log_error_errno(r, "Failed to apply IDNA to name '%s': %m", name);
543 if (r > 0 && !streq(name, idnafied)) {
544 *ret = TAKE_PTR(idnafied);
545 return true;
546 }
547
548 *ret = NULL;
549 return false;
550 }
551
552 static bool single_label_nonsynthetic(const char *name) {
553 _cleanup_free_ char *first_label = NULL;
554 int r;
555
556 if (!dns_name_is_single_label(name))
557 return false;
558
559 if (is_localhost(name) ||
560 is_gateway_hostname(name) ||
561 is_outbound_hostname(name) ||
562 is_dns_stub_hostname(name) ||
563 is_dns_proxy_stub_hostname(name))
564 return false;
565
566 r = resolve_system_hostname(NULL, &first_label);
567 if (r < 0) {
568 log_warning_errno(r, "Failed to determine the hostname: %m");
569 return false;
570 }
571
572 return !streq(name, first_label);
573 }
574
575 static int resolve_record(sd_bus *bus, const char *name, uint16_t class, uint16_t type, bool warn_missing) {
576 _cleanup_(sd_bus_message_unrefp) sd_bus_message *req = NULL, *reply = NULL;
577 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
578 _cleanup_free_ char *idnafied = NULL;
579 bool needs_authentication = false;
580 unsigned n = 0;
581 uint64_t flags;
582 usec_t ts;
583 int r;
584
585 assert(name);
586
587 log_debug("Resolving %s %s %s (interface %s).", name, dns_class_to_string(class), dns_type_to_string(type), isempty(arg_ifname) ? "*" : arg_ifname);
588
589 if (dns_name_dot_suffixed(name) == 0 && single_label_nonsynthetic(name))
590 log_notice("(Note that search domains are not appended when --type= is specified. "
591 "Please specify fully qualified domain names, or remove --type= switch from invocation in order to request regular hostname resolution.)");
592
593 r = idna_candidate(name, &idnafied);
594 if (r < 0)
595 return r;
596 if (r > 0)
597 log_notice("(Note that IDNA translation is not applied when --type= is specified. "
598 "Please specify translated domain names — i.e. '%s' — when resolving raw records, or remove --type= switch from invocation in order to request regular hostname resolution.",
599 idnafied);
600
601 r = bus_message_new_method_call(bus, &req, bus_resolve_mgr, "ResolveRecord");
602 if (r < 0)
603 return bus_log_create_error(r);
604
605 r = sd_bus_message_append(req, "isqqt", arg_ifindex, name, class, type, arg_flags);
606 if (r < 0)
607 return bus_log_create_error(r);
608
609 ts = now(CLOCK_MONOTONIC);
610
611 r = sd_bus_call(bus, req, SD_RESOLVED_QUERY_TIMEOUT_USEC, &error, &reply);
612 if (r < 0) {
613 if (warn_missing || r != -ENXIO)
614 log_error("%s: resolve call failed: %s", name, bus_error_message(&error, r));
615 return r;
616 }
617
618 ts = now(CLOCK_MONOTONIC) - ts;
619
620 r = sd_bus_message_enter_container(reply, 'a', "(iqqay)");
621 if (r < 0)
622 return bus_log_parse_error(r);
623
624 while ((r = sd_bus_message_enter_container(reply, 'r', "iqqay")) > 0) {
625 uint16_t c, t;
626 int ifindex;
627 const void *d;
628 size_t l;
629
630 assert_cc(sizeof(int) == sizeof(int32_t));
631
632 r = sd_bus_message_read(reply, "iqq", &ifindex, &c, &t);
633 if (r < 0)
634 return bus_log_parse_error(r);
635
636 r = sd_bus_message_read_array(reply, 'y', &d, &l);
637 if (r < 0)
638 return bus_log_parse_error(r);
639
640 r = sd_bus_message_exit_container(reply);
641 if (r < 0)
642 return bus_log_parse_error(r);
643
644 if (arg_raw == RAW_PACKET) {
645 uint64_t u64 = htole64(l);
646
647 fwrite(&u64, sizeof(u64), 1, stdout);
648 fwrite(d, 1, l, stdout);
649 } else {
650 r = output_rr_packet(d, l, ifindex);
651 if (r < 0)
652 return r;
653 }
654
655 if (dns_type_needs_authentication(t))
656 needs_authentication = true;
657
658 n++;
659 }
660 if (r < 0)
661 return bus_log_parse_error(r);
662
663 r = sd_bus_message_exit_container(reply);
664 if (r < 0)
665 return bus_log_parse_error(r);
666
667 r = sd_bus_message_read(reply, "t", &flags);
668 if (r < 0)
669 return bus_log_parse_error(r);
670
671 if (n == 0) {
672 if (warn_missing)
673 log_error("%s: no records found", name);
674 return -ESRCH;
675 }
676
677 print_source(flags, ts);
678
679 if ((flags & SD_RESOLVED_AUTHENTICATED) == 0 && needs_authentication) {
680 fflush(stdout);
681
682 fprintf(stderr, "\n%s"
683 "WARNING: The resources shown contain cryptographic key data which could not be\n"
684 " authenticated. It is not suitable to authenticate any communication.\n"
685 " This is usually indication that DNSSEC authentication was not enabled\n"
686 " or is not available for the selected protocol or DNS servers.%s\n",
687 ansi_highlight_red(),
688 ansi_normal());
689 }
690
691 return 0;
692 }
693
694 static int resolve_rfc4501(sd_bus *bus, const char *name) {
695 uint16_t type = 0, class = 0;
696 const char *p, *q, *n;
697 int r;
698
699 assert(bus);
700 assert(name);
701 assert(startswith(name, "dns:"));
702
703 /* Parse RFC 4501 dns: URIs */
704
705 p = name + 4;
706
707 if (p[0] == '/') {
708 const char *e;
709
710 if (p[1] != '/')
711 goto invalid;
712
713 e = strchr(p + 2, '/');
714 if (!e)
715 goto invalid;
716
717 if (e != p + 2)
718 log_warning("DNS authority specification not supported; ignoring specified authority.");
719
720 p = e + 1;
721 }
722
723 q = strchr(p, '?');
724 if (q) {
725 n = strndupa_safe(p, q - p);
726 q++;
727
728 for (;;) {
729 const char *f;
730
731 f = startswith_no_case(q, "class=");
732 if (f) {
733 _cleanup_free_ char *t = NULL;
734 const char *e;
735
736 if (class != 0)
737 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
738 "DNS class specified twice.");
739
740 e = strchrnul(f, ';');
741 t = strndup(f, e - f);
742 if (!t)
743 return log_oom();
744
745 r = dns_class_from_string(t);
746 if (r < 0)
747 return log_error_errno(r, "Unknown DNS class %s.", t);
748
749 class = r;
750
751 if (*e == ';') {
752 q = e + 1;
753 continue;
754 }
755
756 break;
757 }
758
759 f = startswith_no_case(q, "type=");
760 if (f) {
761 _cleanup_free_ char *t = NULL;
762 const char *e;
763
764 if (type != 0)
765 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
766 "DNS type specified twice.");
767
768 e = strchrnul(f, ';');
769 t = strndup(f, e - f);
770 if (!t)
771 return log_oom();
772
773 r = dns_type_from_string(t);
774 if (r < 0)
775 return log_error_errno(r, "Unknown DNS type %s: %m", t);
776
777 type = r;
778
779 if (*e == ';') {
780 q = e + 1;
781 continue;
782 }
783
784 break;
785 }
786
787 goto invalid;
788 }
789 } else
790 n = p;
791
792 if (class == 0)
793 class = arg_class ?: DNS_CLASS_IN;
794 if (type == 0)
795 type = arg_type ?: DNS_TYPE_A;
796
797 return resolve_record(bus, n, class, type, true);
798
799 invalid:
800 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
801 "Invalid DNS URI: %s", name);
802 }
803
804 VERB(verb_query, "query", "HOSTNAME|ADDRESS…", 2, VERB_ANY, 0,
805 "Resolve domain names, IPv4 and IPv6 addresses");
806 static int verb_query(int argc, char *argv[], uintptr_t _data, void *userdata) {
807 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
808 int ret = 0, r;
809
810 r = acquire_bus(&bus);
811 if (r < 0)
812 return r;
813
814 if (arg_type != 0)
815 STRV_FOREACH(p, strv_skip(argv, 1))
816 RET_GATHER(ret, resolve_record(bus, *p, arg_class, arg_type, true));
817
818 else
819 STRV_FOREACH(p, strv_skip(argv, 1)) {
820 if (startswith(*p, "dns:"))
821 RET_GATHER(ret, resolve_rfc4501(bus, *p));
822 else {
823 int family, ifindex;
824 union in_addr_union a;
825
826 r = in_addr_ifindex_from_string_auto(*p, &family, &a, &ifindex);
827 if (r >= 0)
828 RET_GATHER(ret, resolve_address(bus, family, &a, ifindex));
829 else
830 RET_GATHER(ret, resolve_host(bus, *p));
831 }
832 }
833
834 return ret;
835 }
836
837 static int resolve_service(sd_bus *bus, const char *name, const char *type, const char *domain) {
838 const char *canonical_name, *canonical_type, *canonical_domain;
839 _cleanup_(sd_bus_message_unrefp) sd_bus_message *req = NULL, *reply = NULL;
840 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
841 size_t indent, sz;
842 uint64_t flags;
843 const char *p;
844 unsigned c;
845 usec_t ts;
846 int r;
847
848 assert(bus);
849 assert(domain);
850
851 name = empty_to_null(name);
852 type = empty_to_null(type);
853
854 if (name)
855 log_debug("Resolving service \"%s\" of type %s in %s (family %s, interface %s).", name, type, domain, af_to_name(arg_family) ?: "*", isempty(arg_ifname) ? "*" : arg_ifname);
856 else if (type)
857 log_debug("Resolving service type %s of %s (family %s, interface %s).", type, domain, af_to_name(arg_family) ?: "*", isempty(arg_ifname) ? "*" : arg_ifname);
858 else
859 log_debug("Resolving service type %s (family %s, interface %s).", domain, af_to_name(arg_family) ?: "*", isempty(arg_ifname) ? "*" : arg_ifname);
860
861 r = bus_message_new_method_call(bus, &req, bus_resolve_mgr, "ResolveService");
862 if (r < 0)
863 return bus_log_create_error(r);
864
865 r = sd_bus_message_append(req, "isssit", arg_ifindex, name, type, domain, arg_family, arg_flags);
866 if (r < 0)
867 return bus_log_create_error(r);
868
869 ts = now(CLOCK_MONOTONIC);
870
871 r = sd_bus_call(bus, req, SD_RESOLVED_QUERY_TIMEOUT_USEC, &error, &reply);
872 if (r < 0)
873 return log_error_errno(r, "Resolve call failed: %s", bus_error_message(&error, r));
874
875 ts = now(CLOCK_MONOTONIC) - ts;
876
877 r = sd_bus_message_enter_container(reply, 'a', "(qqqsa(iiay)s)");
878 if (r < 0)
879 return bus_log_parse_error(r);
880
881 indent =
882 (name ? strlen(name) + 1 : 0) +
883 (type ? strlen(type) + 1 : 0) +
884 strlen(domain) + 2;
885
886 c = 0;
887 while ((r = sd_bus_message_enter_container(reply, 'r', "qqqsa(iiay)s")) > 0) {
888 uint16_t priority, weight, port;
889 const char *hostname, *canonical;
890
891 r = sd_bus_message_read(reply, "qqqs", &priority, &weight, &port, &hostname);
892 if (r < 0)
893 return bus_log_parse_error(r);
894
895 if (name)
896 printf("%*s%s", (int) strlen(name), c == 0 ? name : "", c == 0 ? "/" : " ");
897 if (type)
898 printf("%*s%s", (int) strlen(type), c == 0 ? type : "", c == 0 ? "/" : " ");
899
900 printf("%*s%s %s:%u [priority=%u, weight=%u]\n",
901 (int) strlen(domain), c == 0 ? domain : "",
902 c == 0 ? ":" : " ",
903 hostname, port,
904 priority, weight);
905
906 r = sd_bus_message_enter_container(reply, 'a', "(iiay)");
907 if (r < 0)
908 return bus_log_parse_error(r);
909
910 while ((r = sd_bus_message_enter_container(reply, 'r', "iiay")) > 0) {
911 _cleanup_free_ char *pretty = NULL;
912 int ifindex, family, k;
913 union in_addr_union a;
914
915 assert_cc(sizeof(int) == sizeof(int32_t));
916
917 r = sd_bus_message_read(reply, "i", &ifindex);
918 if (r < 0)
919 return bus_log_parse_error(r);
920
921 sd_bus_error_free(&error);
922 r = bus_message_read_in_addr_auto(reply, &error, &family, &a);
923 if (r < 0 && !sd_bus_error_has_name(&error, SD_BUS_ERROR_INVALID_ARGS))
924 return log_error_errno(r, "%s: systemd-resolved returned invalid result: %s", name, bus_error_message(&error, r));
925
926 r = sd_bus_message_exit_container(reply);
927 if (r < 0)
928 return bus_log_parse_error(r);
929
930 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_INVALID_ARGS)) {
931 log_debug_errno(r, "%s: systemd-resolved returned invalid result, ignoring: %s", name, bus_error_message(&error, r));
932 continue;
933 }
934
935 r = in_addr_ifindex_to_string(family, &a, ifindex, &pretty);
936 if (r < 0)
937 return log_error_errno(r, "Failed to print address for %s: %m", name);
938
939 k = printf("%*s%s", (int) indent, "", pretty);
940 print_ifindex_comment(k, ifindex);
941 fputc('\n', stdout);
942 }
943 if (r < 0)
944 return bus_log_parse_error(r);
945
946 r = sd_bus_message_exit_container(reply);
947 if (r < 0)
948 return bus_log_parse_error(r);
949
950 r = sd_bus_message_read(reply, "s", &canonical);
951 if (r < 0)
952 return bus_log_parse_error(r);
953
954 if (!streq(hostname, canonical))
955 printf("%*s(%s)\n", (int) indent, "", canonical);
956
957 r = sd_bus_message_exit_container(reply);
958 if (r < 0)
959 return bus_log_parse_error(r);
960
961 c++;
962 }
963 if (r < 0)
964 return bus_log_parse_error(r);
965
966 r = sd_bus_message_exit_container(reply);
967 if (r < 0)
968 return bus_log_parse_error(r);
969
970 r = sd_bus_message_enter_container(reply, 'a', "ay");
971 if (r < 0)
972 return bus_log_parse_error(r);
973
974 while ((r = sd_bus_message_read_array(reply, 'y', (const void**) &p, &sz)) > 0) {
975 _cleanup_free_ char *escaped = NULL;
976
977 escaped = cescape_length(p, sz);
978 if (!escaped)
979 return log_oom();
980
981 printf("%*s%s\n", (int) indent, "", escaped);
982 }
983 if (r < 0)
984 return bus_log_parse_error(r);
985
986 r = sd_bus_message_exit_container(reply);
987 if (r < 0)
988 return bus_log_parse_error(r);
989
990 r = sd_bus_message_read(reply, "ssst", &canonical_name, &canonical_type, &canonical_domain, &flags);
991 if (r < 0)
992 return bus_log_parse_error(r);
993
994 canonical_name = empty_to_null(canonical_name);
995 canonical_type = empty_to_null(canonical_type);
996
997 if (!streq_ptr(name, canonical_name) ||
998 !streq_ptr(type, canonical_type) ||
999 !streq_ptr(domain, canonical_domain)) {
1000
1001 printf("%*s(", (int) indent, "");
1002
1003 if (canonical_name)
1004 printf("%s/", canonical_name);
1005 if (canonical_type)
1006 printf("%s/", canonical_type);
1007
1008 printf("%s)\n", canonical_domain);
1009 }
1010
1011 print_source(flags, ts);
1012
1013 return 0;
1014 }
1015
1016 VERB(verb_service, "service", "[[NAME] TYPE] DOMAIN", 2, 4, 0,
1017 "Resolve service (SRV)");
1018 static int verb_service(int argc, char *argv[], uintptr_t _data, void *userdata) {
1019 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1020 int r;
1021
1022 r = acquire_bus(&bus);
1023 if (r < 0)
1024 return r;
1025
1026 if (sd_json_format_enabled(arg_json_format_flags))
1027 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Use --json=pretty with --type= to acquire resource record information in JSON format.");
1028
1029 if (argc == 2)
1030 return resolve_service(bus, NULL, NULL, argv[1]);
1031 else if (argc == 3)
1032 return resolve_service(bus, NULL, argv[1], argv[2]);
1033 else
1034 return resolve_service(bus, argv[1], argv[2], argv[3]);
1035 }
1036
1037 #if HAVE_OPENSSL
1038 static int resolve_openpgp(sd_bus *bus, const char *address) {
1039 int r;
1040
1041 assert(bus);
1042 assert(address);
1043
1044 const char *domain = strrchr(address, '@');
1045 if (!domain)
1046 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1047 "Address does not contain '@': \"%s\"", address);
1048 if (domain == address || domain[1] == '\0')
1049 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1050 "Address starts or ends with '@': \"%s\"", address);
1051 domain++;
1052
1053 _cleanup_free_ char *hashed = NULL;
1054 r = string_hashsum_sha256(address, domain - 1 - address, &hashed);
1055 if (r < 0)
1056 return log_error_errno(r, "Hashing failed: %m");
1057
1058 strshorten(hashed, 56);
1059
1060 _cleanup_free_ char *suffix = NULL;
1061 r = dns_name_concat("_openpgpkey", domain, /* flags= */ 0, &suffix);
1062 if (r < 0)
1063 return log_error_errno(r, "Failed to join DNS suffix: %m");
1064
1065 _cleanup_free_ char *full = NULL;
1066 r = dns_name_concat(hashed, suffix, /* flags= */ 0, &full);
1067 if (r < 0)
1068 return log_error_errno(r, "Failed to join OPENPGPKEY name: %m");
1069 log_debug("Looking up \"%s\".", full);
1070
1071 r = resolve_record(
1072 bus,
1073 full,
1074 arg_class ?: DNS_CLASS_IN,
1075 arg_type ?: DNS_TYPE_OPENPGPKEY,
1076 /* warn_missing= */ false);
1077 if (!IN_SET(r, -ENXIO, -ESRCH)) /* Not NXDOMAIN or NODATA? Then fail immediately. */
1078 return r;
1079
1080 hashed = mfree(hashed);
1081 r = string_hashsum_sha224(address, domain - 1 - address, &hashed);
1082 if (r < 0)
1083 return log_error_errno(r, "Hashing failed: %m");
1084
1085 full = mfree(full);
1086 r = dns_name_concat(hashed, suffix, /* flags= */ 0, &full);
1087 if (r < 0)
1088 return log_error_errno(r, "Failed to join OPENPGPKEY name: %m");
1089 log_debug("Looking up \"%s\".", full);
1090
1091 return resolve_record(
1092 bus,
1093 full,
1094 arg_class ?: DNS_CLASS_IN,
1095 arg_type ?: DNS_TYPE_OPENPGPKEY,
1096 /* warn_missing= */ true);
1097 }
1098 #endif
1099
1100 VERB(verb_openpgp, "openpgp", "EMAIL@DOMAIN…", 2, VERB_ANY, 0,
1101 "Query OpenPGP public key");
1102 static int verb_openpgp(int argc, char *argv[], uintptr_t _data, void *userdata) {
1103 #if HAVE_OPENSSL
1104 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1105 int r, ret = 0;
1106
1107 r = acquire_bus(&bus);
1108 if (r < 0)
1109 return r;
1110
1111 if (sd_json_format_enabled(arg_json_format_flags))
1112 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Use --json=pretty with --type= to acquire resource record information in JSON format.");
1113
1114 STRV_FOREACH(p, strv_skip(argv, 1))
1115 RET_GATHER(ret, resolve_openpgp(bus, *p));
1116
1117 return ret;
1118 #else
1119 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "OpenSSL support is disabled, cannot query Open PGP keys.");
1120 #endif
1121 }
1122
1123 static int resolve_tlsa(sd_bus *bus, const char *family, const char *address) {
1124 const char *port;
1125 uint16_t port_num = 443;
1126 _cleanup_free_ char *full = NULL;
1127 int r;
1128
1129 assert(bus);
1130 assert(address);
1131
1132 port = strrchr(address, ':');
1133 if (port) {
1134 r = parse_ip_port(port + 1, &port_num);
1135 if (r < 0)
1136 return log_error_errno(r, "Invalid port \"%s\".", port + 1);
1137
1138 address = strndupa_safe(address, port - address);
1139 }
1140
1141 r = asprintf(&full, "_%u._%s.%s",
1142 port_num,
1143 family,
1144 address);
1145 if (r < 0)
1146 return log_oom();
1147
1148 log_debug("Looking up \"%s\".", full);
1149
1150 return resolve_record(bus, full,
1151 arg_class ?: DNS_CLASS_IN,
1152 arg_type ?: DNS_TYPE_TLSA, true);
1153 }
1154
1155 static bool service_family_is_valid(const char *s) {
1156 return STR_IN_SET(s, "tcp", "udp", "sctp");
1157 }
1158
1159 VERB(verb_tlsa, "tlsa", "DOMAIN[:PORT]…", 2, VERB_ANY, 0,
1160 "Query TLS public key");
1161 static int verb_tlsa(int argc, char *argv[], uintptr_t _data, void *userdata) {
1162 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1163 const char *family = "tcp";
1164 char **args;
1165 int r, ret = 0;
1166
1167 assert(argc >= 2);
1168
1169 r = acquire_bus(&bus);
1170 if (r < 0)
1171 return r;
1172
1173 if (sd_json_format_enabled(arg_json_format_flags))
1174 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Use --json=pretty with --type= to acquire resource record information in JSON format.");
1175
1176 if (service_family_is_valid(argv[1])) {
1177 family = argv[1];
1178 args = strv_skip(argv, 2);
1179 } else
1180 args = strv_skip(argv, 1);
1181
1182 STRV_FOREACH(p, args)
1183 RET_GATHER(ret, resolve_tlsa(bus, family, *p));
1184
1185 return ret;
1186 }
1187
1188 static int varlink_dump_dns_configuration(sd_json_variant **ret) {
1189 _cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
1190 _cleanup_(sd_json_variant_unrefp) sd_json_variant *reply = NULL;
1191 sd_json_variant *v;
1192 int r;
1193
1194 assert(ret);
1195
1196 r = sd_varlink_connect_address(&vl, "/run/systemd/resolve/io.systemd.Resolve");
1197 if (r < 0)
1198 return log_error_errno(r, "Failed to connect to service /run/systemd/resolve/io.systemd.Resolve: %m");
1199
1200 r = varlink_call_and_log(vl, "io.systemd.Resolve.DumpDNSConfiguration", /* parameters= */ NULL, &reply);
1201 if (r < 0)
1202 return r;
1203
1204 v = sd_json_variant_by_key(reply, "configuration");
1205
1206 if (!sd_json_variant_is_array(v))
1207 return log_error_errno(SYNTHETIC_ERRNO(ENODATA), "DumpDNSConfiguration() response missing 'configuration' key.");
1208
1209 TAKE_PTR(reply);
1210 *ret = sd_json_variant_ref(v);
1211 return 0;
1212 }
1213
1214 static int status_json_filter_links(sd_json_variant **configuration, char **links) {
1215 _cleanup_set_free_ Set *links_by_index = NULL;
1216 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
1217 sd_json_variant *w;
1218 int r;
1219
1220 assert(configuration);
1221
1222 if (links)
1223 STRV_FOREACH(ifname, links) {
1224 int ifindex = rtnl_resolve_interface_or_warn(/* rtnl= */ NULL, *ifname);
1225 if (ifindex < 0)
1226 return ifindex;
1227
1228 r = set_ensure_put(&links_by_index, NULL, INT_TO_PTR(ifindex));
1229 if (r < 0)
1230 return r;
1231 }
1232
1233 JSON_VARIANT_ARRAY_FOREACH(w, *configuration) {
1234 int ifindex = sd_json_variant_unsigned(sd_json_variant_by_key(w, "ifindex"));
1235
1236 if (links_by_index) {
1237 if (ifindex <= 0)
1238 /* Possibly invalid, but most likely unset because this is global
1239 * or delegate configuration. */
1240 continue;
1241
1242 if (!set_contains(links_by_index, INT_TO_PTR(ifindex)))
1243 continue;
1244
1245 } else if (ifindex == LOOPBACK_IFINDEX)
1246 /* By default, exclude the loopback interface. */
1247 continue;
1248
1249 r = sd_json_variant_append_array(&v, w);
1250 if (r < 0)
1251 return r;
1252 }
1253
1254 return json_variant_unref_and_replace(*configuration, v);
1255 }
1256
1257 static int status_json_filter_fields(sd_json_variant **configuration, StatusMode mode) {
1258 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
1259 sd_json_variant *w;
1260 const char *field;
1261 int r;
1262
1263 assert(configuration);
1264
1265 field = status_mode_json_field_to_string(mode);
1266 if (!field)
1267 /* Nothing to filter for this mode. */
1268 return 0;
1269
1270 JSON_VARIANT_ARRAY_FOREACH(w, *configuration) {
1271 /* Always include identifier fields like ifname or delegate, and include the requested
1272 * field even if it is empty in the configuration. */
1273 r = sd_json_variant_append_arraybo(
1274 &v,
1275 JSON_BUILD_PAIR_VARIANT_NON_NULL("ifname", sd_json_variant_by_key(w, "ifname")),
1276 JSON_BUILD_PAIR_VARIANT_NON_NULL("ifindex", sd_json_variant_by_key(w, "ifindex")),
1277 JSON_BUILD_PAIR_VARIANT_NON_NULL("delegate", sd_json_variant_by_key(w, "delegate")),
1278 SD_JSON_BUILD_PAIR_VARIANT(field, sd_json_variant_by_key(w, field)));
1279 if (r < 0)
1280 return r;
1281 }
1282
1283 return json_variant_unref_and_replace(*configuration, v);
1284 }
1285
1286 static int format_dns_server_one(DNSConfiguration *configuration, DNSServer *s, char **ret) {
1287 bool global;
1288 int r;
1289
1290 assert(s);
1291 assert(ret);
1292
1293 global = !(configuration->ifindex > 0 || configuration->delegate);
1294
1295 if (global && s->ifindex > 0 && s->ifindex != LOOPBACK_IFINDEX) {
1296 /* This one has an (non-loopback) ifindex set, and we were told to suppress those. Hence do so. */
1297 *ret = NULL;
1298 return 0;
1299 }
1300
1301 r = in_addr_port_ifindex_name_to_string(
1302 s->family,
1303 &s->in_addr,
1304 s->port != 53 ? s->port : 0,
1305 s->ifindex,
1306 s->server_name,
1307 ret);
1308 if (r < 0)
1309 return r;
1310
1311 return 1;
1312 }
1313
1314 static int format_dns_servers(DNSConfiguration *configuration, OrderedSet *servers, char ***ret) {
1315 int r;
1316
1317 assert(ret);
1318
1319 _cleanup_strv_free_ char **l = NULL;
1320 DNSServer *s;
1321 ORDERED_SET_FOREACH(s, servers) {
1322 _cleanup_free_ char *str = NULL;
1323 r = format_dns_server_one(configuration, s, &str);
1324 if (r < 0)
1325 return r;
1326 if (r > 0) {
1327 r = strv_consume(&l, TAKE_PTR(str));
1328 if (r < 0)
1329 return log_oom();
1330 }
1331 }
1332
1333 *ret = TAKE_PTR(l);
1334 return 0;
1335 }
1336
1337 static int format_search_domains(DNSConfiguration *configuration, OrderedSet *domains, char ***ret) {
1338 int r;
1339
1340 assert(ret);
1341
1342 _cleanup_strv_free_ char **l = NULL;
1343 SearchDomain *d;
1344 ORDERED_SET_FOREACH(d, domains) {
1345 if (!(configuration->ifindex > 0 || configuration->delegate) && d->ifindex > 0)
1346 /* Only show the global ones here */
1347 continue;
1348
1349 _cleanup_free_ char *str = NULL;
1350 if (d->route_only)
1351 str = strjoin("~", d->name);
1352 else
1353 str = strdup(d->name);
1354 if (!str)
1355 return log_oom();
1356
1357 r = strv_consume(&l, TAKE_PTR(str));
1358 if (r < 0)
1359 return log_oom();
1360 }
1361
1362 *ret = TAKE_PTR(l);
1363 return 0;
1364 }
1365
1366 static int format_protocol_status(DNSConfiguration *configuration, char ***ret) {
1367 _cleanup_strv_free_ char **s = NULL;
1368 int r;
1369
1370 assert(configuration);
1371 assert(ret);
1372
1373 if (configuration->ifindex > 0) {
1374 r = strv_extendf(&s, "%sDefaultRoute", plus_minus(configuration->default_route));
1375 if (r < 0)
1376 return r;
1377 }
1378
1379 r = strv_extend_extended_bool(&s, "LLMNR", configuration->llmnr_mode_str);
1380 if (r < 0)
1381 return r;
1382
1383 r = strv_extend_extended_bool(&s, "mDNS", configuration->mdns_mode_str);
1384 if (r < 0)
1385 return r;
1386
1387 r = strv_extend_extended_bool(&s, "DNSOverTLS", configuration->dns_over_tls_mode_str);
1388 if (r < 0)
1389 return r;
1390
1391 r = strv_extendf(&s, "DNSSEC=%s/%s",
1392 configuration->dnssec_mode_str ?: "???",
1393 configuration->dnssec_supported ? "supported" : "unsupported");
1394 if (r < 0)
1395 return r;
1396
1397 *ret = TAKE_PTR(s);
1398 return 0;
1399 }
1400
1401 static int format_scopes_string(DNSConfiguration *configuration, char **ret) {
1402 assert(configuration);
1403 assert(ret);
1404
1405 if (!configuration->dns_scopes) {
1406 *ret = NULL;
1407 return 0;
1408 }
1409
1410 uint64_t scopes_mask = 0;
1411 DNSScope *scope;
1412 SET_FOREACH(scope, configuration->dns_scopes) {
1413 if (streq(scope->protocol, "dns"))
1414 scopes_mask |= SD_RESOLVED_DNS;
1415 else if (streq(scope->protocol, "llmnr"))
1416 scopes_mask |= scope->family == AF_INET ?
1417 SD_RESOLVED_LLMNR_IPV4 :
1418 SD_RESOLVED_LLMNR_IPV6;
1419 else if (streq(scope->protocol, "mdns"))
1420 scopes_mask |= scope->family == AF_INET ?
1421 SD_RESOLVED_MDNS_IPV4 :
1422 SD_RESOLVED_MDNS_IPV6;
1423 }
1424
1425 _cleanup_free_ char *buf = NULL;
1426 if (asprintf(&buf, "%s%s%s%s%s",
1427 scopes_mask & SD_RESOLVED_DNS ? "DNS " : "",
1428 scopes_mask & SD_RESOLVED_LLMNR_IPV4 ? "LLMNR/IPv4 " : "",
1429 scopes_mask & SD_RESOLVED_LLMNR_IPV6 ? "LLMNR/IPv6 " : "",
1430 scopes_mask & SD_RESOLVED_MDNS_IPV4 ? "mDNS/IPv4 " : "",
1431 scopes_mask & SD_RESOLVED_MDNS_IPV6 ? "mDNS/IPv6 " : "") < 0)
1432 return log_oom();
1433
1434 size_t len = strlen(buf);
1435 assert(len > 0);
1436 buf[len - 1] = '\0';
1437
1438 *ret = TAKE_PTR(buf);
1439 return 0;
1440 }
1441
1442 static void status_print_header(DNSConfiguration *c) {
1443 assert(c);
1444
1445 if (c->ifname)
1446 printf("%sLink %i (%s)%s\n",
1447 ansi_highlight(),
1448 c->ifindex,
1449 c->ifname,
1450 ansi_normal());
1451 else if (c->delegate)
1452 printf("%sDelegate %s%s\n",
1453 ansi_highlight(),
1454 c->delegate,
1455 ansi_normal());
1456 else
1457 printf("%sGlobal%s\n", ansi_highlight(), ansi_normal());
1458 }
1459
1460 static void status_print_string(DNSConfiguration *c, const char *p) {
1461 assert(c);
1462
1463 if (c->ifname)
1464 printf("%sLink %i (%s)%s: %s\n",
1465 ansi_highlight(),
1466 c->ifindex,
1467 c->ifname,
1468 ansi_normal(),
1469 p);
1470 else if (c->delegate)
1471 printf("%sDelegate %s%s: %s\n",
1472 ansi_highlight(),
1473 c->delegate,
1474 ansi_normal(),
1475 p);
1476 else
1477 printf("%sGlobal%s: %s\n", ansi_highlight(), ansi_normal(), p);
1478 }
1479
1480 static int status_print_strv(DNSConfiguration *c, char **p) {
1481 const unsigned indent = strlen("Global: "); /* Use the same indentation everywhere to make things nice */
1482 int pos1, pos2;
1483
1484 assert(c);
1485
1486 if (c->ifname)
1487 printf("%s%nLink %i (%s)%n%s:", ansi_highlight(), &pos1, c->ifindex, c->ifname, &pos2, ansi_normal());
1488 else if (c->delegate)
1489 printf("%s%nDelegate %s%n%s:", ansi_highlight(), &pos1, c->delegate, &pos2, ansi_normal());
1490 else
1491 printf("%s%nGlobal%n%s:", ansi_highlight(), &pos1, &pos2, ansi_normal());
1492
1493 size_t cols = columns(), position = pos2 - pos1 + 2;
1494
1495 STRV_FOREACH(i, p) {
1496 size_t our_len = utf8_console_width(*i); /* This returns -1 on invalid utf-8 (which shouldn't happen).
1497 * If that happens, we'll just print one item per line. */
1498
1499 if (position <= indent || size_add(size_add(position, 1), our_len) < cols) {
1500 printf(" %s", *i);
1501 position = size_add(size_add(position, 1), our_len);
1502 } else {
1503 printf("\n%*s%s", (int) indent, "", *i);
1504 position = size_add(our_len, indent);
1505 }
1506 }
1507
1508 printf("\n");
1509
1510 return 0;
1511 }
1512
1513 static int dump_list(Table *table, const char *field, char * const *l) {
1514 int r;
1515
1516 if (strv_isempty(l))
1517 return 0;
1518
1519 r = table_add_many(table,
1520 TABLE_FIELD, field,
1521 TABLE_STRV_WRAPPED, l);
1522 if (r < 0)
1523 return table_log_add_error(r);
1524
1525 return 0;
1526 }
1527
1528 static int print_configuration(DNSConfiguration *configuration, StatusMode mode, bool *empty_line) {
1529 _cleanup_(table_unrefp) Table *table = NULL;
1530 int r;
1531
1532 assert(configuration);
1533
1534 pager_open(arg_pager_flags);
1535
1536 bool global = !(configuration->ifindex > 0 || configuration->delegate);
1537 if (mode == STATUS_DNS) {
1538 _cleanup_strv_free_ char **l = NULL;
1539 r = format_dns_servers(configuration, configuration->dns_servers, &l);
1540 if (r < 0)
1541 return r;
1542
1543 return status_print_strv(configuration, l);
1544
1545 } else if (mode == STATUS_DOMAIN) {
1546 _cleanup_strv_free_ char **l = NULL;
1547 r = format_search_domains(configuration, configuration->search_domains, &l);
1548 if (r < 0)
1549 return r;
1550
1551 return status_print_strv(configuration, l);
1552
1553 } else if (mode == STATUS_NTA) {
1554 if (configuration->delegate)
1555 return 0;
1556
1557 return status_print_strv(configuration, configuration->negative_trust_anchors);
1558
1559 } else if (mode == STATUS_DEFAULT_ROUTE) {
1560 if (global)
1561 return 0;
1562
1563 status_print_string(configuration, yes_no(configuration->default_route));
1564
1565 return 0;
1566
1567 } else if (IN_SET(mode, STATUS_LLMNR, STATUS_MDNS, STATUS_DNS_OVER_TLS, STATUS_DNSSEC)) {
1568 if (configuration->delegate)
1569 return 0;
1570
1571 status_print_string(configuration,
1572 strna(mode == STATUS_LLMNR ? configuration->llmnr_mode_str :
1573 mode == STATUS_MDNS ? configuration->mdns_mode_str :
1574 mode == STATUS_DNS_OVER_TLS ? configuration->dns_over_tls_mode_str :
1575 configuration->dnssec_mode_str));
1576
1577 return 0;
1578
1579 } else if (mode != STATUS_ALL)
1580 return 0;
1581
1582 if (empty_line && *empty_line)
1583 fputc('\n', stdout);
1584
1585 status_print_header(configuration);
1586
1587 table = table_new_vertical();
1588 if (!table)
1589 return log_oom();
1590
1591 if (configuration->ifindex > 0) {
1592 r = table_add_many(table,
1593 TABLE_FIELD, "Current Scopes",
1594 TABLE_SET_MINIMUM_WIDTH, 19);
1595 if (r < 0)
1596 return table_log_add_error(r);
1597
1598 _cleanup_free_ char *s = NULL;
1599 r = format_scopes_string(configuration, &s);
1600 if (r < 0)
1601 return r;
1602
1603 r = table_add_cell(table, NULL, TABLE_STRING, s ?: "none");
1604 if (r < 0)
1605 return table_log_add_error(r);
1606 }
1607
1608 if (!configuration->delegate) {
1609 _cleanup_strv_free_ char **l = NULL;
1610 r = format_protocol_status(configuration, &l);
1611 if (r < 0)
1612 return r;
1613
1614 r = table_add_many(table,
1615 TABLE_FIELD, "Protocols",
1616 TABLE_STRV_WRAPPED, l);
1617 if (r < 0)
1618 return table_log_add_error(r);
1619 }
1620
1621 if (configuration->resolv_conf_mode_str) {
1622 r = table_add_many(table,
1623 TABLE_FIELD, "resolv.conf mode",
1624 TABLE_STRING, configuration->resolv_conf_mode_str);
1625 if (r < 0)
1626 return table_log_add_error(r);
1627 }
1628
1629 if (configuration->current_dns_server) {
1630 _cleanup_free_ char *s = NULL;
1631 r = format_dns_server_one(configuration, configuration->current_dns_server, &s);
1632 if (r < 0)
1633 return r;
1634
1635 r = table_add_many(table,
1636 TABLE_FIELD, "Current DNS Server",
1637 TABLE_STRING, s);
1638 if (r < 0)
1639 return table_log_add_error(r);
1640 }
1641
1642 _cleanup_strv_free_ char **dns_servers = NULL;
1643 r = format_dns_servers(configuration, configuration->dns_servers, &dns_servers);
1644 if (r < 0)
1645 return r;
1646
1647 r = dump_list(table, "DNS Servers", dns_servers);
1648 if (r < 0)
1649 return r;
1650
1651 if (global) {
1652 _cleanup_strv_free_ char **l = NULL;
1653 r = format_dns_servers(configuration, configuration->fallback_dns_servers, &l);
1654 if (r < 0)
1655 return r;
1656
1657 r = dump_list(table, "Fallback DNS Servers", l);
1658 if (r < 0)
1659 return r;
1660 }
1661
1662 _cleanup_strv_free_ char **search_domains = NULL;
1663 r = format_search_domains(configuration, configuration->search_domains, &search_domains);
1664 if (r < 0)
1665 return r;
1666
1667 r = dump_list(table, "DNS Domain", search_domains);
1668 if (r < 0)
1669 return r;
1670
1671 if (!global) {
1672 r = table_add_many(table,
1673 TABLE_FIELD, "Default Route",
1674 TABLE_BOOLEAN, configuration->default_route);
1675 if (r < 0)
1676 return table_log_add_error(r);
1677 }
1678
1679 r = table_print_or_warn(table);
1680 if (r < 0)
1681 return r;
1682
1683 if (empty_line)
1684 *empty_line = true;
1685
1686 return 0;
1687 }
1688
1689 static int status_full(StatusMode mode, char **links) {
1690 bool empty_line = false;
1691 int r;
1692
1693 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
1694 r = varlink_dump_dns_configuration(&v);
1695 if (r < 0)
1696 return r;
1697
1698 r = status_json_filter_links(&v, links);
1699 if (r < 0)
1700 return log_error_errno(r, "Failed to filter configuration JSON links: %m");
1701
1702 if (sd_json_format_enabled(arg_json_format_flags)) {
1703 r = status_json_filter_fields(&v, mode);
1704 if (r < 0)
1705 return log_error_errno(r, "Failed to filter configuration JSON fields: %m");
1706
1707 return sd_json_variant_dump(v, arg_json_format_flags, /* f= */ NULL, /* prefix= */ NULL);
1708 }
1709
1710 _cleanup_(dns_configuration_freep) DNSConfiguration *global_config = NULL;
1711 _cleanup_ordered_set_free_ OrderedSet *link_configs = NULL, *delegate_configs = NULL;
1712 sd_json_variant *w;
1713 JSON_VARIANT_ARRAY_FOREACH(w, v) {
1714 _cleanup_(dns_configuration_freep) DNSConfiguration *c = NULL;
1715 r = dns_configuration_from_json(w, &c);
1716 if (r < 0)
1717 return r;
1718
1719 if (c->ifindex > 0) {
1720 r = ordered_set_ensure_put(&link_configs, &dns_configuration_hash_ops, c);
1721 if (r < 0)
1722 return r;
1723 TAKE_PTR(c);
1724 } else if (c->delegate) {
1725 r = ordered_set_ensure_put(&delegate_configs, &dns_configuration_hash_ops, c);
1726 if (r < 0)
1727 return r;
1728 TAKE_PTR(c);
1729 } else {
1730 assert(!global_config);
1731 global_config = TAKE_PTR(c);
1732 }
1733 }
1734
1735 if (global_config) {
1736 r = print_configuration(global_config, mode, &empty_line);
1737 if (r < 0)
1738 return r;
1739 }
1740
1741 DNSConfiguration *c;
1742 ORDERED_SET_FOREACH(c, link_configs) {
1743 r = print_configuration(c, mode, &empty_line);
1744 if (r < 0)
1745 return r;
1746 }
1747
1748 ORDERED_SET_FOREACH(c, delegate_configs) {
1749 r = print_configuration(c, mode, &empty_line);
1750 if (r < 0)
1751 return r;
1752 }
1753
1754 return 0;
1755 }
1756
1757 static int status_all(StatusMode mode) {
1758 return status_full(mode, /* links= */ NULL);
1759 }
1760
1761 static int status_ifindex(int ifindex, StatusMode mode) {
1762 int r;
1763 char ifname[IF_NAMESIZE];
1764
1765 assert(ifindex > 0);
1766
1767 r = format_ifname(ifindex, ifname);
1768 if (r < 0)
1769 return log_error_errno(r, "Failed to resolve interface name for %i: %m", ifindex);
1770
1771 return status_full(mode, STRV_MAKE(ifname));
1772 }
1773
1774 VERB(verb_status, "status", "[LINK…]", VERB_ANY, VERB_ANY, VERB_DEFAULT,
1775 "Show link and server status");
1776 static int verb_status(int argc, char *argv[], uintptr_t _data, void *userdata) {
1777 return status_full(STATUS_ALL, strv_skip(argv, 1));
1778 }
1779
1780 VERB(verb_show_statistics, "statistics", NULL, VERB_ANY, 1, 0,
1781 "Show resolver statistics");
1782 static int verb_show_statistics(int argc, char *argv[], uintptr_t _data, void *userdata) {
1783 _cleanup_(table_unrefp) Table *table = NULL;
1784 sd_json_variant *reply = NULL;
1785 _cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
1786 int r;
1787
1788 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
1789
1790 r = sd_varlink_connect_address(&vl, "/run/systemd/resolve/io.systemd.Resolve.Monitor");
1791 if (r < 0)
1792 return log_error_errno(r, "Failed to connect to query monitoring service /run/systemd/resolve/io.systemd.Resolve.Monitor: %m");
1793
1794 r = varlink_callbo_and_log(
1795 vl,
1796 "io.systemd.Resolve.Monitor.DumpStatistics",
1797 &reply,
1798 SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", arg_ask_password));
1799 if (r < 0)
1800 return r;
1801
1802 if (sd_json_format_enabled(arg_json_format_flags))
1803 return sd_json_variant_dump(reply, arg_json_format_flags, NULL, NULL);
1804
1805 struct statistics {
1806 sd_json_variant *transactions;
1807 sd_json_variant *cache;
1808 sd_json_variant *dnssec;
1809 } statistics;
1810
1811 static const sd_json_dispatch_field statistics_dispatch_table[] = {
1812 { "transactions", SD_JSON_VARIANT_OBJECT, sd_json_dispatch_variant_noref, offsetof(struct statistics, transactions), SD_JSON_MANDATORY },
1813 { "cache", SD_JSON_VARIANT_OBJECT, sd_json_dispatch_variant_noref, offsetof(struct statistics, cache), SD_JSON_MANDATORY },
1814 { "dnssec", SD_JSON_VARIANT_OBJECT, sd_json_dispatch_variant_noref, offsetof(struct statistics, dnssec), SD_JSON_MANDATORY },
1815 {},
1816 };
1817
1818 r = sd_json_dispatch(reply, statistics_dispatch_table, SD_JSON_LOG, &statistics);
1819 if (r < 0)
1820 return r;
1821
1822 struct transactions {
1823 uint64_t n_current_transactions;
1824 uint64_t n_transactions_total;
1825 uint64_t n_timeouts_total;
1826 uint64_t n_timeouts_served_stale_total;
1827 uint64_t n_failure_responses_total;
1828 uint64_t n_failure_responses_served_stale_total;
1829 } transactions;
1830
1831 static const sd_json_dispatch_field transactions_dispatch_table[] = {
1832 { "currentTransactions", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct transactions, n_current_transactions), SD_JSON_MANDATORY },
1833 { "totalTransactions", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct transactions, n_transactions_total), SD_JSON_MANDATORY },
1834 { "totalTimeouts", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct transactions, n_timeouts_total), SD_JSON_MANDATORY },
1835 { "totalTimeoutsServedStale", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct transactions, n_timeouts_served_stale_total), SD_JSON_MANDATORY },
1836 { "totalFailedResponses", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct transactions, n_failure_responses_total), SD_JSON_MANDATORY },
1837 { "totalFailedResponsesServedStale", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct transactions, n_failure_responses_served_stale_total), SD_JSON_MANDATORY },
1838 {},
1839 };
1840
1841 r = sd_json_dispatch(statistics.transactions, transactions_dispatch_table, SD_JSON_LOG, &transactions);
1842 if (r < 0)
1843 return r;
1844
1845 struct cache {
1846 uint64_t cache_size;
1847 uint64_t n_cache_hit;
1848 uint64_t n_cache_miss;
1849 } cache;
1850
1851 static const sd_json_dispatch_field cache_dispatch_table[] = {
1852 { "size", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct cache, cache_size), SD_JSON_MANDATORY },
1853 { "hits", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct cache, n_cache_hit), SD_JSON_MANDATORY },
1854 { "misses", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct cache, n_cache_miss), SD_JSON_MANDATORY },
1855 {},
1856 };
1857
1858 r = sd_json_dispatch(statistics.cache, cache_dispatch_table, SD_JSON_LOG, &cache);
1859 if (r < 0)
1860 return r;
1861
1862 struct dnsssec {
1863 uint64_t n_dnssec_secure;
1864 uint64_t n_dnssec_insecure;
1865 uint64_t n_dnssec_bogus;
1866 uint64_t n_dnssec_indeterminate;
1867 } dnsssec;
1868
1869 static const sd_json_dispatch_field dnssec_dispatch_table[] = {
1870 { "secure", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct dnsssec, n_dnssec_secure), SD_JSON_MANDATORY },
1871 { "insecure", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct dnsssec, n_dnssec_insecure), SD_JSON_MANDATORY },
1872 { "bogus", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct dnsssec, n_dnssec_bogus), SD_JSON_MANDATORY },
1873 { "indeterminate", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct dnsssec, n_dnssec_indeterminate), SD_JSON_MANDATORY },
1874 {},
1875 };
1876
1877 r = sd_json_dispatch(statistics.dnssec, dnssec_dispatch_table, SD_JSON_LOG, &dnsssec);
1878 if (r < 0)
1879 return r;
1880
1881 table = table_new_vertical();
1882 if (!table)
1883 return log_oom();
1884
1885 r = table_add_many(table,
1886 TABLE_STRING, "Transactions",
1887 TABLE_SET_COLOR, ansi_highlight(),
1888 TABLE_SET_ALIGN_PERCENT, 0,
1889 TABLE_EMPTY,
1890 TABLE_FIELD, "Current Transactions",
1891 TABLE_SET_ALIGN_PERCENT, 100,
1892 TABLE_UINT64, transactions.n_current_transactions,
1893 TABLE_SET_ALIGN_PERCENT, 100,
1894 TABLE_FIELD, "Total Transactions",
1895 TABLE_UINT64, transactions.n_transactions_total,
1896 TABLE_EMPTY, TABLE_EMPTY,
1897 TABLE_STRING, "Cache",
1898 TABLE_SET_COLOR, ansi_highlight(),
1899 TABLE_SET_ALIGN_PERCENT, 0,
1900 TABLE_EMPTY,
1901 TABLE_FIELD, "Current Cache Size",
1902 TABLE_SET_ALIGN_PERCENT, 100,
1903 TABLE_UINT64, cache.cache_size,
1904 TABLE_FIELD, "Cache Hits",
1905 TABLE_UINT64, cache.n_cache_hit,
1906 TABLE_FIELD, "Cache Misses",
1907 TABLE_UINT64, cache.n_cache_miss,
1908 TABLE_EMPTY, TABLE_EMPTY,
1909 TABLE_STRING, "Failure Transactions",
1910 TABLE_SET_COLOR, ansi_highlight(),
1911 TABLE_SET_ALIGN_PERCENT, 0,
1912 TABLE_EMPTY,
1913 TABLE_FIELD, "Total Timeouts",
1914 TABLE_SET_ALIGN_PERCENT, 100,
1915 TABLE_UINT64, transactions.n_timeouts_total,
1916 TABLE_FIELD, "Total Timeouts (Stale Data Served)",
1917 TABLE_UINT64, transactions.n_timeouts_served_stale_total,
1918 TABLE_FIELD, "Total Failure Responses",
1919 TABLE_UINT64, transactions.n_failure_responses_total,
1920 TABLE_FIELD, "Total Failure Responses (Stale Data Served)",
1921 TABLE_UINT64, transactions.n_failure_responses_served_stale_total,
1922 TABLE_EMPTY, TABLE_EMPTY,
1923 TABLE_STRING, "DNSSEC Verdicts",
1924 TABLE_SET_COLOR, ansi_highlight(),
1925 TABLE_SET_ALIGN_PERCENT, 0,
1926 TABLE_EMPTY,
1927 TABLE_FIELD, "Secure",
1928 TABLE_SET_ALIGN_PERCENT, 100,
1929 TABLE_UINT64, dnsssec.n_dnssec_secure,
1930 TABLE_FIELD, "Insecure",
1931 TABLE_UINT64, dnsssec.n_dnssec_insecure,
1932 TABLE_FIELD, "Bogus",
1933 TABLE_UINT64, dnsssec.n_dnssec_bogus,
1934 TABLE_FIELD, "Indeterminate",
1935 TABLE_UINT64, dnsssec.n_dnssec_indeterminate
1936 );
1937 if (r < 0)
1938 return table_log_add_error(r);
1939
1940 return table_print_or_warn(table);
1941 }
1942
1943 VERB(verb_reset_statistics, "reset-statistics", NULL, VERB_ANY, 1, 0,
1944 "Reset resolver statistics");
1945 static int verb_reset_statistics(int argc, char *argv[], uintptr_t _data, void *userdata) {
1946 sd_json_variant *reply = NULL;
1947 _cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
1948 int r;
1949
1950 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
1951
1952 r = sd_varlink_connect_address(&vl, "/run/systemd/resolve/io.systemd.Resolve.Monitor");
1953 if (r < 0)
1954 return log_error_errno(r, "Failed to connect to query monitoring service /run/systemd/resolve/io.systemd.Resolve.Monitor: %m");
1955
1956 r = varlink_callbo_and_log(
1957 vl,
1958 "io.systemd.Resolve.Monitor.ResetStatistics",
1959 &reply,
1960 SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", arg_ask_password));
1961 if (r < 0)
1962 return r;
1963
1964 if (sd_json_format_enabled(arg_json_format_flags))
1965 return sd_json_variant_dump(reply, arg_json_format_flags, NULL, NULL);
1966
1967 return 0;
1968 }
1969
1970 VERB(verb_flush_caches, "flush-caches", NULL, VERB_ANY, 1, 0,
1971 "Flush all local DNS caches");
1972 static int verb_flush_caches(int argc, char *argv[], uintptr_t _data, void *userdata) {
1973 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1974 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1975 int r;
1976
1977 r = acquire_bus(&bus);
1978 if (r < 0)
1979 return r;
1980
1981 r = bus_call_method(bus, bus_resolve_mgr, "FlushCaches", &error, NULL, NULL);
1982 if (r < 0)
1983 return log_error_errno(r, "Failed to flush caches: %s", bus_error_message(&error, r));
1984
1985 return 0;
1986 }
1987
1988 VERB(verb_reset_server_features, "reset-server-features", NULL, VERB_ANY, 1, 0,
1989 "Forget learnt DNS server feature levels");
1990 static int verb_reset_server_features(int argc, char *argv[], uintptr_t _data, void *userdata) {
1991 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1992 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1993 int r;
1994
1995 r = acquire_bus(&bus);
1996 if (r < 0)
1997 return r;
1998
1999 r = bus_call_method(bus, bus_resolve_mgr, "ResetServerFeatures", &error, NULL, NULL);
2000 if (r < 0)
2001 return log_error_errno(r, "Failed to reset server features: %s", bus_error_message(&error, r));
2002
2003 return 0;
2004 }
2005
2006 static int print_question(char prefix, const char *color, sd_json_variant *question) {
2007 sd_json_variant *q = NULL;
2008 int r;
2009
2010 assert(color);
2011
2012 JSON_VARIANT_ARRAY_FOREACH(q, question) {
2013 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
2014 char buf[DNS_RESOURCE_KEY_STRING_MAX];
2015
2016 r = dns_resource_key_from_json(q, &key);
2017 if (r < 0) {
2018 log_warning_errno(r, "Received monitor message with invalid question key, ignoring: %m");
2019 continue;
2020 }
2021
2022 printf("%s%s %c%s: %s\n",
2023 color,
2024 glyph(GLYPH_ARROW_RIGHT),
2025 prefix,
2026 ansi_normal(),
2027 dns_resource_key_to_string(key, buf, sizeof(buf)));
2028 }
2029
2030 return 0;
2031 }
2032
2033 static int print_answer(sd_json_variant *answer) {
2034 sd_json_variant *a;
2035 int r;
2036
2037 JSON_VARIANT_ARRAY_FOREACH(a, answer) {
2038 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
2039 _cleanup_free_ void *d = NULL;
2040 sd_json_variant *jraw;
2041 const char *s;
2042 size_t l;
2043
2044 jraw = sd_json_variant_by_key(a, "raw");
2045 if (!jraw) {
2046 log_warning("Received monitor answer lacking valid raw data, ignoring.");
2047 continue;
2048 }
2049
2050 r = sd_json_variant_unbase64(jraw, &d, &l);
2051 if (r < 0) {
2052 log_warning_errno(r, "Failed to undo base64 encoding of monitor answer raw data, ignoring.");
2053 continue;
2054 }
2055
2056 r = dns_resource_record_new_from_raw(&rr, d, l);
2057 if (r < 0) {
2058 log_warning_errno(r, "Failed to parse monitor answer RR, ignoring: %m");
2059 continue;
2060 }
2061
2062 s = dns_resource_record_to_string(rr);
2063 if (!s)
2064 return log_oom();
2065
2066 printf("%s%s A%s: %s\n",
2067 ansi_highlight_yellow(),
2068 glyph(GLYPH_ARROW_LEFT),
2069 ansi_normal(),
2070 s);
2071 }
2072
2073 return 0;
2074 }
2075
2076 typedef struct MonitorQueryParams {
2077 sd_json_variant *question;
2078 sd_json_variant *answer;
2079 sd_json_variant *collected_questions;
2080 int rcode;
2081 int error;
2082 int ede_code;
2083 const char *state;
2084 const char *result;
2085 const char *ede_msg;
2086 } MonitorQueryParams;
2087
2088 static void monitor_query_params_done(MonitorQueryParams *p) {
2089 assert(p);
2090
2091 sd_json_variant_unref(p->question);
2092 sd_json_variant_unref(p->answer);
2093 sd_json_variant_unref(p->collected_questions);
2094 }
2095
2096 static void monitor_query_dump(sd_json_variant *v) {
2097 static const sd_json_dispatch_field dispatch_table[] = {
2098 { "question", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(MonitorQueryParams, question), SD_JSON_MANDATORY },
2099 { "answer", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(MonitorQueryParams, answer), 0 },
2100 { "collectedQuestions", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(MonitorQueryParams, collected_questions), 0 },
2101 { "state", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MonitorQueryParams, state), SD_JSON_MANDATORY },
2102 { "result", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MonitorQueryParams, result), 0 },
2103 { "rcode", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(MonitorQueryParams, rcode), 0 },
2104 { "errno", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(MonitorQueryParams, error), 0 },
2105 { "extendedDNSErrorCode", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(MonitorQueryParams, ede_code), 0 },
2106 { "extendedDNSErrorMessage", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MonitorQueryParams, ede_msg), 0 },
2107 {}
2108 };
2109
2110 _cleanup_(monitor_query_params_done) MonitorQueryParams p = {
2111 .rcode = -1,
2112 .ede_code = -1,
2113 };
2114
2115 assert(v);
2116
2117 if (sd_json_dispatch(v, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &p) < 0)
2118 return;
2119
2120 /* First show the current question */
2121 print_question('Q', ansi_highlight_cyan(), p.question);
2122
2123 /* And then show the questions that led to this one in case this was a CNAME chain */
2124 print_question('C', ansi_highlight_grey(), p.collected_questions);
2125
2126 printf("%s%s S%s: %s",
2127 streq_ptr(p.state, "success") ? ansi_highlight_green() : ansi_highlight_red(),
2128 glyph(GLYPH_ARROW_LEFT),
2129 ansi_normal(),
2130 streq_ptr(p.state, "errno") ? ERRNO_NAME(p.error) :
2131 streq_ptr(p.state, "rcode-failure") ? strna(dns_rcode_to_string(p.rcode)) :
2132 strna(p.state));
2133
2134 if (!isempty(p.result))
2135 printf(": %s", p.result);
2136
2137 if (p.ede_code >= 0)
2138 printf(" (%s%s%s)",
2139 FORMAT_DNS_EDE_RCODE(p.ede_code),
2140 !isempty(p.ede_msg) ? ": " : "",
2141 strempty(p.ede_msg));
2142
2143 puts("");
2144
2145 print_answer(p.answer);
2146 }
2147
2148 static int monitor_reply(
2149 sd_varlink *link,
2150 sd_json_variant *parameters,
2151 const char *error_id,
2152 sd_varlink_reply_flags_t flags,
2153 void *userdata) {
2154
2155 assert(link);
2156
2157 if (error_id) {
2158 bool disconnect;
2159
2160 disconnect = streq(error_id, SD_VARLINK_ERROR_DISCONNECTED);
2161 if (disconnect)
2162 log_info("Disconnected.");
2163 else
2164 log_error("Varlink error: %s", error_id);
2165
2166 (void) sd_event_exit(ASSERT_PTR(sd_varlink_get_event(link)), disconnect ? EXIT_SUCCESS : EXIT_FAILURE);
2167 return 0;
2168 }
2169
2170 if (sd_json_variant_by_key(parameters, "ready")) {
2171 /* The first message coming in will just indicate that we are now subscribed. We let our
2172 * caller know if they asked for it. Once the caller sees this they should know that we are
2173 * not going to miss any queries anymore. */
2174 (void) sd_notify(/* unset_environment=false */ false, "READY=1");
2175 return 0;
2176 }
2177
2178 if (!sd_json_format_enabled(arg_json_format_flags)) {
2179 monitor_query_dump(parameters);
2180 printf("\n");
2181 } else
2182 sd_json_variant_dump(parameters, arg_json_format_flags, NULL, NULL);
2183
2184 fflush(stdout);
2185
2186 return 0;
2187 }
2188
2189 VERB(verb_monitor, "monitor", NULL, VERB_ANY, 1, 0,
2190 "Monitor DNS queries");
2191 static int verb_monitor(int argc, char *argv[], uintptr_t _data, void *userdata) {
2192 _cleanup_(sd_event_unrefp) sd_event *event = NULL;
2193 _cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
2194 int r, c;
2195
2196 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
2197
2198 r = sd_event_default(&event);
2199 if (r < 0)
2200 return log_error_errno(r, "Failed to get event loop: %m");
2201
2202 r = sd_event_set_signal_exit(event, true);
2203 if (r < 0)
2204 return log_error_errno(r, "Failed to enable exit on SIGINT/SIGTERM: %m");
2205
2206 r = sd_varlink_connect_address(&vl, "/run/systemd/resolve/io.systemd.Resolve.Monitor");
2207 if (r < 0)
2208 return log_error_errno(r, "Failed to connect to query monitoring service /run/systemd/resolve/io.systemd.Resolve.Monitor: %m");
2209
2210 r = sd_varlink_set_relative_timeout(vl, USEC_INFINITY); /* We want the monitor to run basically forever */
2211 if (r < 0)
2212 return log_error_errno(r, "Failed to set varlink timeout: %m");
2213
2214 r = sd_varlink_attach_event(vl, event, SD_EVENT_PRIORITY_NORMAL);
2215 if (r < 0)
2216 return log_error_errno(r, "Failed to attach varlink connection to event loop: %m");
2217
2218 r = sd_varlink_bind_reply(vl, monitor_reply);
2219 if (r < 0)
2220 return log_error_errno(r, "Failed to bind reply callback to varlink connection: %m");
2221
2222 r = sd_varlink_observebo(
2223 vl,
2224 "io.systemd.Resolve.Monitor.SubscribeQueryResults",
2225 SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", arg_ask_password));
2226 if (r < 0)
2227 return log_error_errno(r, "Failed to issue SubscribeQueryResults() varlink call: %m");
2228
2229 r = sd_event_loop(event);
2230 if (r < 0)
2231 return log_error_errno(r, "Failed to run event loop: %m");
2232
2233 r = sd_event_get_exit_code(event, &c);
2234 if (r < 0)
2235 return log_error_errno(r, "Failed to get exit code: %m");
2236
2237 return c;
2238 }
2239
2240 static int call_dns(sd_bus *bus, char **dns, const BusLocator *locator, sd_bus_error *error, bool extended) {
2241 _cleanup_(sd_bus_message_unrefp) sd_bus_message *req = NULL;
2242 int r;
2243
2244 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
2245
2246 r = bus_message_new_method_call(bus, &req, locator, extended ? "SetLinkDNSEx" : "SetLinkDNS");
2247 if (r < 0)
2248 return bus_log_create_error(r);
2249
2250 r = sd_bus_message_append(req, "i", arg_ifindex);
2251 if (r < 0)
2252 return bus_log_create_error(r);
2253
2254 r = sd_bus_message_open_container(req, 'a', extended ? "(iayqs)" : "(iay)");
2255 if (r < 0)
2256 return bus_log_create_error(r);
2257
2258 /* If only argument is the empty string, then call SetLinkDNS() with an
2259 * empty list, which will clear the list of domains for an interface. */
2260 if (!strv_equal(dns, STRV_MAKE("")))
2261 STRV_FOREACH(p, dns) {
2262 _cleanup_free_ char *name = NULL;
2263 struct in_addr_data data;
2264 uint16_t port;
2265 int ifindex;
2266
2267 r = in_addr_port_ifindex_name_from_string_auto(*p, &data.family, &data.address, &port, &ifindex, &name);
2268 if (r < 0)
2269 return log_error_errno(r, "Failed to parse DNS server address: %s", *p);
2270
2271 if (ifindex != 0 && ifindex != arg_ifindex)
2272 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid ifindex: %i", ifindex);
2273
2274 r = sd_bus_message_open_container(req, 'r', extended ? "iayqs" : "iay");
2275 if (r < 0)
2276 return bus_log_create_error(r);
2277
2278 r = sd_bus_message_append(req, "i", data.family);
2279 if (r < 0)
2280 return bus_log_create_error(r);
2281
2282 r = sd_bus_message_append_array(req, 'y', &data.address, FAMILY_ADDRESS_SIZE(data.family));
2283 if (r < 0)
2284 return bus_log_create_error(r);
2285
2286 if (extended) {
2287 r = sd_bus_message_append(req, "q", port);
2288 if (r < 0)
2289 return bus_log_create_error(r);
2290
2291 r = sd_bus_message_append(req, "s", name);
2292 if (r < 0)
2293 return bus_log_create_error(r);
2294 }
2295
2296 r = sd_bus_message_close_container(req);
2297 if (r < 0)
2298 return bus_log_create_error(r);
2299 }
2300
2301 r = sd_bus_message_close_container(req);
2302 if (r < 0)
2303 return bus_log_create_error(r);
2304
2305 r = sd_bus_call(bus, req, 0, error, NULL);
2306 if (r < 0 && extended && sd_bus_error_has_name(error, SD_BUS_ERROR_UNKNOWN_METHOD)) {
2307 sd_bus_error_free(error);
2308 return call_dns(bus, dns, locator, error, false);
2309 }
2310 return r;
2311 }
2312
2313 static int dump_cache_item(sd_json_variant *item) {
2314
2315 struct item_info {
2316 sd_json_variant *key;
2317 sd_json_variant *rrs;
2318 const char *type;
2319 uint64_t until;
2320 } item_info = {};
2321
2322 static const sd_json_dispatch_field dispatch_table[] = {
2323 { "key", SD_JSON_VARIANT_OBJECT, sd_json_dispatch_variant_noref, offsetof(struct item_info, key), SD_JSON_MANDATORY },
2324 { "rrs", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant_noref, offsetof(struct item_info, rrs), 0 },
2325 { "type", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct item_info, type), 0 },
2326 { "until", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct item_info, until), 0 },
2327 {},
2328 };
2329
2330 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *k = NULL;
2331 int r, c = 0;
2332
2333 r = sd_json_dispatch(item, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &item_info);
2334 if (r < 0)
2335 return r;
2336
2337 r = dns_resource_key_from_json(item_info.key, &k);
2338 if (r < 0)
2339 return log_error_errno(r, "Failed to turn JSON data to resource key: %m");
2340
2341 if (item_info.type)
2342 printf("%s %s%s%s\n", DNS_RESOURCE_KEY_TO_STRING(k), ansi_highlight_red(), item_info.type, ansi_normal());
2343 else {
2344 sd_json_variant *i;
2345
2346 JSON_VARIANT_ARRAY_FOREACH(i, item_info.rrs) {
2347 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
2348 _cleanup_free_ void *data = NULL;
2349 sd_json_variant *raw;
2350 size_t size;
2351
2352 raw = sd_json_variant_by_key(i, "raw");
2353 if (!raw)
2354 return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE), "raw field missing from RR JSON data.");
2355
2356 r = sd_json_variant_unbase64(raw, &data, &size);
2357 if (r < 0)
2358 return log_error_errno(r, "Unable to decode raw RR JSON data: %m");
2359
2360 r = dns_resource_record_new_from_raw(&rr, data, size);
2361 if (r < 0)
2362 return log_error_errno(r, "Failed to parse DNS data: %m");
2363
2364 printf("%s\n", dns_resource_record_to_string(rr));
2365 c++;
2366 }
2367 }
2368
2369 return c;
2370 }
2371
2372 static int dump_cache_scope(sd_json_variant *scope) {
2373 struct scope_info {
2374 const char *protocol;
2375 int family;
2376 int ifindex;
2377 const char *ifname;
2378 sd_json_variant *cache;
2379 const char *dnssec_mode;
2380 const char *dns_over_tls_mode;
2381 } scope_info = {
2382 .family = AF_UNSPEC,
2383 };
2384 sd_json_variant *i;
2385 int r, c = 0;
2386
2387 static const sd_json_dispatch_field dispatch_table[] = {
2388 { "protocol", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct scope_info, protocol), SD_JSON_MANDATORY },
2389 { "family", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(struct scope_info, family), 0 },
2390 { "ifindex", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_ifindex, offsetof(struct scope_info, ifindex), SD_JSON_RELAX },
2391 { "ifname", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct scope_info, ifname), 0 },
2392 { "cache", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant_noref, offsetof(struct scope_info, cache), SD_JSON_MANDATORY },
2393 { "dnssec", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct scope_info, dnssec_mode), 0 },
2394 { "dnsOverTLS", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct scope_info, dns_over_tls_mode), 0 },
2395 {},
2396 };
2397
2398 r = sd_json_dispatch(scope, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &scope_info);
2399 if (r < 0)
2400 return r;
2401
2402 printf("%sScope protocol=%s", ansi_underline(), scope_info.protocol);
2403
2404 if (scope_info.family != AF_UNSPEC)
2405 printf(" family=%s", af_to_name(scope_info.family));
2406
2407 if (scope_info.ifindex > 0)
2408 printf(" ifindex=%i", scope_info.ifindex);
2409 if (scope_info.ifname)
2410 printf(" ifname=%s", scope_info.ifname);
2411
2412 if (dns_protocol_from_string(scope_info.protocol) == DNS_PROTOCOL_DNS) {
2413 if (scope_info.dnssec_mode)
2414 printf(" DNSSEC=%s", scope_info.dnssec_mode);
2415 if (scope_info.dns_over_tls_mode)
2416 printf(" DNSOverTLS=%s", scope_info.dns_over_tls_mode);
2417 }
2418
2419 printf("%s\n", ansi_normal());
2420
2421 JSON_VARIANT_ARRAY_FOREACH(i, scope_info.cache) {
2422 r = dump_cache_item(i);
2423 if (r < 0)
2424 return r;
2425
2426 c += r;
2427 }
2428
2429 if (c == 0)
2430 printf("%sNo entries.%s\n\n", ansi_grey(), ansi_normal());
2431 else
2432 printf("\n");
2433
2434 return 0;
2435 }
2436
2437 VERB(verb_show_cache, "show-cache", NULL, VERB_ANY, 1, 0,
2438 "Show cache contents");
2439 static int verb_show_cache(int argc, char *argv[], uintptr_t _data, void *userdata) {
2440 sd_json_variant *reply = NULL, *d = NULL;
2441 _cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
2442 int r;
2443
2444 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
2445
2446 r = sd_varlink_connect_address(&vl, "/run/systemd/resolve/io.systemd.Resolve.Monitor");
2447 if (r < 0)
2448 return log_error_errno(r, "Failed to connect to query monitoring service /run/systemd/resolve/io.systemd.Resolve.Monitor: %m");
2449
2450 r = varlink_callbo_and_log(
2451 vl,
2452 "io.systemd.Resolve.Monitor.DumpCache",
2453 &reply,
2454 SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", arg_ask_password));
2455 if (r < 0)
2456 return r;
2457
2458 d = sd_json_variant_by_key(reply, "dump");
2459 if (!d)
2460 return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
2461 "DumpCache() response is missing 'dump' key.");
2462
2463 if (!sd_json_variant_is_array(d))
2464 return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
2465 "DumpCache() response 'dump' field not an array");
2466
2467 if (!sd_json_format_enabled(arg_json_format_flags)) {
2468 sd_json_variant *i;
2469
2470 JSON_VARIANT_ARRAY_FOREACH(i, d) {
2471 r = dump_cache_scope(i);
2472 if (r < 0)
2473 return r;
2474 }
2475
2476 return 0;
2477 }
2478
2479 return sd_json_variant_dump(d, arg_json_format_flags, NULL, NULL);
2480 }
2481
2482 static int dump_server_state(sd_json_variant *server) {
2483 _cleanup_(table_unrefp) Table *table = NULL;
2484 TableCell *cell;
2485
2486 struct server_state {
2487 const char *server_name;
2488 const char *type;
2489 const char *ifname;
2490 int ifindex;
2491 const char *verified_feature_level;
2492 const char *possible_feature_level;
2493 const char *dnssec_mode;
2494 bool dnssec_supported;
2495 size_t received_udp_fragment_max;
2496 uint64_t n_failed_udp;
2497 uint64_t n_failed_tcp;
2498 bool packet_truncated;
2499 bool packet_bad_opt;
2500 bool packet_rrsig_missing;
2501 bool packet_invalid;
2502 bool packet_do_off;
2503 } server_state = {
2504 .ifindex = -1,
2505 };
2506
2507 int r;
2508
2509 static const sd_json_dispatch_field dispatch_table[] = {
2510 { "Server", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, server_name), SD_JSON_MANDATORY },
2511 { "Type", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, type), SD_JSON_MANDATORY },
2512 { "Interface", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, ifname), 0 },
2513 { "InterfaceIndex", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_ifindex, offsetof(struct server_state, ifindex), SD_JSON_RELAX },
2514 { "VerifiedFeatureLevel", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, verified_feature_level), 0 },
2515 { "PossibleFeatureLevel", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, possible_feature_level), 0 },
2516 { "DNSSECMode", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, dnssec_mode), SD_JSON_MANDATORY },
2517 { "DNSSECSupported", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, dnssec_supported), SD_JSON_MANDATORY },
2518 { "ReceivedUDPFragmentMax", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct server_state, received_udp_fragment_max), SD_JSON_MANDATORY },
2519 { "FailedUDPAttempts", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct server_state, n_failed_udp), SD_JSON_MANDATORY },
2520 { "FailedTCPAttempts", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct server_state, n_failed_tcp), SD_JSON_MANDATORY },
2521 { "PacketTruncated", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_truncated), SD_JSON_MANDATORY },
2522 { "PacketBadOpt", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_bad_opt), SD_JSON_MANDATORY },
2523 { "PacketRRSIGMissing", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_rrsig_missing), SD_JSON_MANDATORY },
2524 { "PacketInvalid", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_invalid), SD_JSON_MANDATORY },
2525 { "PacketDoOff", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_do_off), SD_JSON_MANDATORY },
2526 {},
2527 };
2528
2529 r = sd_json_dispatch(server, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &server_state);
2530 if (r < 0)
2531 return r;
2532
2533 table = table_new_vertical();
2534 if (!table)
2535 return log_oom();
2536
2537 assert_se(cell = table_get_cell(table, 0, 0));
2538 (void) table_set_ellipsize_percent(table, cell, 100);
2539 (void) table_set_align_percent(table, cell, 0);
2540
2541 r = table_add_cell_stringf(table, NULL, "Server: %s", server_state.server_name);
2542 if (r < 0)
2543 return table_log_add_error(r);
2544
2545 r = table_add_many(table,
2546 TABLE_EMPTY,
2547 TABLE_FIELD, "Type",
2548 TABLE_SET_ALIGN_PERCENT, 100,
2549 TABLE_STRING, server_state.type);
2550 if (r < 0)
2551 return table_log_add_error(r);
2552
2553 if (server_state.ifname) {
2554 r = table_add_many(table,
2555 TABLE_FIELD, "Interface",
2556 TABLE_STRING, server_state.ifname);
2557 if (r < 0)
2558 return table_log_add_error(r);
2559 }
2560
2561 if (server_state.ifindex >= 0) {
2562 r = table_add_many(table,
2563 TABLE_FIELD, "Interface Index",
2564 TABLE_INT, server_state.ifindex);
2565 if (r < 0)
2566 return table_log_add_error(r);
2567 }
2568
2569 if (server_state.verified_feature_level) {
2570 r = table_add_many(table,
2571 TABLE_FIELD, "Verified feature level",
2572 TABLE_STRING, server_state.verified_feature_level);
2573 if (r < 0)
2574 return table_log_add_error(r);
2575 }
2576
2577 if (server_state.possible_feature_level) {
2578 r = table_add_many(table,
2579 TABLE_FIELD, "Possible feature level",
2580 TABLE_STRING, server_state.possible_feature_level);
2581 if (r < 0)
2582 return table_log_add_error(r);
2583 }
2584
2585 r = table_add_many(table,
2586 TABLE_FIELD, "DNSSEC Mode",
2587 TABLE_STRING, server_state.dnssec_mode,
2588 TABLE_FIELD, "DNSSEC Supported",
2589 TABLE_STRING, yes_no(server_state.dnssec_supported),
2590 TABLE_FIELD, "Maximum UDP fragment size received",
2591 TABLE_UINT64, server_state.received_udp_fragment_max,
2592 TABLE_FIELD, "Failed UDP attempts",
2593 TABLE_UINT64, server_state.n_failed_udp,
2594 TABLE_FIELD, "Failed TCP attempts",
2595 TABLE_UINT64, server_state.n_failed_tcp,
2596 TABLE_FIELD, "Seen truncated packet",
2597 TABLE_STRING, yes_no(server_state.packet_truncated),
2598 TABLE_FIELD, "Seen OPT RR getting lost",
2599 TABLE_STRING, yes_no(server_state.packet_bad_opt),
2600 TABLE_FIELD, "Seen RRSIG RR missing",
2601 TABLE_STRING, yes_no(server_state.packet_rrsig_missing),
2602 TABLE_FIELD, "Seen invalid packet",
2603 TABLE_STRING, yes_no(server_state.packet_invalid),
2604 TABLE_FIELD, "Server dropped DO flag",
2605 TABLE_STRING, yes_no(server_state.packet_do_off),
2606 TABLE_SET_ALIGN_PERCENT, 0,
2607 TABLE_EMPTY, TABLE_EMPTY);
2608
2609 if (r < 0)
2610 return table_log_add_error(r);
2611
2612 return table_print_or_warn(table);
2613 }
2614
2615 VERB(verb_show_server_state, "show-server-state", NULL, VERB_ANY, 1, 0,
2616 "Show servers state");
2617 static int verb_show_server_state(int argc, char *argv[], uintptr_t _data, void *userdata) {
2618 sd_json_variant *reply = NULL, *d = NULL;
2619 _cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
2620 int r;
2621
2622 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
2623
2624 r = sd_varlink_connect_address(&vl, "/run/systemd/resolve/io.systemd.Resolve.Monitor");
2625 if (r < 0)
2626 return log_error_errno(r, "Failed to connect to query monitoring service /run/systemd/resolve/io.systemd.Resolve.Monitor: %m");
2627
2628 r = varlink_callbo_and_log(
2629 vl,
2630 "io.systemd.Resolve.Monitor.DumpServerState",
2631 &reply,
2632 SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", arg_ask_password));
2633 if (r < 0)
2634 return r;
2635
2636 d = sd_json_variant_by_key(reply, "dump");
2637 if (!d)
2638 return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
2639 "DumpCache() response is missing 'dump' key.");
2640
2641 if (!sd_json_variant_is_array(d))
2642 return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
2643 "DumpCache() response 'dump' field not an array");
2644
2645 if (!sd_json_format_enabled(arg_json_format_flags)) {
2646 sd_json_variant *i;
2647
2648 JSON_VARIANT_ARRAY_FOREACH(i, d) {
2649 r = dump_server_state(i);
2650 if (r < 0)
2651 return r;
2652 }
2653
2654 return 0;
2655 }
2656
2657 return sd_json_variant_dump(d, arg_json_format_flags, NULL, NULL);
2658 }
2659
2660 VERB(verb_dns, "dns", "[LINK [SERVER…]]", VERB_ANY, VERB_ANY, 0,
2661 "Get/set per-interface DNS server address");
2662 static int verb_dns(int argc, char *argv[], uintptr_t _data, void *userdata) {
2663 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
2664 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2665 int r;
2666
2667 r = acquire_bus(&bus);
2668 if (r < 0)
2669 return r;
2670
2671 if (argc >= 2) {
2672 r = ifname_mangle(argv[1]);
2673 if (r < 0)
2674 return r;
2675 }
2676
2677 if (arg_ifindex <= 0)
2678 return status_all(STATUS_DNS);
2679
2680 if (argc < 3)
2681 return status_ifindex(arg_ifindex, STATUS_DNS);
2682
2683 char **args = strv_skip(argv, 2);
2684 r = call_dns(bus, args, bus_resolve_mgr, &error, true);
2685 if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
2686 sd_bus_error_free(&error);
2687
2688 r = call_dns(bus, args, bus_network_mgr, &error, true);
2689 }
2690 if (r < 0) {
2691 if (arg_ifindex_permissive &&
2692 sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
2693 return 0;
2694
2695 return log_error_errno(r, "Failed to set DNS configuration: %s", bus_error_message(&error, r));
2696 }
2697
2698 return 0;
2699 }
2700
2701 static int call_domain(sd_bus *bus, char **domain, const BusLocator *locator, sd_bus_error *error) {
2702 _cleanup_(sd_bus_message_unrefp) sd_bus_message *req = NULL;
2703 int r;
2704
2705 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
2706
2707 r = bus_message_new_method_call(bus, &req, locator, "SetLinkDomains");
2708 if (r < 0)
2709 return bus_log_create_error(r);
2710
2711 r = sd_bus_message_append(req, "i", arg_ifindex);
2712 if (r < 0)
2713 return bus_log_create_error(r);
2714
2715 r = sd_bus_message_open_container(req, 'a', "(sb)");
2716 if (r < 0)
2717 return bus_log_create_error(r);
2718
2719 /* If only argument is the empty string, then call SetLinkDomains() with an
2720 * empty list, which will clear the list of domains for an interface. */
2721 if (!strv_equal(domain, STRV_MAKE("")))
2722 STRV_FOREACH(p, domain) {
2723 const char *n;
2724
2725 n = **p == '~' ? *p + 1 : *p;
2726
2727 r = dns_name_is_valid(n);
2728 if (r < 0)
2729 return log_error_errno(r, "Failed to validate specified domain %s: %m", n);
2730 if (r == 0)
2731 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
2732 "Domain not valid: %s",
2733 n);
2734
2735 r = sd_bus_message_append(req, "(sb)", n, **p == '~');
2736 if (r < 0)
2737 return bus_log_create_error(r);
2738 }
2739
2740 r = sd_bus_message_close_container(req);
2741 if (r < 0)
2742 return bus_log_create_error(r);
2743
2744 return sd_bus_call(bus, req, 0, error, NULL);
2745 }
2746
2747 VERB(verb_domain, "domain", "[LINK [DOMAIN…]]", VERB_ANY, VERB_ANY, 0,
2748 "Get/set per-interface search domain");
2749 static int verb_domain(int argc, char *argv[], uintptr_t _data, void *userdata) {
2750 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
2751 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2752 int r;
2753
2754 r = acquire_bus(&bus);
2755 if (r < 0)
2756 return r;
2757
2758 if (argc >= 2) {
2759 r = ifname_mangle(argv[1]);
2760 if (r < 0)
2761 return r;
2762 }
2763
2764 if (arg_ifindex <= 0)
2765 return status_all(STATUS_DOMAIN);
2766
2767 if (argc < 3)
2768 return status_ifindex(arg_ifindex, STATUS_DOMAIN);
2769
2770 char **args = strv_skip(argv, 2);
2771 r = call_domain(bus, args, bus_resolve_mgr, &error);
2772 if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
2773 sd_bus_error_free(&error);
2774
2775 r = call_domain(bus, args, bus_network_mgr, &error);
2776 }
2777 if (r < 0) {
2778 if (arg_ifindex_permissive &&
2779 sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
2780 return 0;
2781
2782 return log_error_errno(r, "Failed to set domain configuration: %s", bus_error_message(&error, r));
2783 }
2784
2785 return 0;
2786 }
2787
2788 VERB(verb_default_route, "default-route", "[LINK [BOOL]]", VERB_ANY, 3, 0,
2789 "Get/set per-interface default route flag");
2790 static int verb_default_route(int argc, char *argv[], uintptr_t _data, void *userdata) {
2791 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
2792 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2793 int r, b;
2794
2795 r = acquire_bus(&bus);
2796 if (r < 0)
2797 return r;
2798
2799 if (argc >= 2) {
2800 r = ifname_mangle(argv[1]);
2801 if (r < 0)
2802 return r;
2803 }
2804
2805 if (arg_ifindex <= 0)
2806 return status_all(STATUS_DEFAULT_ROUTE);
2807
2808 if (argc < 3)
2809 return status_ifindex(arg_ifindex, STATUS_DEFAULT_ROUTE);
2810
2811 b = parse_boolean(argv[2]);
2812 if (b < 0)
2813 return log_error_errno(b, "Failed to parse boolean argument: %s", argv[2]);
2814
2815 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
2816
2817 r = bus_call_method(bus, bus_resolve_mgr, "SetLinkDefaultRoute", &error, NULL, "ib", arg_ifindex, b);
2818 if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
2819 sd_bus_error_free(&error);
2820
2821 r = bus_call_method(bus, bus_network_mgr, "SetLinkDefaultRoute", &error, NULL, "ib", arg_ifindex, b);
2822 }
2823 if (r < 0) {
2824 if (arg_ifindex_permissive &&
2825 sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
2826 return 0;
2827
2828 return log_error_errno(r, "Failed to set default route configuration: %s", bus_error_message(&error, r));
2829 }
2830
2831 return 0;
2832 }
2833
2834 VERB(verb_llmnr, "llmnr", "[LINK [MODE]]", VERB_ANY, 3, 0,
2835 "Get/set per-interface LLMNR mode");
2836 static int verb_llmnr(int argc, char *argv[], uintptr_t _data, void *userdata) {
2837 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
2838 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2839 _cleanup_free_ char *global_llmnr_support_str = NULL;
2840 ResolveSupport global_llmnr_support, llmnr_support;
2841 int r;
2842
2843 r = acquire_bus(&bus);
2844 if (r < 0)
2845 return r;
2846
2847 if (argc >= 2) {
2848 r = ifname_mangle(argv[1]);
2849 if (r < 0)
2850 return r;
2851 }
2852
2853 if (arg_ifindex <= 0)
2854 return status_all(STATUS_LLMNR);
2855
2856 if (argc < 3)
2857 return status_ifindex(arg_ifindex, STATUS_LLMNR);
2858
2859 llmnr_support = resolve_support_from_string(argv[2]);
2860 if (llmnr_support < 0)
2861 return log_error_errno(llmnr_support, "Invalid LLMNR setting: %s", argv[2]);
2862
2863 r = bus_get_property_string(bus, bus_resolve_mgr, "LLMNR", &error, &global_llmnr_support_str);
2864 if (r < 0)
2865 return log_error_errno(r, "Failed to get the global LLMNR support state: %s", bus_error_message(&error, r));
2866
2867 global_llmnr_support = resolve_support_from_string(global_llmnr_support_str);
2868 if (global_llmnr_support < 0)
2869 return log_error_errno(global_llmnr_support, "Received invalid global LLMNR setting: %s", global_llmnr_support_str);
2870
2871 if (global_llmnr_support < llmnr_support)
2872 log_warning("Setting LLMNR support level \"%s\" for \"%s\", but the global support level is \"%s\".",
2873 argv[2], arg_ifname, global_llmnr_support_str);
2874
2875 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
2876
2877 r = bus_call_method(bus, bus_resolve_mgr, "SetLinkLLMNR", &error, NULL, "is", arg_ifindex, argv[2]);
2878 if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
2879 sd_bus_error_free(&error);
2880
2881 r = bus_call_method(bus, bus_network_mgr, "SetLinkLLMNR", &error, NULL, "is", arg_ifindex, argv[2]);
2882 }
2883 if (r < 0) {
2884 if (arg_ifindex_permissive &&
2885 sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
2886 return 0;
2887
2888 return log_error_errno(r, "Failed to set LLMNR configuration: %s", bus_error_message(&error, r));
2889 }
2890
2891 return 0;
2892 }
2893
2894 VERB(verb_mdns, "mdns", "[LINK [MODE]]", VERB_ANY, 3, 0,
2895 "Get/set per-interface MulticastDNS mode");
2896 static int verb_mdns(int argc, char *argv[], uintptr_t _data, void *userdata) {
2897 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
2898 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2899 _cleanup_free_ char *global_mdns_support_str = NULL;
2900 ResolveSupport global_mdns_support, mdns_support;
2901 int r;
2902
2903 r = acquire_bus(&bus);
2904 if (r < 0)
2905 return r;
2906
2907 if (argc >= 2) {
2908 r = ifname_mangle(argv[1]);
2909 if (r < 0)
2910 return r;
2911 }
2912
2913 if (arg_ifindex <= 0)
2914 return status_all(STATUS_MDNS);
2915
2916 if (argc < 3)
2917 return status_ifindex(arg_ifindex, STATUS_MDNS);
2918
2919 mdns_support = resolve_support_from_string(argv[2]);
2920 if (mdns_support < 0)
2921 return log_error_errno(mdns_support, "Invalid mDNS setting: %s", argv[2]);
2922
2923 r = bus_get_property_string(bus, bus_resolve_mgr, "MulticastDNS", &error, &global_mdns_support_str);
2924 if (r < 0)
2925 return log_error_errno(r, "Failed to get the global mDNS support state: %s", bus_error_message(&error, r));
2926
2927 global_mdns_support = resolve_support_from_string(global_mdns_support_str);
2928 if (global_mdns_support < 0)
2929 return log_error_errno(global_mdns_support, "Received invalid global mDNS setting: %s", global_mdns_support_str);
2930
2931 if (global_mdns_support < mdns_support)
2932 log_warning("Setting mDNS support level \"%s\" for \"%s\", but the global support level is \"%s\".",
2933 argv[2], arg_ifname, global_mdns_support_str);
2934
2935 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
2936
2937 r = bus_call_method(bus, bus_resolve_mgr, "SetLinkMulticastDNS", &error, NULL, "is", arg_ifindex, argv[2]);
2938 if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
2939 sd_bus_error_free(&error);
2940
2941 r = bus_call_method(
2942 bus,
2943 bus_network_mgr,
2944 "SetLinkMulticastDNS",
2945 &error,
2946 NULL,
2947 "is", arg_ifindex, argv[2]);
2948 }
2949 if (r < 0) {
2950 if (arg_ifindex_permissive &&
2951 sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
2952 return 0;
2953
2954 return log_error_errno(r, "Failed to set MulticastDNS configuration: %s", bus_error_message(&error, r));
2955 }
2956
2957 return 0;
2958 }
2959
2960 VERB(verb_dns_over_tls, "dnsovertls", "[LINK [MODE]]", VERB_ANY, 3, 0,
2961 "Get/set per-interface DNS-over-TLS mode");
2962 static int verb_dns_over_tls(int argc, char *argv[], uintptr_t _data, void *userdata) {
2963 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
2964 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2965 int r;
2966
2967 r = acquire_bus(&bus);
2968 if (r < 0)
2969 return r;
2970
2971 if (argc >= 2) {
2972 r = ifname_mangle(argv[1]);
2973 if (r < 0)
2974 return r;
2975 }
2976
2977 if (arg_ifindex <= 0)
2978 return status_all(STATUS_DNS_OVER_TLS);
2979
2980 if (argc < 3)
2981 return status_ifindex(arg_ifindex, STATUS_DNS_OVER_TLS);
2982
2983 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
2984
2985 r = bus_call_method(bus, bus_resolve_mgr, "SetLinkDNSOverTLS", &error, NULL, "is", arg_ifindex, argv[2]);
2986 if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
2987 sd_bus_error_free(&error);
2988
2989 r = bus_call_method(
2990 bus,
2991 bus_network_mgr,
2992 "SetLinkDNSOverTLS",
2993 &error,
2994 NULL,
2995 "is", arg_ifindex, argv[2]);
2996 }
2997 if (r < 0) {
2998 if (arg_ifindex_permissive &&
2999 sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
3000 return 0;
3001
3002 return log_error_errno(r, "Failed to set DNSOverTLS configuration: %s", bus_error_message(&error, r));
3003 }
3004
3005 return 0;
3006 }
3007
3008 VERB(verb_dnssec, "dnssec", "[LINK [MODE]]", VERB_ANY, 3, 0,
3009 "Get/set per-interface DNSSEC mode");
3010 static int verb_dnssec(int argc, char *argv[], uintptr_t _data, void *userdata) {
3011 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
3012 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
3013 int r;
3014
3015 r = acquire_bus(&bus);
3016 if (r < 0)
3017 return r;
3018
3019 if (argc >= 2) {
3020 r = ifname_mangle(argv[1]);
3021 if (r < 0)
3022 return r;
3023 }
3024
3025 if (arg_ifindex <= 0)
3026 return status_all(STATUS_DNSSEC);
3027
3028 if (argc < 3)
3029 return status_ifindex(arg_ifindex, STATUS_DNSSEC);
3030
3031 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
3032
3033 r = bus_call_method(bus, bus_resolve_mgr, "SetLinkDNSSEC", &error, NULL, "is", arg_ifindex, argv[2]);
3034 if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
3035 sd_bus_error_free(&error);
3036
3037 r = bus_call_method(bus, bus_network_mgr, "SetLinkDNSSEC", &error, NULL, "is", arg_ifindex, argv[2]);
3038 }
3039 if (r < 0) {
3040 if (arg_ifindex_permissive &&
3041 sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
3042 return 0;
3043
3044 return log_error_errno(r, "Failed to set DNSSEC configuration: %s", bus_error_message(&error, r));
3045 }
3046
3047 return 0;
3048 }
3049
3050 static int call_nta(sd_bus *bus, char **nta, const BusLocator *locator, sd_bus_error *error) {
3051 _cleanup_(sd_bus_message_unrefp) sd_bus_message *req = NULL;
3052 int r;
3053
3054 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
3055
3056 r = bus_message_new_method_call(bus, &req, locator, "SetLinkDNSSECNegativeTrustAnchors");
3057 if (r < 0)
3058 return bus_log_create_error(r);
3059
3060 r = sd_bus_message_append(req, "i", arg_ifindex);
3061 if (r < 0)
3062 return bus_log_create_error(r);
3063
3064 r = sd_bus_message_append_strv(req, nta);
3065 if (r < 0)
3066 return bus_log_create_error(r);
3067
3068 return sd_bus_call(bus, req, 0, error, NULL);
3069 }
3070
3071 VERB(verb_nta, "nta", "[LINK [DOMAIN…]]", VERB_ANY, VERB_ANY, 0,
3072 "Get/set per-interface DNSSEC NTA");
3073 static int verb_nta(int argc, char *argv[], uintptr_t _data, void *userdata) {
3074 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
3075 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
3076 char **args;
3077 bool clear;
3078 int r;
3079
3080 r = acquire_bus(&bus);
3081 if (r < 0)
3082 return r;
3083
3084 if (argc >= 2) {
3085 r = ifname_mangle(argv[1]);
3086 if (r < 0)
3087 return r;
3088 }
3089
3090 if (arg_ifindex <= 0)
3091 return status_all(STATUS_NTA);
3092
3093 if (argc < 3)
3094 return status_ifindex(arg_ifindex, STATUS_NTA);
3095
3096 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
3097
3098 /* If only argument is the empty string, then call SetLinkDNSSECNegativeTrustAnchors()
3099 * with an empty list, which will clear the list of domains for an interface. */
3100 args = strv_skip(argv, 2);
3101 clear = strv_equal(args, STRV_MAKE(""));
3102
3103 if (!clear)
3104 STRV_FOREACH(p, args) {
3105 r = dns_name_is_valid(*p);
3106 if (r < 0)
3107 return log_error_errno(r, "Failed to validate specified domain %s: %m", *p);
3108 if (r == 0)
3109 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
3110 "Domain not valid: %s",
3111 *p);
3112 }
3113
3114 r = call_nta(bus, clear ? NULL : args, bus_resolve_mgr, &error);
3115 if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
3116 sd_bus_error_free(&error);
3117
3118 r = call_nta(bus, clear ? NULL : args, bus_network_mgr, &error);
3119 }
3120 if (r < 0) {
3121 if (arg_ifindex_permissive &&
3122 sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
3123 return 0;
3124
3125 return log_error_errno(r, "Failed to set DNSSEC NTA configuration: %s", bus_error_message(&error, r));
3126 }
3127
3128 return 0;
3129 }
3130
3131 VERB(verb_revert_link, "revert", "LINK", VERB_ANY, 2, 0,
3132 "Revert per-interface configuration");
3133 static int verb_revert_link(int argc, char *argv[], uintptr_t _data, void *userdata) {
3134 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
3135 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
3136 int r;
3137
3138 r = acquire_bus(&bus);
3139 if (r < 0)
3140 return r;
3141
3142 if (argc >= 2) {
3143 r = ifname_mangle(argv[1]);
3144 if (r < 0)
3145 return r;
3146 }
3147
3148 if (arg_ifindex <= 0)
3149 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Interface argument required.");
3150
3151 (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
3152
3153 r = bus_call_method(bus, bus_resolve_mgr, "RevertLink", &error, NULL, "i", arg_ifindex);
3154 if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
3155 sd_bus_error_free(&error);
3156
3157 r = bus_call_method(bus, bus_network_mgr, "RevertLinkDNS", &error, NULL, "i", arg_ifindex);
3158 }
3159 if (r < 0) {
3160 if (arg_ifindex_permissive &&
3161 sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
3162 return 0;
3163
3164 return log_error_errno(r, "Failed to revert interface configuration: %s", bus_error_message(&error, r));
3165 }
3166
3167 return 0;
3168 }
3169
3170 VERB(verb_log_level, "log-level", "[LEVEL]", VERB_ANY, 2, 0,
3171 "Get/set logging threshold for systemd-resolved");
3172 static int verb_log_level(int argc, char *argv[], uintptr_t _data, void *userdata) {
3173 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
3174 int r;
3175
3176 r = acquire_bus(&bus);
3177 if (r < 0)
3178 return r;
3179
3180 assert(IN_SET(argc, 1, 2));
3181
3182 return verb_log_control_common(bus, "org.freedesktop.resolve1", argv[0], argc == 2 ? argv[1] : NULL);
3183 }
3184
3185 static int parse_protocol(const char *arg) {
3186 if (streq(arg, "help")) {
3187 if (arg_legend)
3188 puts("Known protocol types:");
3189 puts("dns\n"
3190 "llmnr\n"
3191 "llmnr-ipv4\n"
3192 "llmnr-ipv6\n"
3193 "mdns\n"
3194 "mdns-ipv4\n"
3195 "mdns-ipv6");
3196 return 0;
3197 }
3198
3199 if (streq(arg, "dns"))
3200 arg_flags |= SD_RESOLVED_DNS;
3201 else if (streq(arg, "llmnr"))
3202 arg_flags |= SD_RESOLVED_LLMNR;
3203 else if (streq(arg, "llmnr-ipv4"))
3204 arg_flags |= SD_RESOLVED_LLMNR_IPV4;
3205 else if (streq(arg, "llmnr-ipv6"))
3206 arg_flags |= SD_RESOLVED_LLMNR_IPV6;
3207 else if (streq(arg, "mdns"))
3208 arg_flags |= SD_RESOLVED_MDNS;
3209 else if (streq(arg, "mdns-ipv4"))
3210 arg_flags |= SD_RESOLVED_MDNS_IPV4;
3211 else if (streq(arg, "mdns-ipv6"))
3212 arg_flags |= SD_RESOLVED_MDNS_IPV6;
3213 else
3214 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
3215 "Unknown protocol specifier: %s", arg);
3216 return 1;
3217 }
3218
3219 static void help_dns_types(void) {
3220 if (arg_legend)
3221 puts("Known DNS RR types:");
3222
3223 DUMP_STRING_TABLE(dns_type, int, _DNS_TYPE_MAX);
3224 }
3225
3226 static void help_dns_classes(void) {
3227 if (arg_legend)
3228 puts("Known DNS RR classes:");
3229
3230 DUMP_STRING_TABLE(dns_class, int, _DNS_CLASS_MAX);
3231 }
3232
3233 static int compat_help(void) {
3234 _cleanup_(table_unrefp) Table *options = NULL;
3235 int r;
3236
3237 r = option_parser_get_help_table_ns("systemd-resolve", &options);
3238 if (r < 0)
3239 return r;
3240
3241 pager_open(arg_pager_flags);
3242
3243 help_cmdline("[OPTIONS…] HOSTNAME|ADDRESS…");
3244 help_cmdline("[OPTIONS…] --service [[NAME] TYPE] DOMAIN");
3245 help_cmdline("[OPTIONS…] --openpgp EMAIL@DOMAIN…");
3246 help_cmdline("[OPTIONS…] --statistics");
3247 help_cmdline("[OPTIONS…] --reset-statistics");
3248 help_abstract("Resolve domain names, IPv4 and IPv6 addresses, DNS records, and services.");
3249
3250 help_section("Options");
3251 r = table_print_or_warn(options);
3252 if (r < 0)
3253 return r;
3254
3255 help_man_page_reference("resolvectl", "1");
3256 return 0;
3257 }
3258
3259 static int native_help(void) {
3260 _cleanup_(table_unrefp) Table *verbs = NULL, *options = NULL;
3261 int r;
3262
3263 r = verbs_get_help_table(&verbs);
3264 if (r < 0)
3265 return r;
3266
3267 r = option_parser_get_help_table_ns("resolvectl", &options);
3268 if (r < 0)
3269 return r;
3270
3271 (void) table_sync_column_widths(0, verbs, options);
3272
3273 pager_open(arg_pager_flags);
3274
3275 help_cmdline("[OPTIONS…] COMMAND …");
3276 help_abstract("Send control commands to the network name resolution manager, or\n"
3277 "resolve domain names, IPv4 and IPv6 addresses, DNS records, and services.");
3278
3279 help_section("Commands");
3280 r = table_print_or_warn(verbs);
3281 if (r < 0)
3282 return r;
3283
3284 help_section("Options");
3285 r = table_print_or_warn(options);
3286 if (r < 0)
3287 return r;
3288
3289 help_man_page_reference("resolvectl", "1");
3290 return 0;
3291 }
3292
3293 VERB_COMMON_HELP_HIDDEN(native_help);
3294
3295 static int compat_parse_argv(int argc, char *argv[], char ***remaining_args) {
3296 int r;
3297
3298 assert(argc >= 0);
3299 assert(argv);
3300 assert(remaining_args);
3301
3302 OptionParser opts = { argc, argv, .namespace = "systemd-resolve" };
3303
3304 FOREACH_OPTION_OR_RETURN(c, &opts)
3305 switch (c) {
3306
3307 OPTION_NAMESPACE("systemd-resolve"): {}
3308
3309 OPTION_COMMON_HELP:
3310 return compat_help();
3311
3312 OPTION_COMMON_VERSION:
3313 return version();
3314
3315 OPTION_SHORT('4', NULL, "Resolve IPv4 addresses"):
3316 arg_family = AF_INET;
3317 break;
3318
3319 OPTION_SHORT('6', NULL, "Resolve IPv6 addresses"):
3320 arg_family = AF_INET6;
3321 break;
3322
3323 OPTION('i', "interface", "INTERFACE", "Look on interface"):
3324 r = ifname_mangle(opts.arg);
3325 if (r < 0)
3326 return r;
3327 break;
3328
3329 OPTION('p', "protocol", "PROTO|help", "Look via protocol"):
3330 r = parse_protocol(opts.arg);
3331 if (r <= 0)
3332 return r;
3333 break;
3334
3335 OPTION('t', "type", "TYPE|help", "Query RR with DNS type"):
3336 if (streq(opts.arg, "help")) {
3337 help_dns_types();
3338 return 0;
3339 }
3340
3341 r = dns_type_from_string(opts.arg);
3342 if (r < 0)
3343 return log_error_errno(r, "Failed to parse RR record type %s: %m", opts.arg);
3344
3345 arg_type = (uint16_t) r;
3346 assert((int) arg_type == r);
3347
3348 arg_mode = MODE_RESOLVE_RECORD;
3349 break;
3350
3351 OPTION('c', "class", "CLASS|help", "Query RR with DNS class"):
3352 if (streq(opts.arg, "help")) {
3353 help_dns_classes();
3354 return 0;
3355 }
3356
3357 r = dns_class_from_string(opts.arg);
3358 if (r < 0)
3359 return log_error_errno(r, "Failed to parse RR record class %s: %m", opts.arg);
3360
3361 arg_class = (uint16_t) r;
3362 assert((int) arg_class == r);
3363
3364 break;
3365
3366 OPTION_LONG("service", NULL, "Resolve service (SRV)"):
3367 arg_mode = MODE_RESOLVE_SERVICE;
3368 break;
3369
3370 OPTION_LONG("service-address", "BOOL", "Resolve address for services (default: yes)"):
3371 r = parse_boolean_argument("--service-address=", opts.arg, NULL);
3372 if (r < 0)
3373 return r;
3374 SET_FLAG(arg_flags, SD_RESOLVED_NO_ADDRESS, r == 0);
3375 break;
3376
3377 OPTION_LONG("service-txt", "BOOL", "Resolve TXT records for services (default: yes)"):
3378 r = parse_boolean_argument("--service-txt=", opts.arg, NULL);
3379 if (r < 0)
3380 return r;
3381 SET_FLAG(arg_flags, SD_RESOLVED_NO_TXT, r == 0);
3382 break;
3383
3384 OPTION_LONG("openpgp", NULL, "Query OpenPGP public key"):
3385 arg_mode = MODE_RESOLVE_OPENPGP;
3386 break;
3387
3388 OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "tlsa", "FAMILY", "Query TLS public key"):
3389 arg_mode = MODE_RESOLVE_TLSA;
3390 if (!opts.arg || service_family_is_valid(opts.arg))
3391 arg_service_family = opts.arg;
3392 else
3393 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
3394 "Unknown service family \"%s\".", opts.arg);
3395 break;
3396
3397 OPTION_LONG("cname", "BOOL", "Follow CNAME redirects (default: yes)"):
3398 r = parse_boolean_argument("--cname=", opts.arg, NULL);
3399 if (r < 0)
3400 return r;
3401 SET_FLAG(arg_flags, SD_RESOLVED_NO_CNAME, r == 0);
3402 break;
3403
3404 OPTION_LONG("search", "BOOL", "Use search domains for single-label names (default: yes)"):
3405 r = parse_boolean_argument("--search=", opts.arg, NULL);
3406 if (r < 0)
3407 return r;
3408 SET_FLAG(arg_flags, SD_RESOLVED_NO_SEARCH, r == 0);
3409 break;
3410
3411 OPTION_LONG("statistics", NULL, "Show resolver statistics"):
3412 arg_mode = MODE_STATISTICS;
3413 break;
3414
3415 OPTION_LONG("reset-statistics", NULL, "Reset resolver statistics"):
3416 arg_mode = MODE_RESET_STATISTICS;
3417 break;
3418
3419 OPTION_LONG("status", NULL, "Show link and server status"):
3420 arg_mode = MODE_STATUS;
3421 break;
3422
3423 OPTION_LONG("flush-caches", NULL, "Flush all local DNS caches"):
3424 arg_mode = MODE_FLUSH_CACHES;
3425 break;
3426
3427 OPTION_LONG("reset-server-features", NULL,
3428 "Forget learnt DNS server feature levels"):
3429 arg_mode = MODE_RESET_SERVER_FEATURES;
3430 break;
3431
3432 OPTION_LONG("set-dns", "SERVER", "Set per-interface DNS server address"):
3433 r = strv_extend(&arg_set_dns, opts.arg);
3434 if (r < 0)
3435 return log_oom();
3436
3437 arg_mode = MODE_SET_LINK;
3438 break;
3439
3440 OPTION_LONG("set-domain", "DOMAIN", "Set per-interface search domain"):
3441 r = strv_extend(&arg_set_domain, opts.arg);
3442 if (r < 0)
3443 return log_oom();
3444
3445 arg_mode = MODE_SET_LINK;
3446 break;
3447
3448 OPTION_LONG("set-llmnr", "MODE", "Set per-interface LLMNR mode"):
3449 arg_set_llmnr = opts.arg;
3450 arg_mode = MODE_SET_LINK;
3451 break;
3452
3453 OPTION_LONG("set-mdns", "MODE", "Set per-interface MulticastDNS mode"):
3454 arg_set_mdns = opts.arg;
3455 arg_mode = MODE_SET_LINK;
3456 break;
3457
3458 OPTION_LONG("set-dnsovertls", "MODE", "Set per-interface DNS-over-TLS mode"):
3459 arg_set_dns_over_tls = opts.arg;
3460 arg_mode = MODE_SET_LINK;
3461 break;
3462
3463 OPTION_LONG("set-dnssec", "MODE", "Set per-interface DNSSEC mode"):
3464 arg_set_dnssec = opts.arg;
3465 arg_mode = MODE_SET_LINK;
3466 break;
3467
3468 OPTION_LONG("set-nta", "DOMAIN", "Set per-interface DNSSEC NTA"):
3469 r = strv_extend(&arg_set_nta, opts.arg);
3470 if (r < 0)
3471 return log_oom();
3472
3473 arg_mode = MODE_SET_LINK;
3474 break;
3475
3476 OPTION_LONG("revert", NULL, "Revert per-interface configuration"):
3477 arg_mode = MODE_REVERT_LINK;
3478 break;
3479
3480 OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "raw", "payload|packet",
3481 "Dump the answer as binary data"):
3482 if (on_tty())
3483 return log_error_errno(SYNTHETIC_ERRNO(ENOTTY),
3484 "Refusing to write binary data to tty.");
3485
3486 if (opts.arg == NULL || streq(opts.arg, "payload"))
3487 arg_raw = RAW_PAYLOAD;
3488 else if (streq(opts.arg, "packet"))
3489 arg_raw = RAW_PACKET;
3490 else
3491 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
3492 "Unknown --raw specifier \"%s\".",
3493 opts.arg);
3494
3495 arg_legend = false;
3496 break;
3497
3498 OPTION_COMMON_NO_PAGER:
3499 arg_pager_flags |= PAGER_DISABLE;
3500 break;
3501
3502 OPTION_LONG("legend", "BOOL", "Print headers and additional info (default: yes)"):
3503 r = parse_boolean_argument("--legend=", opts.arg, &arg_legend);
3504 if (r < 0)
3505 return r;
3506 break;
3507 }
3508
3509 if (arg_type == 0 && arg_class != 0)
3510 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
3511 "--class= may only be used in conjunction with --type=.");
3512
3513 if (arg_type != 0 && arg_mode == MODE_RESOLVE_SERVICE)
3514 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
3515 "--service and --type= may not be combined.");
3516
3517 if (arg_type != 0 && arg_class == 0)
3518 arg_class = DNS_CLASS_IN;
3519
3520 if (arg_class != 0 && arg_type == 0)
3521 arg_type = DNS_TYPE_A;
3522
3523 if (IN_SET(arg_mode, MODE_SET_LINK, MODE_REVERT_LINK)) {
3524
3525 if (arg_ifindex <= 0)
3526 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
3527 "--set-dns=, --set-domain=, --set-llmnr=, --set-mdns=, --set-dnsovertls=, --set-dnssec=, --set-nta= and --revert require --interface=.");
3528 }
3529
3530 *remaining_args = option_parser_get_args(&opts);
3531 return 1 /* work to do */;
3532 }
3533
3534 static int native_parse_argv(int argc, char *argv[], char ***remaining_args) {
3535 int r;
3536
3537 assert(argc >= 0);
3538 assert(argv);
3539 assert(remaining_args);
3540
3541 OptionParser opts = { argc, argv, .namespace = "resolvectl" };
3542
3543 FOREACH_OPTION_OR_RETURN(c, &opts)
3544 switch (c) {
3545
3546 OPTION_NAMESPACE("resolvectl"): {}
3547
3548 OPTION_COMMON_HELP:
3549 return native_help();
3550
3551 OPTION_COMMON_VERSION:
3552 return version();
3553
3554 OPTION_SHORT('4', NULL, "Resolve IPv4 addresses"):
3555 arg_family = AF_INET;
3556 break;
3557
3558 OPTION_SHORT('6', NULL, "Resolve IPv6 addresses"):
3559 arg_family = AF_INET6;
3560 break;
3561
3562 OPTION('i', "interface", "INTERFACE", "Look on interface"):
3563 r = ifname_mangle(opts.arg);
3564 if (r < 0)
3565 return r;
3566 break;
3567
3568 OPTION('p', "protocol", "PROTO|help", "Look via protocol"):
3569 r = parse_protocol(opts.arg);
3570 if (r <= 0)
3571 return r;
3572 break;
3573
3574 OPTION('t', "type", "TYPE|help", "Query RR with DNS type"):
3575 if (streq(opts.arg, "help")) {
3576 help_dns_types();
3577 return 0;
3578 }
3579
3580 r = dns_type_from_string(opts.arg);
3581 if (r < 0)
3582 return log_error_errno(r, "Failed to parse RR record type %s: %m", opts.arg);
3583
3584 arg_type = (uint16_t) r;
3585 assert((int) arg_type == r);
3586
3587 break;
3588
3589 OPTION('c', "class", "CLASS|help", "Query RR with DNS class"):
3590 if (streq(opts.arg, "help")) {
3591 help_dns_classes();
3592 return 0;
3593 }
3594
3595 r = dns_class_from_string(opts.arg);
3596 if (r < 0)
3597 return log_error_errno(r, "Failed to parse RR record class %s: %m", opts.arg);
3598
3599 arg_class = (uint16_t) r;
3600 assert((int) arg_class == r);
3601
3602 break;
3603
3604 OPTION_LONG("service-address", "BOOL", "Resolve address for services (default: yes)"):
3605 r = parse_boolean_argument("--service-address=", opts.arg, NULL);
3606 if (r < 0)
3607 return r;
3608 SET_FLAG(arg_flags, SD_RESOLVED_NO_ADDRESS, r == 0);
3609 break;
3610
3611 OPTION_LONG("service-txt", "BOOL", "Resolve TXT records for services (default: yes)"):
3612 r = parse_boolean_argument("--service-txt=", opts.arg, NULL);
3613 if (r < 0)
3614 return r;
3615 SET_FLAG(arg_flags, SD_RESOLVED_NO_TXT, r == 0);
3616 break;
3617
3618 OPTION_LONG("cname", "BOOL", "Follow CNAME redirects (default: yes)"):
3619 r = parse_boolean_argument("--cname=", opts.arg, NULL);
3620 if (r < 0)
3621 return r;
3622 SET_FLAG(arg_flags, SD_RESOLVED_NO_CNAME, r == 0);
3623 break;
3624
3625 OPTION_LONG("validate", "BOOL", "Allow DNSSEC validation (default: yes)"):
3626 r = parse_boolean_argument("--validate=", opts.arg, NULL);
3627 if (r < 0)
3628 return r;
3629 SET_FLAG(arg_flags, SD_RESOLVED_NO_VALIDATE, r == 0);
3630 break;
3631
3632 OPTION_LONG("synthesize", "BOOL", "Allow synthetic response (default: yes)"):
3633 r = parse_boolean_argument("--synthesize=", opts.arg, NULL);
3634 if (r < 0)
3635 return r;
3636 SET_FLAG(arg_flags, SD_RESOLVED_NO_SYNTHESIZE, r == 0);
3637 break;
3638
3639 OPTION_LONG("cache", "BOOL", "Allow response from cache (default: yes)"):
3640 r = parse_boolean_argument("--cache=", opts.arg, NULL);
3641 if (r < 0)
3642 return r;
3643 SET_FLAG(arg_flags, SD_RESOLVED_NO_CACHE, r == 0);
3644 break;
3645
3646 OPTION_LONG("stale-data", "BOOL",
3647 "Allow response from cache with stale data (default: yes)"):
3648 r = parse_boolean_argument("--stale-data=", opts.arg, NULL);
3649 if (r < 0)
3650 return r;
3651 SET_FLAG(arg_flags, SD_RESOLVED_NO_STALE, r == 0);
3652 break;
3653
3654 OPTION_LONG("relax-single-label", "BOOL",
3655 "Allow single label lookups to go upstream (default: no)"):
3656 r = parse_boolean_argument("--relax-single-label=", opts.arg, NULL);
3657 if (r < 0)
3658 return r;
3659 SET_FLAG(arg_flags, SD_RESOLVED_RELAX_SINGLE_LABEL, r > 0);
3660 break;
3661
3662 OPTION_LONG("zone", "BOOL",
3663 "Allow response from locally registered mDNS/LLMNR records (default: yes)"):
3664 r = parse_boolean_argument("--zone=", opts.arg, NULL);
3665 if (r < 0)
3666 return r;
3667 SET_FLAG(arg_flags, SD_RESOLVED_NO_ZONE, r == 0);
3668 break;
3669
3670 OPTION_LONG("trust-anchor", "BOOL",
3671 "Allow response from local trust anchor (default: yes)"):
3672 r = parse_boolean_argument("--trust-anchor=", opts.arg, NULL);
3673 if (r < 0)
3674 return r;
3675 SET_FLAG(arg_flags, SD_RESOLVED_NO_TRUST_ANCHOR, r == 0);
3676 break;
3677
3678 OPTION_LONG("network", "BOOL", "Allow response from network (default: yes)"):
3679 r = parse_boolean_argument("--network=", opts.arg, NULL);
3680 if (r < 0)
3681 return r;
3682 SET_FLAG(arg_flags, SD_RESOLVED_NO_NETWORK, r == 0);
3683 break;
3684
3685 OPTION_LONG("search", "BOOL", "Use search domains for single-label names (default: yes)"):
3686 r = parse_boolean_argument("--search=", opts.arg, NULL);
3687 if (r < 0)
3688 return r;
3689 SET_FLAG(arg_flags, SD_RESOLVED_NO_SEARCH, r == 0);
3690 break;
3691
3692 OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "raw", "payload|packet",
3693 "Dump the answer as binary data"):
3694 if (on_tty())
3695 return log_error_errno(SYNTHETIC_ERRNO(ENOTTY),
3696 "Refusing to write binary data to tty.");
3697
3698 if (opts.arg == NULL || streq(opts.arg, "payload"))
3699 arg_raw = RAW_PAYLOAD;
3700 else if (streq(opts.arg, "packet"))
3701 arg_raw = RAW_PACKET;
3702 else
3703 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
3704 "Unknown --raw specifier \"%s\".",
3705 opts.arg);
3706
3707 arg_legend = false;
3708 break;
3709
3710 OPTION_COMMON_NO_PAGER:
3711 arg_pager_flags |= PAGER_DISABLE;
3712 break;
3713
3714 OPTION_COMMON_NO_ASK_PASSWORD:
3715 arg_ask_password = false;
3716 break;
3717
3718 OPTION_LONG("legend", "BOOL", "Print headers and additional info (default: yes)"):
3719 r = parse_boolean_argument("--legend=", opts.arg, &arg_legend);
3720 if (r < 0)
3721 return r;
3722 break;
3723
3724 OPTION_COMMON_JSON:
3725 r = parse_json_argument(opts.arg, &arg_json_format_flags);
3726 if (r <= 0)
3727 return r;
3728 break;
3729
3730 OPTION_COMMON_LOWERCASE_J:
3731 arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
3732 break;
3733 }
3734
3735 if (arg_type == 0 && arg_class != 0)
3736 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
3737 "--class= may only be used in conjunction with --type=.");
3738
3739 if (arg_type != 0 && arg_class == 0)
3740 arg_class = DNS_CLASS_IN;
3741
3742 if (arg_class != 0 && arg_type == 0)
3743 arg_type = DNS_TYPE_A;
3744
3745 *remaining_args = option_parser_get_args(&opts);
3746 return 1 /* work to do */;
3747 }
3748
3749 static int translate(const char *verb, const char *single_arg, char **args) {
3750 char **fake, **p;
3751 size_t num;
3752
3753 assert(verb);
3754
3755 num = !!single_arg + strv_length(args) + 1;
3756
3757 p = fake = newa0(char *, num + 1);
3758 *p++ = (char *) verb;
3759 if (single_arg)
3760 *p++ = (char *) single_arg;
3761 STRV_FOREACH(a, args)
3762 *p++ = *a;
3763
3764 return dispatch_verb(fake, /* userdata= */ NULL);
3765 }
3766
3767 static int compat_main(char **args) {
3768 int r = 0;
3769
3770 switch (arg_mode) {
3771 case MODE_RESOLVE_HOST:
3772 case MODE_RESOLVE_RECORD:
3773 return translate("query", NULL, args);
3774
3775 case MODE_RESOLVE_SERVICE:
3776 return translate("service", NULL, args);
3777
3778 case MODE_RESOLVE_OPENPGP:
3779 return translate("openpgp", NULL, args);
3780
3781 case MODE_RESOLVE_TLSA:
3782 return translate("tlsa", arg_service_family, args);
3783
3784 case MODE_STATISTICS:
3785 return translate("statistics", NULL, NULL);
3786
3787 case MODE_RESET_STATISTICS:
3788 return translate("reset-statistics", NULL, NULL);
3789
3790 case MODE_FLUSH_CACHES:
3791 return translate("flush-caches", NULL, NULL);
3792
3793 case MODE_RESET_SERVER_FEATURES:
3794 return translate("reset-server-features", NULL, NULL);
3795
3796 case MODE_STATUS:
3797 return translate("status", NULL, args);
3798
3799 case MODE_SET_LINK:
3800 assert(arg_ifname);
3801
3802 if (arg_disable_default_route) {
3803 r = translate("default-route", arg_ifname, STRV_MAKE("no"));
3804 if (r < 0)
3805 return r;
3806 }
3807
3808 if (arg_set_dns) {
3809 r = translate("dns", arg_ifname, arg_set_dns);
3810 if (r < 0)
3811 return r;
3812 }
3813
3814 if (arg_set_domain) {
3815 r = translate("domain", arg_ifname, arg_set_domain);
3816 if (r < 0)
3817 return r;
3818 }
3819
3820 if (arg_set_nta) {
3821 r = translate("nta", arg_ifname, arg_set_nta);
3822 if (r < 0)
3823 return r;
3824 }
3825
3826 if (arg_set_llmnr) {
3827 r = translate("llmnr", arg_ifname, STRV_MAKE(arg_set_llmnr));
3828 if (r < 0)
3829 return r;
3830 }
3831
3832 if (arg_set_mdns) {
3833 r = translate("mdns", arg_ifname, STRV_MAKE(arg_set_mdns));
3834 if (r < 0)
3835 return r;
3836 }
3837
3838 if (arg_set_dns_over_tls) {
3839 r = translate("dnsovertls", arg_ifname, STRV_MAKE(arg_set_dns_over_tls));
3840 if (r < 0)
3841 return r;
3842 }
3843
3844 if (arg_set_dnssec) {
3845 r = translate("dnssec", arg_ifname, STRV_MAKE(arg_set_dnssec));
3846 if (r < 0)
3847 return r;
3848 }
3849
3850 return r;
3851
3852 case MODE_REVERT_LINK:
3853 assert(arg_ifname);
3854
3855 return translate("revert", arg_ifname, NULL);
3856
3857 case _MODE_INVALID:
3858 assert_not_reached();
3859 }
3860
3861 return 0;
3862 }
3863
3864 static int run(int argc, char **argv) {
3865 char **args = NULL;
3866 bool compat = false;
3867 int r;
3868
3869 setlocale(LC_ALL, "");
3870 log_setup();
3871
3872 if (invoked_as(argv, "resolvconf")) {
3873 compat = true;
3874 r = resolvconf_parse_argv(argc, argv);
3875 } else if (invoked_as(argv, "systemd-resolve")) {
3876 compat = true;
3877 r = compat_parse_argv(argc, argv, &args);
3878 } else
3879 r = native_parse_argv(argc, argv, &args);
3880 if (r <= 0)
3881 return r;
3882
3883 if (compat)
3884 return compat_main(args);
3885
3886 return dispatch_verb(args, /* userdata= */ NULL);
3887 }
3888
3889 DEFINE_MAIN_FUNCTION(run);