]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/resolve/resolved-bus.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge pull request #11827 from keszybz/pkgconfig-variables
[thirdparty/systemd.git] / src / resolve / resolved-bus.c
CommitLineData
53e1b683 1/* SPDX-License-Identifier: LGPL-2.1+ */
74b2466e 2
b5efdb8a 3#include "alloc-util.h"
96aad8d1 4#include "bus-common-errors.h"
74b2466e 5#include "bus-util.h"
4ad7f276 6#include "dns-domain.h"
ef118d00 7#include "missing_capability.h"
39d8db04 8#include "resolved-bus.h"
51323288 9#include "resolved-def.h"
c3be369f 10#include "resolved-dns-synthesize.h"
c3036641
DR		 11#include "resolved-dnssd.h"
12#include "resolved-dnssd-bus.h"
3abaabda 13#include "resolved-link-bus.h"
84b0f133 14#include "user-util.h"
c3036641 15#include "utf8.h"
74b2466e 16
bf4e5c4c
YW		 17BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_resolve_support, resolve_support, ResolveSupport);
18
ad867662 19static int reply_query_state(DnsQuery *q) {
ad867662
LP		 20
21 switch (q->state) {
74b2466e 22
ec2c5e43 23 case DNS_TRANSACTION_NO_SERVERS:
309e9d86 24 return sd_bus_reply_method_errorf(q->request, BUS_ERROR_NO_NAME_SERVERS, "No appropriate name servers or networks for name found");
74b2466e 25
ec2c5e43 26 case DNS_TRANSACTION_TIMEOUT:
ad867662 27 return sd_bus_reply_method_errorf(q->request, SD_BUS_ERROR_TIMEOUT, "Query timed out");
74b2466e 28
ec2c5e43 29 case DNS_TRANSACTION_ATTEMPTS_MAX_REACHED:
ad867662
LP		 30 return sd_bus_reply_method_errorf(q->request, SD_BUS_ERROR_TIMEOUT, "All attempts to contact name servers or networks failed");
31
818f766b
LP		 32 case DNS_TRANSACTION_INVALID_REPLY:
33 return sd_bus_reply_method_errorf(q->request, BUS_ERROR_INVALID_REPLY, "Received invalid reply");
34
7cc6ed7b
LP		 35 case DNS_TRANSACTION_ERRNO:
36 return sd_bus_reply_method_errnof(q->request, q->answer_errno, "Lookup failed due to system error: %m");
ad867662 37
818f766b
LP		 38 case DNS_TRANSACTION_ABORTED:
39 return sd_bus_reply_method_errorf(q->request, BUS_ERROR_ABORTED, "Query aborted");
74b2466e 40
547973de 41 case DNS_TRANSACTION_DNSSEC_FAILED:
a761c1ca 42 return sd_bus_reply_method_errorf(q->request, BUS_ERROR_DNSSEC_FAILED, "DNSSEC validation failed: %s",
019036a4 43 dnssec_result_to_string(q->answer_dnssec_result));
547973de 44
b2b796b8
LP		 45 case DNS_TRANSACTION_NO_TRUST_ANCHOR:
46 return sd_bus_reply_method_errorf(q->request, BUS_ERROR_NO_TRUST_ANCHOR, "No suitable trust anchor known");
47
91adc4db
LP		 48 case DNS_TRANSACTION_RR_TYPE_UNSUPPORTED:
49 return sd_bus_reply_method_errorf(q->request, BUS_ERROR_RR_TYPE_UNSUPPORTED, "Server does not support requested resource record type");
50
edbcc1fd
LP		 51 case DNS_TRANSACTION_NETWORK_DOWN:
52 return sd_bus_reply_method_errorf(q->request, BUS_ERROR_NETWORK_DOWN, "Network is down");
53
0791110f
LP		 54 case DNS_TRANSACTION_NOT_FOUND:
55 /* We return this as NXDOMAIN. This is only generated when a host doesn't implement LLMNR/TCP, and we
56 * thus quickly know that we cannot resolve an in-addr.arpa or ip6.arpa address. */
57 return sd_bus_reply_method_errorf(q->request, _BUS_ERROR_DNS "NXDOMAIN", "'%s' not found", dns_query_string(q));
58
3bbdc31d 59 case DNS_TRANSACTION_RCODE_FAILURE: {
4afd3348 60 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
74b2466e 61
faa133f3 62 if (q->answer_rcode == DNS_RCODE_NXDOMAIN)
23b298bc 63 sd_bus_error_setf(&error, _BUS_ERROR_DNS "NXDOMAIN", "'%s' not found", dns_query_string(q));
74b2466e
LP		 64 else {
65 const char *rc, *n;
3347dd5e 66 char p[DECIMAL_STR_MAX(q->answer_rcode)];
74b2466e 67
faa133f3 68 rc = dns_rcode_to_string(q->answer_rcode);
74b2466e 69 if (!rc) {
faa133f3 70 sprintf(p, "%i", q->answer_rcode);
74b2466e
LP		 71 rc = p;
72 }
73
63c372cb 74 n = strjoina(_BUS_ERROR_DNS, rc);
23b298bc 75 sd_bus_error_setf(&error, n, "Could not resolve '%s', server or network returned error %s", dns_query_string(q), rc);
74b2466e
LP		 76 }
77
ad867662 78 return sd_bus_reply_method_error(q->request, &error);
74b2466e
LP		 79 }
80
ec2c5e43
LP		 81 case DNS_TRANSACTION_NULL:
82 case DNS_TRANSACTION_PENDING:
ef9fb66c 83 case DNS_TRANSACTION_VALIDATING:
ec2c5e43 84 case DNS_TRANSACTION_SUCCESS:
8ba9fd9c 85 default:
ad867662
LP		 86 assert_not_reached("Impossible state");
87 }
88}
74b2466e 89
78c6a153 90static int append_address(sd_bus_message *reply, DnsResourceRecord *rr, int ifindex) {
8ba9fd9c
LP		 91 int r;
92
93 assert(reply);
94 assert(rr);
95
78c6a153
LP		 96 r = sd_bus_message_open_container(reply, 'r', "iiay");
97 if (r < 0)
98 return r;
99
100 r = sd_bus_message_append(reply, "i", ifindex);
8ba9fd9c
LP		 101 if (r < 0)
102 return r;
103
faa133f3 104 if (rr->key->type == DNS_TYPE_A) {
0dd25fb9 105 r = sd_bus_message_append(reply, "i", AF_INET);
8ba9fd9c
LP		 106 if (r < 0)
107 return r;
108
109 r = sd_bus_message_append_array(reply, 'y', &rr->a.in_addr, sizeof(struct in_addr));
faa133f3
LP		 110
111 } else if (rr->key->type == DNS_TYPE_AAAA) {
0dd25fb9 112 r = sd_bus_message_append(reply, "i", AF_INET6);
8ba9fd9c
LP		 113 if (r < 0)
114 return r;
115
116 r = sd_bus_message_append_array(reply, 'y', &rr->aaaa.in6_addr, sizeof(struct in6_addr));
faa133f3
LP		 117 } else
118 return -EAFNOSUPPORT;
119
8ba9fd9c
LP		 120 if (r < 0)
121 return r;
122
8ba9fd9c
LP		 123 r = sd_bus_message_close_container(reply);
124 if (r < 0)
125 return r;
126
127 return 0;
128}
129
ad867662 130static void bus_method_resolve_hostname_complete(DnsQuery *q) {
45ec7efb 131 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *canonical = NULL;
4afd3348 132 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
c77d2612 133 _cleanup_free_ char *normalized = NULL;
ce736ace 134 DnsResourceRecord *rr;
45ec7efb 135 unsigned added = 0;
ce736ace 136 int ifindex, r;
74b2466e 137
ad867662 138 assert(q);
74b2466e 139
ec2c5e43 140 if (q->state != DNS_TRANSACTION_SUCCESS) {
ad867662
LP		 141 r = reply_query_state(q);
142 goto finish;
143 }
74b2466e 144
45ec7efb
LP		 145 r = dns_query_process_cname(q);
146 if (r == -ELOOP) {
23b298bc 147 r = sd_bus_reply_method_errorf(q->request, BUS_ERROR_CNAME_LOOP, "CNAME loop detected, or CNAME resolving disabled on '%s'", dns_query_string(q));
45ec7efb
LP		 148 goto finish;
149 }
150 if (r < 0)
151 goto finish;
7588460a 152 if (r == DNS_QUERY_RESTARTED) /* This was a cname, and the query was restarted. */
45ec7efb
LP		 153 return;
154
ad867662
LP		 155 r = sd_bus_message_new_method_return(q->request, &reply);
156 if (r < 0)
157 goto finish;
74b2466e 158
78c6a153 159 r = sd_bus_message_open_container(reply, 'a', "(iiay)");
51323288
LP		 160 if (r < 0)
161 goto finish;
8ba9fd9c 162
ce736ace
LP		 163 DNS_ANSWER_FOREACH_IFINDEX(rr, ifindex, q->answer) {
164 DnsQuestion *question;
23b298bc 165
ce736ace 166 question = dns_query_question_for_protocol(q, q->answer_protocol);
23b298bc 167
ce736ace
LP		 168 r = dns_question_matches_rr(question, rr, DNS_SEARCH_DOMAIN_NAME(q->answer_search_domain));
169 if (r < 0)
170 goto finish;
171 if (r == 0)
172 continue;
74b2466e 173
ce736ace
LP		 174 r = append_address(reply, rr, ifindex);
175 if (r < 0)
176 goto finish;
74b2466e 177
ce736ace
LP		 178 if (!canonical)
179 canonical = dns_resource_record_ref(rr);
309e9d86 180
313cefa1 181 added++;
8ba9fd9c 182 }
74b2466e 183
45ec7efb 184 if (added <= 0) {
23b298bc 185 r = sd_bus_reply_method_errorf(q->request, BUS_ERROR_NO_SUCH_RR, "'%s' does not have any RR of the requested type", dns_query_string(q));
45ec7efb 186 goto finish;
74b2466e
LP		 187 }
188
ad867662
LP		 189 r = sd_bus_message_close_container(reply);
190 if (r < 0)
191 goto finish;
192
c77d2612
LP		 193 /* The key names are not necessarily normalized, make sure that they are when we return them to our bus
194 * clients. */
7470cc4c 195 r = dns_name_normalize(dns_resource_key_name(canonical->key), 0, &normalized);
c77d2612
LP		 196 if (r < 0)
197 goto finish;
198
45ec7efb 199 /* Return the precise spelling and uppercasing and CNAME target reported by the server */
309e9d86 200 assert(canonical);
45ec7efb
LP		 201 r = sd_bus_message_append(
202 reply, "st",
c77d2612 203 normalized,
28830a64 204 SD_RESOLVED_FLAGS_MAKE(q->answer_protocol, q->answer_family, dns_query_fully_authenticated(q)));
309e9d86
LP		 205 if (r < 0)
206 goto finish;
207
ad867662 208 r = sd_bus_send(q->manager->bus, reply, NULL);
ad867662 209
74b2466e 210finish:
2d4c5cbc 211 if (r < 0) {
da927ba9 212 log_error_errno(r, "Failed to send hostname reply: %m");
45ec7efb 213 sd_bus_reply_method_errno(q->request, r, NULL);
2d4c5cbc 214 }
74b2466e
LP		 215
216 dns_query_free(q);
217}
218
45ec7efb 219static int check_ifindex_flags(int ifindex, uint64_t *flags, uint64_t ok, sd_bus_error *error) {
51323288
LP		 220 assert(flags);
221
222 if (ifindex < 0)
223 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid interface index");
224
45ec7efb 225 if (*flags & ~(SD_RESOLVED_PROTOCOLS_ALL|SD_RESOLVED_NO_CNAME|ok))
51323288
LP		 226 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid flags parameter");
227
45ec7efb
LP		 228 if ((*flags & SD_RESOLVED_PROTOCOLS_ALL) == 0) /* If no protocol is enabled, enable all */
229 *flags |= SD_RESOLVED_PROTOCOLS_ALL;
51323288
LP		 230
231 return 0;
232}
233
c3be369f
LP		 234static int parse_as_address(sd_bus_message *m, int ifindex, const char *hostname, int family, uint64_t flags) {
235 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
236 _cleanup_free_ char *canonical = NULL;
237 union in_addr_union parsed;
94831eae 238 int r, ff, parsed_ifindex = 0;
c3be369f
LP		 239
240 /* Check if the hostname is actually already an IP address formatted as string. In that case just parse it,
241 * let's not attempt to look it up. */
242
94831eae 243 r = in_addr_ifindex_from_string_auto(hostname, &ff, &parsed, &parsed_ifindex);
c3be369f
LP		 244 if (r < 0) /* not an address */
245 return 0;
246
247 if (family != AF_UNSPEC && ff != family)
248 return sd_bus_reply_method_errorf(m, BUS_ERROR_NO_SUCH_RR, "The specified address is not of the requested family.");
94831eae
LP		 249 if (ifindex > 0 && parsed_ifindex > 0 && parsed_ifindex != ifindex)
250 return sd_bus_reply_method_errorf(m, BUS_ERROR_NO_SUCH_RR, "The specified address interface index does not match requested interface.");
251
252 if (parsed_ifindex > 0)
253 ifindex = parsed_ifindex;
c3be369f
LP		 254
255 r = sd_bus_message_new_method_return(m, &reply);
256 if (r < 0)
257 return r;
258
259 r = sd_bus_message_open_container(reply, 'a', "(iiay)");
260 if (r < 0)
261 return r;
262
263 r = sd_bus_message_open_container(reply, 'r', "iiay");
264 if (r < 0)
265 return r;
266
267 r = sd_bus_message_append(reply, "ii", ifindex, ff);
268 if (r < 0)
269 return r;
270
271 r = sd_bus_message_append_array(reply, 'y', &parsed, FAMILY_ADDRESS_SIZE(ff));
272 if (r < 0)
273 return r;
274
275 r = sd_bus_message_close_container(reply);
276 if (r < 0)
277 return r;
278
279 r = sd_bus_message_close_container(reply);
280 if (r < 0)
281 return r;
282
283 /* When an IP address is specified we just return it as canonical name, in order to avoid a DNS
284 * look-up. However, we reformat it to make sure it's in a truly canonical form (i.e. on IPv6 the inner
285 * omissions are always done the same way). */
94831eae 286 r = in_addr_ifindex_to_string(ff, &parsed, ifindex, &canonical);
c3be369f
LP		 287 if (r < 0)
288 return r;
289
290 r = sd_bus_message_append(reply, "st", canonical,
291 SD_RESOLVED_FLAGS_MAKE(dns_synthesize_protocol(flags), ff, true));
292 if (r < 0)
293 return r;
294
295 return sd_bus_send(sd_bus_message_get_bus(m), reply, NULL);
296}
297
19070062 298static int bus_method_resolve_hostname(sd_bus_message *message, void *userdata, sd_bus_error *error) {
23b298bc 299 _cleanup_(dns_question_unrefp) DnsQuestion *question_idna = NULL, *question_utf8 = NULL;
74b2466e
LP		 300 Manager *m = userdata;
301 const char *hostname;
51323288
LP		 302 int family, ifindex;
303 uint64_t flags;
74b2466e 304 DnsQuery *q;
74b2466e
LP		 305 int r;
306
74b2466e
LP		 307 assert(message);
308 assert(m);
309
45ec7efb
LP		 310 assert_cc(sizeof(int) == sizeof(int32_t));
311
51323288 312 r = sd_bus_message_read(message, "isit", &ifindex, &hostname, &family, &flags);
74b2466e
LP		 313 if (r < 0)
314 return r;
315
316 if (!IN_SET(family, AF_INET, AF_INET6, AF_UNSPEC))
0dd25fb9 317 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);
74b2466e 318
c3be369f 319 r = check_ifindex_flags(ifindex, &flags, SD_RESOLVED_NO_SEARCH, error);
7b9f7afc 320 if (r < 0)
45ec7efb 321 return r;
74b2466e 322
c3be369f
LP		 323 r = parse_as_address(message, ifindex, hostname, family, flags);
324 if (r != 0)
325 return r;
326
327 r = dns_name_is_valid(hostname);
51323288
LP		 328 if (r < 0)
329 return r;
c3be369f
LP		 330 if (r == 0)
331 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid hostname '%s'", hostname);
51323288 332
23b298bc
LP		 333 r = dns_question_new_address(&question_utf8, family, hostname, false);
334 if (r < 0)
335 return r;
336
337 r = dns_question_new_address(&question_idna, family, hostname, true);
ad1f3fe6 338 if (r < 0 && r != -EALREADY)
45ec7efb 339 return r;
74b2466e 340
ad1f3fe6 341 r = dns_query_new(m, &q, question_utf8, question_idna ?: question_utf8, ifindex, flags);
74b2466e
LP		 342 if (r < 0)
343 return r;
344
345 q->request = sd_bus_message_ref(message);
346 q->request_family = family;
74b2466e 347 q->complete = bus_method_resolve_hostname_complete;
011696f7 348 q->suppress_unroutable_family = family == AF_UNSPEC;
74b2466e 349
966c66e3 350 r = dns_query_bus_track(q, message);
82bd6ddd 351 if (r < 0)
45ec7efb 352 goto fail;
82bd6ddd 353
322345fd 354 r = dns_query_go(q);
45ec7efb
LP		 355 if (r < 0)
356 goto fail;
74b2466e
LP		 357
358 return 1;
45ec7efb
LP		 359
360fail:
361 dns_query_free(q);
362 return r;
74b2466e
LP		 363}
364
365static void bus_method_resolve_address_complete(DnsQuery *q) {
4afd3348 366 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
23b298bc 367 DnsQuestion *question;
45ec7efb
LP		 368 DnsResourceRecord *rr;
369 unsigned added = 0;
370 int ifindex, r;
74b2466e
LP		 371
372 assert(q);
373
ec2c5e43 374 if (q->state != DNS_TRANSACTION_SUCCESS) {
ad867662
LP		 375 r = reply_query_state(q);
376 goto finish;
377 }
74b2466e 378
95d46fca
TG		 379 r = dns_query_process_cname(q);
380 if (r == -ELOOP) {
23b298bc 381 r = sd_bus_reply_method_errorf(q->request, BUS_ERROR_CNAME_LOOP, "CNAME loop detected, or CNAME resolving disabled on '%s'", dns_query_string(q));
95d46fca
TG		 382 goto finish;
383 }
384 if (r < 0)
385 goto finish;
7588460a 386 if (r == DNS_QUERY_RESTARTED) /* This was a cname, and the query was restarted. */
95d46fca 387 return;
45ec7efb 388
ad867662
LP		 389 r = sd_bus_message_new_method_return(q->request, &reply);
390 if (r < 0)
391 goto finish;
74b2466e 392
78c6a153 393 r = sd_bus_message_open_container(reply, 'a', "(is)");
ad867662
LP		 394 if (r < 0)
395 goto finish;
74b2466e 396
23b298bc 397 question = dns_query_question_for_protocol(q, q->answer_protocol);
74b2466e 398
23b298bc 399 DNS_ANSWER_FOREACH_IFINDEX(rr, ifindex, q->answer) {
c77d2612
LP		 400 _cleanup_free_ char *normalized = NULL;
401
23b298bc
LP		 402 r = dns_question_matches_rr(question, rr, NULL);
403 if (r < 0)
404 goto finish;
405 if (r == 0)
406 continue;
74b2466e 407
7470cc4c 408 r = dns_name_normalize(rr->ptr.name, 0, &normalized);
c77d2612
LP		 409 if (r < 0)
410 goto finish;
411
412 r = sd_bus_message_append(reply, "(is)", ifindex, normalized);
23b298bc
LP		 413 if (r < 0)
414 goto finish;
415
313cefa1 416 added++;
ad867662 417 }
74b2466e 418
45ec7efb 419 if (added <= 0) {
ad867662 420 _cleanup_free_ char *ip = NULL;
74b2466e 421
164d025d
ZJS		 422 (void) in_addr_to_string(q->request_family, &q->request_address, &ip);
423 r = sd_bus_reply_method_errorf(q->request, BUS_ERROR_NO_SUCH_RR,
424 "Address '%s' does not have any RR of requested type", strnull(ip));
ad867662 425 goto finish;
74b2466e
LP		 426 }
427
ad867662
LP		 428 r = sd_bus_message_close_container(reply);
429 if (r < 0)
430 goto finish;
74b2466e 431
28830a64 432 r = sd_bus_message_append(reply, "t", SD_RESOLVED_FLAGS_MAKE(q->answer_protocol, q->answer_family, dns_query_fully_authenticated(q)));
51323288
LP		 433 if (r < 0)
434 goto finish;
435
ad867662 436 r = sd_bus_send(q->manager->bus, reply, NULL);
74b2466e
LP		 437
438finish:
2d4c5cbc 439 if (r < 0) {
da927ba9 440 log_error_errno(r, "Failed to send address reply: %m");
45ec7efb 441 sd_bus_reply_method_errno(q->request, r, NULL);
2d4c5cbc 442 }
74b2466e
LP		 443
444 dns_query_free(q);
445}
446
19070062 447static int bus_method_resolve_address(sd_bus_message *message, void *userdata, sd_bus_error *error) {
faa133f3 448 _cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
74b2466e 449 Manager *m = userdata;
faa133f3 450 int family, ifindex;
51323288 451 uint64_t flags;
74b2466e 452 const void *d;
74b2466e
LP		 453 DnsQuery *q;
454 size_t sz;
455 int r;
456
74b2466e
LP		 457 assert(message);
458 assert(m);
459
45ec7efb
LP		 460 assert_cc(sizeof(int) == sizeof(int32_t));
461
51323288 462 r = sd_bus_message_read(message, "ii", &ifindex, &family);
74b2466e
LP		 463 if (r < 0)
464 return r;
465
466 if (!IN_SET(family, AF_INET, AF_INET6))
0dd25fb9 467 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);
74b2466e
LP		 468
469 r = sd_bus_message_read_array(message, 'y', &d, &sz);
470 if (r < 0)
471 return r;
472
0dd25fb9 473 if (sz != FAMILY_ADDRESS_SIZE(family))
74b2466e
LP		 474 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address size");
475
51323288
LP		 476 r = sd_bus_message_read(message, "t", &flags);
477 if (r < 0)
478 return r;
479
45ec7efb 480 r = check_ifindex_flags(ifindex, &flags, 0, error);
faa133f3
LP		 481 if (r < 0)
482 return r;
483
45ec7efb 484 r = dns_question_new_reverse(&question, family, d);
74b2466e
LP		 485 if (r < 0)
486 return r;
487
23b298bc 488 r = dns_query_new(m, &q, question, question, ifindex, flags|SD_RESOLVED_NO_SEARCH);
74b2466e
LP		 489 if (r < 0)
490 return r;
491
492 q->request = sd_bus_message_ref(message);
493 q->request_family = family;
494 memcpy(&q->request_address, d, sz);
495 q->complete = bus_method_resolve_address_complete;
496
966c66e3 497 r = dns_query_bus_track(q, message);
82bd6ddd 498 if (r < 0)
45ec7efb 499 goto fail;
82bd6ddd 500
322345fd 501 r = dns_query_go(q);
45ec7efb
LP		 502 if (r < 0)
503 goto fail;
74b2466e
LP		 504
505 return 1;
45ec7efb
LP		 506
507fail:
508 dns_query_free(q);
509 return r;
510}
511
512static int bus_message_append_rr(sd_bus_message *m, DnsResourceRecord *rr, int ifindex) {
45ec7efb
LP		 513 int r;
514
515 assert(m);
516 assert(rr);
517
518 r = sd_bus_message_open_container(m, 'r', "iqqay");
519 if (r < 0)
520 return r;
521
522 r = sd_bus_message_append(m, "iqq",
523 ifindex,
524 rr->key->class,
525 rr->key->type);
526 if (r < 0)
527 return r;
528
4e2d538f 529 r = dns_resource_record_to_wire_format(rr, false);
45ec7efb
LP		 530 if (r < 0)
531 return r;
532
4e2d538f 533 r = sd_bus_message_append_array(m, 'y', rr->wire_format, rr->wire_format_size);
45ec7efb
LP		 534 if (r < 0)
535 return r;
536
537 return sd_bus_message_close_container(m);
74b2466e
LP		 538}
539
2d4c5cbc 540static void bus_method_resolve_record_complete(DnsQuery *q) {
4afd3348 541 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
23b298bc
LP		 542 DnsResourceRecord *rr;
543 DnsQuestion *question;
45ec7efb 544 unsigned added = 0;
23b298bc 545 int ifindex;
2d4c5cbc
LP		 546 int r;
547
548 assert(q);
549
ec2c5e43 550 if (q->state != DNS_TRANSACTION_SUCCESS) {
2d4c5cbc
LP		 551 r = reply_query_state(q);
552 goto finish;
553 }
554
45ec7efb
LP		 555 r = dns_query_process_cname(q);
556 if (r == -ELOOP) {
23b298bc 557 r = sd_bus_reply_method_errorf(q->request, BUS_ERROR_CNAME_LOOP, "CNAME loop detected, or CNAME resolving disabled on '%s'", dns_query_string(q));
45ec7efb
LP		 558 goto finish;
559 }
560 if (r < 0)
561 goto finish;
7588460a 562 if (r == DNS_QUERY_RESTARTED) /* This was a cname, and the query was restarted. */
45ec7efb
LP		 563 return;
564
2d4c5cbc
LP		 565 r = sd_bus_message_new_method_return(q->request, &reply);
566 if (r < 0)
567 goto finish;
568
78c6a153 569 r = sd_bus_message_open_container(reply, 'a', "(iqqay)");
2d4c5cbc
LP		 570 if (r < 0)
571 goto finish;
572
23b298bc 573 question = dns_query_question_for_protocol(q, q->answer_protocol);
2d4c5cbc 574
23b298bc
LP		 575 DNS_ANSWER_FOREACH_IFINDEX(rr, ifindex, q->answer) {
576 r = dns_question_matches_rr(question, rr, NULL);
577 if (r < 0)
578 goto finish;
579 if (r == 0)
580 continue;
2d4c5cbc 581
23b298bc
LP		 582 r = bus_message_append_rr(reply, rr, ifindex);
583 if (r < 0)
584 goto finish;
2d4c5cbc 585
313cefa1 586 added++;
2d4c5cbc
LP		 587 }
588
589 if (added <= 0) {
23b298bc 590 r = sd_bus_reply_method_errorf(q->request, BUS_ERROR_NO_SUCH_RR, "Name '%s' does not have any RR of the requested type", dns_query_string(q));
2d4c5cbc
LP		 591 goto finish;
592 }
593
594 r = sd_bus_message_close_container(reply);
595 if (r < 0)
596 goto finish;
597
28830a64 598 r = sd_bus_message_append(reply, "t", SD_RESOLVED_FLAGS_MAKE(q->answer_protocol, q->answer_family, dns_query_fully_authenticated(q)));
51323288
LP		 599 if (r < 0)
600 goto finish;
601
2d4c5cbc
LP		 602 r = sd_bus_send(q->manager->bus, reply, NULL);
603
604finish:
605 if (r < 0) {
da927ba9 606 log_error_errno(r, "Failed to send record reply: %m");
45ec7efb 607 sd_bus_reply_method_errno(q->request, r, NULL);
2d4c5cbc
LP		 608 }
609
610 dns_query_free(q);
611}
612
19070062 613static int bus_method_resolve_record(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d4c5cbc
LP		 614 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
615 _cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
2d4c5cbc 616 Manager *m = userdata;
2d4c5cbc
LP		 617 uint16_t class, type;
618 const char *name;
51323288
LP		 619 int r, ifindex;
620 uint64_t flags;
621 DnsQuery *q;
2d4c5cbc 622
2d4c5cbc
LP		 623 assert(message);
624 assert(m);
625
45ec7efb
LP		 626 assert_cc(sizeof(int) == sizeof(int32_t));
627
51323288 628 r = sd_bus_message_read(message, "isqqt", &ifindex, &name, &class, &type, &flags);
2d4c5cbc
LP		 629 if (r < 0)
630 return r;
631
45ec7efb 632 r = dns_name_is_valid(name);
7b9f7afc 633 if (r < 0)
45ec7efb
LP		 634 return r;
635 if (r == 0)
7b9f7afc
LP		 636 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid name '%s'", name);
637
c463eb78 638 if (!dns_type_is_valid_query(type))
eee026a7 639 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Specified resource record type %" PRIu16 " may not be used in a query.", type);
6ebd1e33
LP		 640 if (dns_type_is_zone_transer(type))
641 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Zone transfers not permitted via this programming interface.");
d0129ddb 642 if (dns_type_is_obsolete(type))
eee026a7 643 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Specified DNS resource record type %" PRIu16 " is obsolete.", type);
c463eb78 644
45ec7efb 645 r = check_ifindex_flags(ifindex, &flags, 0, error);
51323288
LP		 646 if (r < 0)
647 return r;
648
2d4c5cbc
LP		 649 question = dns_question_new(1);
650 if (!question)
651 return -ENOMEM;
652
653 key = dns_resource_key_new(class, type, name);
654 if (!key)
655 return -ENOMEM;
656
657 r = dns_question_add(question, key);
658 if (r < 0)
659 return r;
660
23b298bc 661 r = dns_query_new(m, &q, question, question, ifindex, flags|SD_RESOLVED_NO_SEARCH);
2d4c5cbc
LP		 662 if (r < 0)
663 return r;
664
17c8de63
LP		 665 /* Let's request that the TTL is fixed up for locally cached entries, after all we return it in the wire format
666 * blob */
667 q->clamp_ttl = true;
668
2d4c5cbc 669 q->request = sd_bus_message_ref(message);
2d4c5cbc
LP		 670 q->complete = bus_method_resolve_record_complete;
671
966c66e3 672 r = dns_query_bus_track(q, message);
82bd6ddd 673 if (r < 0)
45ec7efb 674 goto fail;
82bd6ddd 675
2d4c5cbc 676 r = dns_query_go(q);
45ec7efb
LP		 677 if (r < 0)
678 goto fail;
679
680 return 1;
681
682fail:
683 dns_query_free(q);
684 return r;
685}
686
687static int append_srv(DnsQuery *q, sd_bus_message *reply, DnsResourceRecord *rr) {
688 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *canonical = NULL;
c77d2612 689 _cleanup_free_ char *normalized = NULL;
45ec7efb
LP		 690 DnsQuery *aux;
691 int r;
692
693 assert(q);
694 assert(reply);
695 assert(rr);
696 assert(rr->key);
697
698 if (rr->key->type != DNS_TYPE_SRV)
699 return 0;
700
701 if ((q->flags & SD_RESOLVED_NO_ADDRESS) == 0) {
702 /* First, let's see if we could find an appropriate A or AAAA
703 * record for the SRV record */
704 LIST_FOREACH(auxiliary_queries, aux, q->auxiliary_queries) {
705 DnsResourceRecord *zz;
23b298bc 706 DnsQuestion *question;
45ec7efb
LP		 707
708 if (aux->state != DNS_TRANSACTION_SUCCESS)
709 continue;
710 if (aux->auxiliary_result != 0)
711 continue;
712
23b298bc
LP		 713 question = dns_query_question_for_protocol(aux, aux->answer_protocol);
714
715 r = dns_name_equal(dns_question_first_name(question), rr->srv.name);
45ec7efb
LP		 716 if (r < 0)
717 return r;
718 if (r == 0)
719 continue;
720
721 DNS_ANSWER_FOREACH(zz, aux->answer) {
722
23b298bc 723 r = dns_question_matches_rr(question, zz, NULL);
45ec7efb
LP		 724 if (r < 0)
725 return r;
726 if (r == 0)
727 continue;
728
729 canonical = dns_resource_record_ref(zz);
730 break;
731 }
732
733 if (canonical)
734 break;
735 }
736
737 /* Is there are successful A/AAAA lookup for this SRV RR? If not, don't add it */
738 if (!canonical)
739 return 0;
740 }
741
742 r = sd_bus_message_open_container(reply, 'r', "qqqsa(iiay)s");
743 if (r < 0)
744 return r;
745
7470cc4c 746 r = dns_name_normalize(rr->srv.name, 0, &normalized);
c77d2612
LP		 747 if (r < 0)
748 return r;
749
45ec7efb
LP		 750 r = sd_bus_message_append(
751 reply,
752 "qqqs",
c77d2612 753 rr->srv.priority, rr->srv.weight, rr->srv.port, normalized);
45ec7efb
LP		 754 if (r < 0)
755 return r;
756
757 r = sd_bus_message_open_container(reply, 'a', "(iiay)");
758 if (r < 0)
759 return r;
760
761 if ((q->flags & SD_RESOLVED_NO_ADDRESS) == 0) {
762 LIST_FOREACH(auxiliary_queries, aux, q->auxiliary_queries) {
763 DnsResourceRecord *zz;
23b298bc 764 DnsQuestion *question;
45ec7efb
LP		 765 int ifindex;
766
767 if (aux->state != DNS_TRANSACTION_SUCCESS)
768 continue;
769 if (aux->auxiliary_result != 0)
770 continue;
771
23b298bc
LP		 772 question = dns_query_question_for_protocol(aux, aux->answer_protocol);
773
774 r = dns_name_equal(dns_question_first_name(question), rr->srv.name);
45ec7efb
LP		 775 if (r < 0)
776 return r;
777 if (r == 0)
778 continue;
779
780 DNS_ANSWER_FOREACH_IFINDEX(zz, ifindex, aux->answer) {
781
23b298bc 782 r = dns_question_matches_rr(question, zz, NULL);
45ec7efb
LP		 783 if (r < 0)
784 return r;
785 if (r == 0)
786 continue;
787
788 r = append_address(reply, zz, ifindex);
789 if (r < 0)
790 return r;
791 }
792 }
793 }
794
795 r = sd_bus_message_close_container(reply);
796 if (r < 0)
797 return r;
798
c77d2612
LP		 799 if (canonical) {
800 normalized = mfree(normalized);
801
7470cc4c 802 r = dns_name_normalize(dns_resource_key_name(canonical->key), 0, &normalized);
c77d2612
LP		 803 if (r < 0)
804 return r;
805 }
806
45ec7efb
LP		 807 /* Note that above we appended the hostname as encoded in the
808 * SRV, and here the canonical hostname this maps to. */
c77d2612 809 r = sd_bus_message_append(reply, "s", normalized);
45ec7efb
LP		 810 if (r < 0)
811 return r;
812
813 r = sd_bus_message_close_container(reply);
814 if (r < 0)
815 return r;
816
817 return 1;
818}
819
820static int append_txt(sd_bus_message *reply, DnsResourceRecord *rr) {
821 DnsTxtItem *i;
822 int r;
823
824 assert(reply);
825 assert(rr);
826 assert(rr->key);
827
828 if (rr->key->type != DNS_TYPE_TXT)
829 return 0;
830
831 LIST_FOREACH(items, i, rr->txt.items) {
832
833 if (i->length <= 0)
834 continue;
835
836 r = sd_bus_message_append_array(reply, 'y', i->data, i->length);
837 if (r < 0)
838 return r;
839 }
840
841 return 1;
842}
843
844static void resolve_service_all_complete(DnsQuery *q) {
845 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *canonical = NULL;
846 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
847 _cleanup_free_ char *name = NULL, *type = NULL, *domain = NULL;
23b298bc
LP		 848 DnsQuestion *question;
849 DnsResourceRecord *rr;
850 unsigned added = 0;
45ec7efb 851 DnsQuery *aux;
45ec7efb
LP		 852 int r;
853
854 assert(q);
855
856 if (q->block_all_complete > 0)
857 return;
858
859 if ((q->flags & SD_RESOLVED_NO_ADDRESS) == 0) {
860 DnsQuery *bad = NULL;
861 bool have_success = false;
862
863 LIST_FOREACH(auxiliary_queries, aux, q->auxiliary_queries) {
864
865 switch (aux->state) {
866
867 case DNS_TRANSACTION_PENDING:
868 /* If an auxiliary query is still pending, let's wait */
869 return;
870
871 case DNS_TRANSACTION_SUCCESS:
872 if (aux->auxiliary_result == 0)
873 have_success = true;
874 else
875 bad = aux;
876 break;
877
878 default:
879 bad = aux;
880 break;
881 }
882 }
883
884 if (!have_success) {
885 /* We can only return one error, hence pick the last error we encountered */
886
887 assert(bad);
888
889 if (bad->state == DNS_TRANSACTION_SUCCESS) {
890 assert(bad->auxiliary_result != 0);
891
892 if (bad->auxiliary_result == -ELOOP) {
23b298bc 893 r = sd_bus_reply_method_errorf(q->request, BUS_ERROR_CNAME_LOOP, "CNAME loop detected, or CNAME resolving disabled on '%s'", dns_query_string(bad));
45ec7efb
LP		 894 goto finish;
895 }
896
897 r = bad->auxiliary_result;
898 goto finish;
899 }
900
901 r = reply_query_state(bad);
902 goto finish;
903 }
904 }
905
906 r = sd_bus_message_new_method_return(q->request, &reply);
907 if (r < 0)
908 goto finish;
909
910 r = sd_bus_message_open_container(reply, 'a', "(qqqsa(iiay)s)");
911 if (r < 0)
912 goto finish;
913
23b298bc
LP		 914 question = dns_query_question_for_protocol(q, q->answer_protocol);
915 DNS_ANSWER_FOREACH(rr, q->answer) {
916 r = dns_question_matches_rr(question, rr, NULL);
917 if (r < 0)
918 goto finish;
919 if (r == 0)
920 continue;
45ec7efb 921
23b298bc
LP		 922 r = append_srv(q, reply, rr);
923 if (r < 0)
924 goto finish;
925 if (r == 0) /* not an SRV record */
926 continue;
45ec7efb 927
23b298bc
LP		 928 if (!canonical)
929 canonical = dns_resource_record_ref(rr);
45ec7efb 930
23b298bc 931 added++;
45ec7efb
LP		 932 }
933
934 if (added <= 0) {
23b298bc 935 r = sd_bus_reply_method_errorf(q->request, BUS_ERROR_NO_SUCH_RR, "'%s' does not have any RR of the requested type", dns_query_string(q));
45ec7efb
LP		 936 goto finish;
937 }
938
939 r = sd_bus_message_close_container(reply);
940 if (r < 0)
941 goto finish;
942
943 r = sd_bus_message_open_container(reply, 'a', "ay");
944 if (r < 0)
945 goto finish;
946
23b298bc
LP		 947 DNS_ANSWER_FOREACH(rr, q->answer) {
948 r = dns_question_matches_rr(question, rr, NULL);
949 if (r < 0)
950 goto finish;
951 if (r == 0)
952 continue;
45ec7efb 953
23b298bc
LP		 954 r = append_txt(reply, rr);
955 if (r < 0)
956 goto finish;
45ec7efb
LP		 957 }
958
959 r = sd_bus_message_close_container(reply);
960 if (r < 0)
961 goto finish;
962
963 assert(canonical);
1c02e7ba 964 r = dns_service_split(dns_resource_key_name(canonical->key), &name, &type, &domain);
45ec7efb
LP		 965 if (r < 0)
966 goto finish;
967
968 r = sd_bus_message_append(
969 reply,
970 "ssst",
971 name, type, domain,
28830a64 972 SD_RESOLVED_FLAGS_MAKE(q->answer_protocol, q->answer_family, dns_query_fully_authenticated(q)));
45ec7efb
LP		 973 if (r < 0)
974 goto finish;
975
976 r = sd_bus_send(q->manager->bus, reply, NULL);
977
978finish:
979 if (r < 0) {
980 log_error_errno(r, "Failed to send service reply: %m");
981 sd_bus_reply_method_errno(q->request, r, NULL);
982 }
983
984 dns_query_free(q);
985}
986
987static void resolve_service_hostname_complete(DnsQuery *q) {
988 int r;
989
990 assert(q);
991 assert(q->auxiliary_for);
992
993 if (q->state != DNS_TRANSACTION_SUCCESS) {
994 resolve_service_all_complete(q->auxiliary_for);
995 return;
996 }
997
998 r = dns_query_process_cname(q);
7588460a 999 if (r == DNS_QUERY_RESTARTED) /* This was a cname, and the query was restarted. */
45ec7efb
LP		 1000 return;
1001
1002 /* This auxiliary lookup is finished or failed, let's see if all are finished now. */
1003 q->auxiliary_result = r;
1004 resolve_service_all_complete(q->auxiliary_for);
1005}
1006
1007static int resolve_service_hostname(DnsQuery *q, DnsResourceRecord *rr, int ifindex) {
1008 _cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
1009 DnsQuery *aux;
1010 int r;
1011
1012 assert(q);
1013 assert(rr);
1014 assert(rr->key);
1015 assert(rr->key->type == DNS_TYPE_SRV);
1016
1017 /* OK, we found an SRV record for the service. Let's resolve
1018 * the hostname included in it */
1019
23b298bc 1020 r = dns_question_new_address(&question, q->request_family, rr->srv.name, false);
45ec7efb
LP		 1021 if (r < 0)
1022 return r;
1023
23b298bc 1024 r = dns_query_new(q->manager, &aux, question, question, ifindex, q->flags|SD_RESOLVED_NO_SEARCH);
45ec7efb
LP		 1025 if (r < 0)
1026 return r;
1027
1028 aux->request_family = q->request_family;
1029 aux->complete = resolve_service_hostname_complete;
1030
1031 r = dns_query_make_auxiliary(aux, q);
1032 if (r == -EAGAIN) {
1033 /* Too many auxiliary lookups? If so, don't complain,
1034 * let's just not add this one, we already have more
1035 * than enough */
1036
1037 dns_query_free(aux);
1038 return 0;
1039 }
1040 if (r < 0)
1041 goto fail;
1042
1043 /* Note that auxiliary queries do not track the original bus
1044 * client, only the primary request does that. */
1045
1046 r = dns_query_go(aux);
1047 if (r < 0)
1048 goto fail;
1049
1050 return 1;
1051
1052fail:
1053 dns_query_free(aux);
1054 return r;
1055}
1056
1057static void bus_method_resolve_service_complete(DnsQuery *q) {
23b298bc
LP		 1058 bool has_root_domain = false;
1059 DnsResourceRecord *rr;
1060 DnsQuestion *question;
45ec7efb 1061 unsigned found = 0;
23b298bc 1062 int ifindex, r;
45ec7efb
LP		 1063
1064 assert(q);
1065
1066 if (q->state != DNS_TRANSACTION_SUCCESS) {
1067 r = reply_query_state(q);
1068 goto finish;
1069 }
1070
1071 r = dns_query_process_cname(q);
1072 if (r == -ELOOP) {
23b298bc 1073 r = sd_bus_reply_method_errorf(q->request, BUS_ERROR_CNAME_LOOP, "CNAME loop detected, or CNAME resolving disabled on '%s'", dns_query_string(q));
45ec7efb
LP		 1074 goto finish;
1075 }
1076 if (r < 0)
1077 goto finish;
7588460a 1078 if (r == DNS_QUERY_RESTARTED) /* This was a cname, and the query was restarted. */
45ec7efb
LP		 1079 return;
1080
23b298bc 1081 question = dns_query_question_for_protocol(q, q->answer_protocol);
45ec7efb 1082
23b298bc
LP		 1083 DNS_ANSWER_FOREACH_IFINDEX(rr, ifindex, q->answer) {
1084 r = dns_question_matches_rr(question, rr, NULL);
1085 if (r < 0)
1086 goto finish;
1087 if (r == 0)
1088 continue;
45ec7efb 1089
23b298bc
LP		 1090 if (rr->key->type != DNS_TYPE_SRV)
1091 continue;
9a1f0c28 1092
23b298bc
LP		 1093 if (dns_name_is_root(rr->srv.name)) {
1094 has_root_domain = true;
1095 continue;
1096 }
45ec7efb 1097
23b298bc 1098 if ((q->flags & SD_RESOLVED_NO_ADDRESS) == 0) {
313cefa1 1099 q->block_all_complete++;
23b298bc 1100 r = resolve_service_hostname(q, rr, ifindex);
313cefa1 1101 q->block_all_complete--;
45ec7efb 1102
23b298bc
LP		 1103 if (r < 0)
1104 goto finish;
45ec7efb 1105 }
9a1f0c28 1106
23b298bc
LP		 1107 found++;
1108 }
9a1f0c28 1109
23b298bc
LP		 1110 if (has_root_domain && found <= 0) {
1111 /* If there's exactly one SRV RR and it uses
1112 * the root domain as host name, then the
1113 * service is explicitly not offered on the
1114 * domain. Report this as a recognizable
1115 * error. See RFC 2782, Section "Usage
1116 * Rules". */
1117 r = sd_bus_reply_method_errorf(q->request, BUS_ERROR_NO_SUCH_SERVICE, "'%s' does not provide the requested service", dns_query_string(q));
1118 goto finish;
45ec7efb
LP		 1119 }
1120
1121 if (found <= 0) {
23b298bc 1122 r = sd_bus_reply_method_errorf(q->request, BUS_ERROR_NO_SUCH_RR, "'%s' does not have any RR of the requested type", dns_query_string(q));
45ec7efb
LP		 1123 goto finish;
1124 }
1125
1126 /* Maybe we are already finished? check now... */
1127 resolve_service_all_complete(q);
1128 return;
1129
1130finish:
2d4c5cbc 1131 if (r < 0) {
45ec7efb
LP		 1132 log_error_errno(r, "Failed to send service reply: %m");
1133 sd_bus_reply_method_errno(q->request, r, NULL);
1134 }
1135
1136 dns_query_free(q);
1137}
1138
1139static int bus_method_resolve_service(sd_bus_message *message, void *userdata, sd_bus_error *error) {
23b298bc
LP		 1140 _cleanup_(dns_question_unrefp) DnsQuestion *question_idna = NULL, *question_utf8 = NULL;
1141 const char *name, *type, *domain;
45ec7efb
LP		 1142 Manager *m = userdata;
1143 int family, ifindex;
1144 uint64_t flags;
1145 DnsQuery *q;
1146 int r;
1147
1148 assert(message);
1149 assert(m);
1150
1151 assert_cc(sizeof(int) == sizeof(int32_t));
1152
1153 r = sd_bus_message_read(message, "isssit", &ifindex, &name, &type, &domain, &family, &flags);
1154 if (r < 0)
2d4c5cbc 1155 return r;
45ec7efb
LP		 1156
1157 if (!IN_SET(family, AF_INET, AF_INET6, AF_UNSPEC))
1158 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);
1159
1160 if (isempty(name))
1161 name = NULL;
23b298bc
LP		 1162 else if (!dns_service_name_is_valid(name))
1163 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid service name '%s'", name);
2d4c5cbc 1164
45ec7efb
LP		 1165 if (isempty(type))
1166 type = NULL;
7e8131e9
LP		 1167 else if (!dns_srv_type_is_valid(type))
1168 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid SRV service type '%s'", type);
45ec7efb
LP		 1169
1170 r = dns_name_is_valid(domain);
1171 if (r < 0)
1172 return r;
1173 if (r == 0)
1174 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid domain '%s'", domain);
1175
1176 if (name && !type)
1177 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Service name cannot be specified without service type.");
1178
1179 r = check_ifindex_flags(ifindex, &flags, SD_RESOLVED_NO_TXT|SD_RESOLVED_NO_ADDRESS, error);
1180 if (r < 0)
1181 return r;
1182
23b298bc
LP		 1183 r = dns_question_new_service(&question_utf8, name, type, domain, !(flags & SD_RESOLVED_NO_TXT), false);
1184 if (r < 0)
1185 return r;
45ec7efb 1186
23b298bc 1187 r = dns_question_new_service(&question_idna, name, type, domain, !(flags & SD_RESOLVED_NO_TXT), true);
45ec7efb
LP		 1188 if (r < 0)
1189 return r;
1190
23b298bc 1191 r = dns_query_new(m, &q, question_utf8, question_idna, ifindex, flags|SD_RESOLVED_NO_SEARCH);
45ec7efb
LP		 1192 if (r < 0)
1193 return r;
1194
1195 q->request = sd_bus_message_ref(message);
1196 q->request_family = family;
1197 q->complete = bus_method_resolve_service_complete;
1198
1199 r = dns_query_bus_track(q, message);
1200 if (r < 0)
1201 goto fail;
1202
1203 r = dns_query_go(q);
1204 if (r < 0)
1205 goto fail;
1206
2d4c5cbc 1207 return 1;
45ec7efb
LP		 1208
1209fail:
1210 dns_query_free(q);
1211 return r;
2d4c5cbc
LP		 1212}
1213
3abaabda 1214int bus_dns_server_append(sd_bus_message *reply, DnsServer *s, bool with_ifindex) {
7f220d94
LP		 1215 int r;
1216
1217 assert(reply);
b7ac92cd
YW		 1218
1219 if (!s) {
1220 if (with_ifindex)
1221 return sd_bus_message_append(reply, "(iiay)", 0, AF_UNSPEC, 0);
1222 else
1223 return sd_bus_message_append(reply, "(iay)", AF_UNSPEC, 0);
1224 }
7f220d94 1225
3abaabda 1226 r = sd_bus_message_open_container(reply, 'r', with_ifindex ? "iiay" : "iay");
7f220d94
LP		 1227 if (r < 0)
1228 return r;
1229
3abaabda 1230 if (with_ifindex) {
2817157b 1231 r = sd_bus_message_append(reply, "i", dns_server_ifindex(s));
3abaabda
LP		 1232 if (r < 0)
1233 return r;
1234 }
1235
1236 r = sd_bus_message_append(reply, "i", s->family);
7f220d94
LP		 1237 if (r < 0)
1238 return r;
1239
1240 r = sd_bus_message_append_array(reply, 'y', &s->address, FAMILY_ADDRESS_SIZE(s->family));
1241 if (r < 0)
1242 return r;
1243
1244 return sd_bus_message_close_container(reply);
1245}
1246
1247static int bus_property_get_dns_servers(
1248 sd_bus *bus,
1249 const char *path,
1250 const char *interface,
1251 const char *property,
1252 sd_bus_message *reply,
1253 void *userdata,
1254 sd_bus_error *error) {
1255
1256 Manager *m = userdata;
7f220d94
LP		 1257 DnsServer *s;
1258 Iterator i;
1259 Link *l;
1260 int r;
1261
1262 assert(reply);
1263 assert(m);
1264
1265 r = sd_bus_message_open_container(reply, 'a', "(iiay)");
1266 if (r < 0)
1267 return r;
1268
1269 LIST_FOREACH(servers, s, m->dns_servers) {
3abaabda 1270 r = bus_dns_server_append(reply, s, true);
7f220d94
LP		 1271 if (r < 0)
1272 return r;
7f220d94
LP		 1273 }
1274
1275 HASHMAP_FOREACH(l, m->links, i) {
1276 LIST_FOREACH(servers, s, l->dns_servers) {
3abaabda 1277 r = bus_dns_server_append(reply, s, true);
7f220d94
LP		 1278 if (r < 0)
1279 return r;
7f220d94
LP		 1280 }
1281 }
1282
ad32ac53
YW		 1283 return sd_bus_message_close_container(reply);
1284}
1285
1286static int bus_property_get_fallback_dns_servers(
1287 sd_bus *bus,
1288 const char *path,
1289 const char *interface,
1290 const char *property,
1291 sd_bus_message *reply,
1292 void *userdata,
1293 sd_bus_error *error) {
1294
1295 DnsServer *s, **f = userdata;
1296 int r;
1297
1298 assert(reply);
1299 assert(f);
1300
1301 r = sd_bus_message_open_container(reply, 'a', "(iiay)");
1302 if (r < 0)
1303 return r;
1304
1305 LIST_FOREACH(servers, s, *f) {
1306 r = bus_dns_server_append(reply, s, true);
1307 if (r < 0)
1308 return r;
7f220d94
LP		 1309 }
1310
1311 return sd_bus_message_close_container(reply);
1312}
1313
b7ac92cd
YW		 1314static int bus_property_get_current_dns_server(
1315 sd_bus *bus,
1316 const char *path,
1317 const char *interface,
1318 const char *property,
1319 sd_bus_message *reply,
1320 void *userdata,
1321 sd_bus_error *error) {
1322
1323 DnsServer *s;
1324
1325 assert(reply);
1326 assert(userdata);
1327
1328 s = *(DnsServer **) userdata;
1329
1330 return bus_dns_server_append(reply, s, true);
1331}
1332
ee116b54 1333static int bus_property_get_domains(
7f220d94
LP		 1334 sd_bus *bus,
1335 const char *path,
1336 const char *interface,
1337 const char *property,
1338 sd_bus_message *reply,
1339 void *userdata,
1340 sd_bus_error *error) {
1341
1342 Manager *m = userdata;
1343 DnsSearchDomain *d;
1344 Iterator i;
1345 Link *l;
1346 int r;
1347
1348 assert(reply);
1349 assert(m);
1350
ad44b56b 1351 r = sd_bus_message_open_container(reply, 'a', "(isb)");
7f220d94
LP		 1352 if (r < 0)
1353 return r;
1354
1355 LIST_FOREACH(domains, d, m->search_domains) {
ad44b56b 1356 r = sd_bus_message_append(reply, "(isb)", 0, d->name, d->route_only);
7f220d94
LP		 1357 if (r < 0)
1358 return r;
1359 }
1360
1361 HASHMAP_FOREACH(l, m->links, i) {
1362 LIST_FOREACH(domains, d, l->search_domains) {
ad44b56b 1363 r = sd_bus_message_append(reply, "(isb)", l->ifindex, d->name, d->route_only);
7f220d94
LP		 1364 if (r < 0)
1365 return r;
1366 }
1367 }
1368
1369 return sd_bus_message_close_container(reply);
1370}
1371
a150ff5e
LP		 1372static int bus_property_get_transaction_statistics(
1373 sd_bus *bus,
1374 const char *path,
1375 const char *interface,
1376 const char *property,
1377 sd_bus_message *reply,
1378 void *userdata,
1379 sd_bus_error *error) {
1380
1381 Manager *m = userdata;
1382
1383 assert(reply);
1384 assert(m);
1385
1386 return sd_bus_message_append(reply, "(tt)",
1387 (uint64_t) hashmap_size(m->dns_transactions),
1388 (uint64_t) m->n_transactions_total);
1389}
1390
1391static int bus_property_get_cache_statistics(
1392 sd_bus *bus,
1393 const char *path,
1394 const char *interface,
1395 const char *property,
1396 sd_bus_message *reply,
1397 void *userdata,
1398 sd_bus_error *error) {
1399
1400 uint64_t size = 0, hit = 0, miss = 0;
1401 Manager *m = userdata;
1402 DnsScope *s;
1403
1404 assert(reply);
1405 assert(m);
1406
1407 LIST_FOREACH(scopes, s, m->dns_scopes) {
1408 size += dns_cache_size(&s->cache);
1409 hit += s->cache.n_hit;
1410 miss += s->cache.n_miss;
1411 }
1412
1413 return sd_bus_message_append(reply, "(ttt)", size, hit, miss);
1414}
1415
1416static int bus_property_get_dnssec_statistics(
1417 sd_bus *bus,
1418 const char *path,
1419 const char *interface,
1420 const char *property,
1421 sd_bus_message *reply,
1422 void *userdata,
1423 sd_bus_error *error) {
1424
1425 Manager *m = userdata;
1426
1427 assert(reply);
1428 assert(m);
1429
1430 return sd_bus_message_append(reply, "(tttt)",
59c5b597
LP		 1431 (uint64_t) m->n_dnssec_verdict[DNSSEC_SECURE],
1432 (uint64_t) m->n_dnssec_verdict[DNSSEC_INSECURE],
1433 (uint64_t) m->n_dnssec_verdict[DNSSEC_BOGUS],
1434 (uint64_t) m->n_dnssec_verdict[DNSSEC_INDETERMINATE]);
a150ff5e
LP		 1435}
1436
476798b1
LP		 1437static int bus_property_get_ntas(
1438 sd_bus *bus,
1439 const char *path,
1440 const char *interface,
1441 const char *property,
1442 sd_bus_message *reply,
1443 void *userdata,
1444 sd_bus_error *error) {
1445
1446 Manager *m = userdata;
1447 const char *domain;
1448 Iterator i;
1449 int r;
1450
1451 assert(reply);
1452 assert(m);
1453
1454 r = sd_bus_message_open_container(reply, 'a', "s");
1455 if (r < 0)
1456 return r;
1457
1458 SET_FOREACH(domain, m->trust_anchor.negative_by_name, i) {
1459 r = sd_bus_message_append(reply, "s", domain);
1460 if (r < 0)
1461 return r;
1462 }
1463
1464 return sd_bus_message_close_container(reply);
1465}
1466
7ed1565a 1467static BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_dns_stub_listener_mode, dns_stub_listener_mode, DnsStubListenerMode);
acd380c4
YW		 1468static BUS_DEFINE_PROPERTY_GET(bus_property_get_dnssec_supported, "b", Manager, manager_dnssec_supported);
1469static BUS_DEFINE_PROPERTY_GET2(bus_property_get_dnssec_mode, "s", Manager, manager_get_dnssec_mode, dnssec_mode_to_string);
c9299be2 1470static BUS_DEFINE_PROPERTY_GET2(bus_property_get_dns_over_tls_mode, "s", Manager, manager_get_dns_over_tls_mode, dns_over_tls_mode_to_string);
7ed1565a 1471
a150ff5e
LP		 1472static int bus_method_reset_statistics(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1473 Manager *m = userdata;
1474 DnsScope *s;
1475
1476 assert(message);
1477 assert(m);
1478
1479 LIST_FOREACH(scopes, s, m->dns_scopes)
1480 s->cache.n_hit = s->cache.n_miss = 0;
1481
1482 m->n_transactions_total = 0;
59c5b597 1483 zero(m->n_dnssec_verdict);
a150ff5e
LP		 1484
1485 return sd_bus_reply_method_return(message, NULL);
1486}
1487
3abaabda 1488static int get_any_link(Manager *m, int ifindex, Link **ret, sd_bus_error *error) {
97e5d693
LP		 1489 Link *l;
1490
1491 assert(m);
3abaabda 1492 assert(ret);
97e5d693
LP		 1493
1494 if (ifindex <= 0)
1495 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid interface index");
1496
1497 l = hashmap_get(m->links, INT_TO_PTR(ifindex));
1498 if (!l)
1499 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %i not known", ifindex);
3abaabda
LP		 1500
1501 *ret = l;
1502 return 0;
1503}
1504
d2ec6608 1505static int call_link_method(Manager *m, sd_bus_message *message, sd_bus_message_handler_t handler, sd_bus_error *error) {
97e5d693 1506 int ifindex, r;
97e5d693
LP		 1507 Link *l;
1508
97e5d693 1509 assert(m);
97e5d693 1510 assert(message);
d2ec6608 1511 assert(handler);
97e5d693 1512
d2ec6608 1513 assert_cc(sizeof(int) == sizeof(int32_t));
97e5d693
LP		 1514 r = sd_bus_message_read(message, "i", &ifindex);
1515 if (r < 0)
1516 return r;
1517
04b764bf 1518 r = get_any_link(m, ifindex, &l, error);
97e5d693
LP		 1519 if (r < 0)
1520 return r;
1521
d2ec6608
LP		 1522 return handler(message, l, error);
1523}
97e5d693 1524
d2ec6608
LP		 1525static int bus_method_set_link_dns_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1526 return call_link_method(userdata, message, bus_link_method_set_dns_servers, error);
1527}
97e5d693 1528
ee116b54
LP		 1529static int bus_method_set_link_domains(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1530 return call_link_method(userdata, message, bus_link_method_set_domains, error);
97e5d693
LP		 1531}
1532
77673795
LP		 1533static int bus_method_set_link_default_route(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1534 return call_link_method(userdata, message, bus_link_method_set_default_route, error);
1535}
1536
97e5d693 1537static int bus_method_set_link_llmnr(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d2ec6608 1538 return call_link_method(userdata, message, bus_link_method_set_llmnr, error);
97e5d693
LP		 1539}
1540
1541static int bus_method_set_link_mdns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d2ec6608 1542 return call_link_method(userdata, message, bus_link_method_set_mdns, error);
97e5d693
LP		 1543}
1544
c9299be2
IT		 1545static int bus_method_set_link_dns_over_tls(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1546 return call_link_method(userdata, message, bus_link_method_set_dns_over_tls, error);
b761a107
YW		 1547}
1548
97e5d693 1549static int bus_method_set_link_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d2ec6608 1550 return call_link_method(userdata, message, bus_link_method_set_dnssec, error);
97e5d693
LP		 1551}
1552
1553static int bus_method_set_link_dnssec_negative_trust_anchors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d2ec6608 1554 return call_link_method(userdata, message, bus_link_method_set_dnssec_negative_trust_anchors, error);
97e5d693
LP		 1555}
1556
1557static int bus_method_revert_link(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d2ec6608 1558 return call_link_method(userdata, message, bus_link_method_revert, error);
97e5d693
LP		 1559}
1560
3abaabda
LP		 1561static int bus_method_get_link(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1562 _cleanup_free_ char *p = NULL;
1563 Manager *m = userdata;
1564 int r, ifindex;
1565 Link *l;
1566
1567 assert(message);
1568 assert(m);
1569
1570 assert_cc(sizeof(int) == sizeof(int32_t));
3abaabda
LP		 1571 r = sd_bus_message_read(message, "i", &ifindex);
1572 if (r < 0)
1573 return r;
1574
1575 r = get_any_link(m, ifindex, &l, error);
1576 if (r < 0)
1577 return r;
1578
1579 p = link_bus_path(l);
1580 if (!p)
1581 return -ENOMEM;
1582
1583 return sd_bus_reply_method_return(message, "o", p);
1584}
1585
ba35662f
LP		 1586static int bus_method_flush_caches(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1587 Manager *m = userdata;
1588
1589 assert(message);
1590 assert(m);
1591
1592 manager_flush_caches(m);
1593
1594 return sd_bus_reply_method_return(message, NULL);
1595}
1596
d55b0463
LP		 1597static int bus_method_reset_server_features(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1598 Manager *m = userdata;
1599
1600 assert(message);
1601 assert(m);
1602
1603 manager_reset_server_features(m);
1604
1605 return sd_bus_reply_method_return(message, NULL);
1606}
1607
c3036641
DR		 1608static int on_bus_track(sd_bus_track *t, void *userdata) {
1609 DnssdService *s = userdata;
1610
1611 assert(t);
1612 assert(s);
1613
1614 log_debug("Client of active request vanished, destroying DNS-SD service.");
1615 dnssd_service_free(s);
1616
1617 return 0;
1618}
1619
1620static int bus_method_register_service(sd_bus_message *message, void *userdata, sd_bus_error *error) {
84b0f133 1621 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
c3036641
DR		 1622 _cleanup_(dnssd_service_freep) DnssdService *service = NULL;
1623 _cleanup_(sd_bus_track_unrefp) sd_bus_track *bus_track = NULL;
1624 _cleanup_free_ char *path = NULL;
1625 _cleanup_free_ char *instance_name = NULL;
1626 Manager *m = userdata;
1627 DnssdService *s = NULL;
c3036641
DR		 1628 const char *name;
1629 const char *name_template;
1630 const char *type;
84b0f133 1631 uid_t euid;
c3036641
DR		 1632 int r;
1633
1634 assert(message);
1635 assert(m);
1636
1637 if (m->mdns_support != RESOLVE_SUPPORT_YES)
1638 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Support for MulticastDNS is disabled");
1639
84b0f133
DR		 1640 r = bus_verify_polkit_async(message, CAP_SYS_ADMIN,
1641 "org.freedesktop.resolve1.register-service",
1642 NULL, false, UID_INVALID,
1643 &m->polkit_registry, error);
1644 if (r < 0)
1645 return r;
1646 if (r == 0)
1647 return 1; /* Polkit will call us back */
1648
c3036641
DR		 1649 service = new0(DnssdService, 1);
1650 if (!service)
1651 return log_oom();
1652
84b0f133
DR		 1653 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
1654 if (r < 0)
1655 return r;
1656
1657 r = sd_bus_creds_get_euid(creds, &euid);
1658 if (r < 0)
1659 return r;
1660 service->originator = euid;
1661
c3036641
DR		 1662 r = sd_bus_message_read(message, "sssqqq", &name, &name_template, &type,
1663 &service->port, &service->priority,
1664 &service->weight);
1665 if (r < 0)
1666 return r;
1667
1668 s = hashmap_get(m->dnssd_services, name);
1669 if (s)
1670 return sd_bus_error_setf(error, BUS_ERROR_DNSSD_SERVICE_EXISTS, "DNS-SD service '%s' exists already", name);
1671
1672 if (!dnssd_srv_type_is_valid(type))
1673 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "DNS-SD service type '%s' is invalid", type);
1674
1675 service->name = strdup(name);
1676 if (!service->name)
1677 return log_oom();
1678
1679 service->name_template = strdup(name_template);
1680 if (!service->name_template)
1681 return log_oom();
1682
1683 service->type = strdup(type);
1684 if (!service->type)
1685 return log_oom();
1686
1687 r = dnssd_render_instance_name(service, &instance_name);
1688 if (r < 0)
1689 return r;
1690
400f54fb 1691 r = sd_bus_message_enter_container(message, SD_BUS_TYPE_ARRAY, "a{say}");
c3036641 1692 if (r < 0)
400f54fb 1693 return r;
c3036641 1694
400f54fb
DR		 1695 while ((r = sd_bus_message_enter_container(message, SD_BUS_TYPE_ARRAY, "{say}")) > 0) {
1696 _cleanup_(dnssd_txtdata_freep) DnssdTxtData *txt_data = NULL;
1697 DnsTxtItem *last = NULL;
c3036641 1698
400f54fb
DR		 1699 txt_data = new0(DnssdTxtData, 1);
1700 if (!txt_data)
1701 return log_oom();
1702
1703 while ((r = sd_bus_message_enter_container(message, SD_BUS_TYPE_DICT_ENTRY, "say")) > 0) {
1704 const char *key;
1705 const void *value;
1706 size_t size;
1707 DnsTxtItem *i;
1708
1709 r = sd_bus_message_read(message, "s", &key);
1710 if (r < 0)
1711 return r;
1712
1713 if (isempty(key))
1714 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Keys in DNS-SD TXT RRs can't be empty");
c3036641 1715
400f54fb
DR		 1716 if (!ascii_is_valid(key))
1717 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "TXT key '%s' contains non-ASCII symbols", key);
c3036641 1718
400f54fb
DR		 1719 r = sd_bus_message_read_array(message, 'y', &value, &size);
1720 if (r < 0)
1721 return r;
c3036641 1722
400f54fb
DR		 1723 r = dnssd_txt_item_new_from_data(key, value, size, &i);
1724 if (r < 0)
1725 return r;
1726
1727 LIST_INSERT_AFTER(items, txt_data->txt, last, i);
1728 last = i;
1729
1730 r = sd_bus_message_exit_container(message);
1731 if (r < 0)
1732 return r;
1733
1734 }
c3036641 1735 if (r < 0)
400f54fb 1736 return r;
c3036641 1737
400f54fb 1738 r = sd_bus_message_exit_container(message);
c3036641 1739 if (r < 0)
400f54fb 1740 return r;
c3036641 1741
400f54fb
DR		 1742 if (txt_data->txt) {
1743 LIST_PREPEND(items, service->txt_data_items, txt_data);
1744 txt_data = NULL;
1745 }
c3036641 1746 }
400f54fb
DR		 1747 if (r < 0)
1748 return r;
c3036641
DR		 1749
1750 r = sd_bus_message_exit_container(message);
1751 if (r < 0)
400f54fb
DR		 1752 return r;
1753
1754 if (!service->txt_data_items) {
1755 _cleanup_(dnssd_txtdata_freep) DnssdTxtData *txt_data = NULL;
c3036641 1756
400f54fb
DR		 1757 txt_data = new0(DnssdTxtData, 1);
1758 if (!txt_data)
1759 return log_oom();
1760
1761 r = dns_txt_item_new_empty(&txt_data->txt);
c3036641 1762 if (r < 0)
400f54fb
DR		 1763 return r;
1764
1765 LIST_PREPEND(items, service->txt_data_items, txt_data);
1766 txt_data = NULL;
c3036641
DR		 1767 }
1768
1769 r = sd_bus_path_encode("/org/freedesktop/resolve1/dnssd", service->name, &path);
1770 if (r < 0)
1771 return r;
1772
1773 r = hashmap_ensure_allocated(&m->dnssd_services, &string_hash_ops);
1774 if (r < 0)
1775 return r;
1776
1777 r = hashmap_put(m->dnssd_services, service->name, service);
1778 if (r < 0)
1779 return r;
1780
1781 r = sd_bus_track_new(sd_bus_message_get_bus(message), &bus_track, on_bus_track, service);
1782 if (r < 0)
1783 return r;
1784
1785 r = sd_bus_track_add_sender(bus_track, message);
1786 if (r < 0)
1787 return r;
1788
1789 service->manager = m;
1790
1791 service = NULL;
1792
1793 manager_refresh_rrs(m);
1794
1795 return sd_bus_reply_method_return(message, "o", path);
1796}
1797
1798static int call_dnssd_method(Manager *m, sd_bus_message *message, sd_bus_message_handler_t handler, sd_bus_error *error) {
1799 _cleanup_free_ char *name = NULL;
1800 DnssdService *s = NULL;
1801 const char *path;
1802 int r;
1803
1804 assert(m);
1805 assert(message);
1806 assert(handler);
1807
1808 r = sd_bus_message_read(message, "o", &path);
1809 if (r < 0)
1810 return r;
1811
1812 r = sd_bus_path_decode(path, "/org/freedesktop/resolve1/dnssd", &name);
1813 if (r == 0)
1814 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DNSSD_SERVICE, "DNS-SD service with object path '%s' does not exist", path);
1815 if (r < 0)
1816 return r;
1817
1818 s = hashmap_get(m->dnssd_services, name);
1819 if (!s)
1820 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DNSSD_SERVICE, "DNS-SD service '%s' not known", name);
1821
1822 return handler(message, s, error);
1823}
1824
1825static int bus_method_unregister_service(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1826 Manager *m = userdata;
1827
1828 assert(message);
1829 assert(m);
1830
1831 return call_dnssd_method(m, message, bus_dnssd_method_unregister, error);
1832}
1833
74b2466e
LP		 1834static const sd_bus_vtable resolve_vtable[] = {
1835 SD_BUS_VTABLE_START(0),
7f220d94 1836 SD_BUS_PROPERTY("LLMNRHostname", "s", NULL, offsetof(Manager, llmnr_hostname), 0),
bf4e5c4c
YW		 1837 SD_BUS_PROPERTY("LLMNR", "s", bus_property_get_resolve_support, offsetof(Manager, llmnr_support), 0),
1838 SD_BUS_PROPERTY("MulticastDNS", "s", bus_property_get_resolve_support, offsetof(Manager, mdns_support), 0),
c9299be2 1839 SD_BUS_PROPERTY("DNSOverTLS", "s", bus_property_get_dns_over_tls_mode, 0, 0),
e40f0647 1840 SD_BUS_PROPERTY("DNS", "a(iiay)", bus_property_get_dns_servers, 0, 0),
ad32ac53 1841 SD_BUS_PROPERTY("FallbackDNS", "a(iiay)", bus_property_get_fallback_dns_servers, offsetof(Manager, fallback_dns_servers), SD_BUS_VTABLE_PROPERTY_CONST),
b7ac92cd 1842 SD_BUS_PROPERTY("CurrentDNSServer", "(iiay)", bus_property_get_current_dns_server, offsetof(Manager, current_dns_server), 0),
ee116b54 1843 SD_BUS_PROPERTY("Domains", "a(isb)", bus_property_get_domains, 0, 0),
a150ff5e
LP		 1844 SD_BUS_PROPERTY("TransactionStatistics", "(tt)", bus_property_get_transaction_statistics, 0, 0),
1845 SD_BUS_PROPERTY("CacheStatistics", "(ttt)", bus_property_get_cache_statistics, 0, 0),
bf4e5c4c 1846 SD_BUS_PROPERTY("DNSSEC", "s", bus_property_get_dnssec_mode, 0, 0),
a150ff5e 1847 SD_BUS_PROPERTY("DNSSECStatistics", "(tttt)", bus_property_get_dnssec_statistics, 0, 0),
593f665c 1848 SD_BUS_PROPERTY("DNSSECSupported", "b", bus_property_get_dnssec_supported, 0, 0),
476798b1 1849 SD_BUS_PROPERTY("DNSSECNegativeTrustAnchors", "as", bus_property_get_ntas, 0, 0),
7ed1565a 1850 SD_BUS_PROPERTY("DNSStubListener", "s", bus_property_get_dns_stub_listener_mode, offsetof(Manager, dns_stub_listener_mode), 0),
7f220d94 1851
78c6a153
LP		 1852 SD_BUS_METHOD("ResolveHostname", "isit", "a(iiay)st", bus_method_resolve_hostname, SD_BUS_VTABLE_UNPRIVILEGED),
1853 SD_BUS_METHOD("ResolveAddress", "iiayt", "a(is)t", bus_method_resolve_address, SD_BUS_VTABLE_UNPRIVILEGED),
1854 SD_BUS_METHOD("ResolveRecord", "isqqt", "a(iqqay)t", bus_method_resolve_record, SD_BUS_VTABLE_UNPRIVILEGED),
45ec7efb 1855 SD_BUS_METHOD("ResolveService", "isssit", "a(qqqsa(iiay)s)aayssst", bus_method_resolve_service, SD_BUS_VTABLE_UNPRIVILEGED),
a150ff5e 1856 SD_BUS_METHOD("ResetStatistics", NULL, NULL, bus_method_reset_statistics, 0),
ba35662f 1857 SD_BUS_METHOD("FlushCaches", NULL, NULL, bus_method_flush_caches, 0),
d55b0463 1858 SD_BUS_METHOD("ResetServerFeatures", NULL, NULL, bus_method_reset_server_features, 0),
3abaabda 1859 SD_BUS_METHOD("GetLink", "i", "o", bus_method_get_link, SD_BUS_VTABLE_UNPRIVILEGED),
97e5d693 1860 SD_BUS_METHOD("SetLinkDNS", "ia(iay)", NULL, bus_method_set_link_dns_servers, 0),
ee116b54 1861 SD_BUS_METHOD("SetLinkDomains", "ia(sb)", NULL, bus_method_set_link_domains, 0),
77673795 1862 SD_BUS_METHOD("SetLinkDefaultRoute", "ib", NULL, bus_method_set_link_default_route, 0),
97e5d693
LP		 1863 SD_BUS_METHOD("SetLinkLLMNR", "is", NULL, bus_method_set_link_llmnr, 0),
1864 SD_BUS_METHOD("SetLinkMulticastDNS", "is", NULL, bus_method_set_link_mdns, 0),
c9299be2 1865 SD_BUS_METHOD("SetLinkDNSOverTLS", "is", NULL, bus_method_set_link_dns_over_tls, 0),
97e5d693
LP		 1866 SD_BUS_METHOD("SetLinkDNSSEC", "is", NULL, bus_method_set_link_dnssec, 0),
1867 SD_BUS_METHOD("SetLinkDNSSECNegativeTrustAnchors", "ias", NULL, bus_method_set_link_dnssec_negative_trust_anchors, 0),
1868 SD_BUS_METHOD("RevertLink", "i", NULL, bus_method_revert_link, 0),
1869
400f54fb 1870 SD_BUS_METHOD("RegisterService", "sssqqqaa{say}", "o", bus_method_register_service, SD_BUS_VTABLE_UNPRIVILEGED),
84b0f133 1871 SD_BUS_METHOD("UnregisterService", "o", NULL, bus_method_unregister_service, SD_BUS_VTABLE_UNPRIVILEGED),
74b2466e
LP		 1872 SD_BUS_VTABLE_END,
1873};
1874
19070062 1875static int match_prepare_for_sleep(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
902bb5d8
LP		 1876 Manager *m = userdata;
1877 int b, r;
1878
19070062
LP		 1879 assert(message);
1880 assert(m);
902bb5d8
LP		 1881
1882 r = sd_bus_message_read(message, "b", &b);
1883 if (r < 0) {
da927ba9 1884 log_debug_errno(r, "Failed to parse PrepareForSleep signal: %m");
902bb5d8
LP		 1885 return 0;
1886 }
1887
1888 if (b)
1889 return 0;
1890
1891 log_debug("Coming back from suspend, verifying all RRs...");
1892
1893 manager_verify_all(m);
1894 return 0;
1895}
1896
74b2466e
LP		 1897int manager_connect_bus(Manager *m) {
1898 int r;
1899
1900 assert(m);
1901
1902 if (m->bus)
1903 return 0;
1904
8c6afb77 1905 r = bus_open_system_watch_bind_with_description(&m->bus, "bus-api-resolve");
d7afd945
LP		 1906 if (r < 0)
1907 return log_error_errno(r, "Failed to connect to system bus: %m");
74b2466e 1908
4d1cf1e2 1909 r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/resolve1", "org.freedesktop.resolve1.Manager", resolve_vtable, m);
f647962d
MS		 1910 if (r < 0)
1911 return log_error_errno(r, "Failed to register object: %m");
74b2466e 1912
3abaabda
LP		 1913 r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/resolve1/link", "org.freedesktop.resolve1.Link", link_vtable, link_object_find, m);
1914 if (r < 0)
1915 return log_error_errno(r, "Failed to register link objects: %m");
1916
1917 r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/resolve1/link", link_node_enumerator, m);
1918 if (r < 0)
1919 return log_error_errno(r, "Failed to register link enumerator: %m");
1920
c3036641
DR		 1921 r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/resolve1/dnssd", "org.freedesktop.resolve1.DnssdService", dnssd_vtable, dnssd_object_find, m);
1922 if (r < 0)
1923 return log_error_errno(r, "Failed to register dnssd objects: %m");
1924
1925 r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/resolve1/dnssd", dnssd_node_enumerator, m);
1926 if (r < 0)
1927 return log_error_errno(r, "Failed to register dnssd enumerator: %m");
1928
62fb7e80 1929 r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.resolve1", 0, NULL, NULL);
f647962d 1930 if (r < 0)
0c0b9306 1931 return log_error_errno(r, "Failed to request name: %m");
74b2466e
LP		 1932
1933 r = sd_bus_attach_event(m->bus, m->event, 0);
f647962d
MS		 1934 if (r < 0)
1935 return log_error_errno(r, "Failed to attach bus to event loop: %m");
74b2466e 1936
75152a4d
LP		 1937 r = sd_bus_match_signal_async(
1938 m->bus,
4b0051b1 1939 NULL,
75152a4d
LP		 1940 "org.freedesktop.login1",
1941 "/org/freedesktop/login1",
1942 "org.freedesktop.login1.Manager",
1943 "PrepareForSleep",
1944 match_prepare_for_sleep,
1945 NULL,
1946 m);
1947 if (r < 0)
d7afd945 1948 log_warning_errno(r, "Failed to request match for PrepareForSleep, ignoring: %m");
902bb5d8 1949
74b2466e
LP		 1950 return 0;
1951}
Unnamed repository; edit this file 'description' to name the repository.