src/resolve/resolved-bus.c

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