src/resolve/resolved-manager.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <netinet/in.h>
   4 #include <poll.h>
   5 #include <stdio_ext.h>
   6 #include <sys/ioctl.h>
   7
   8 #if HAVE_LIBIDN2
   9 #include <idn2.h>
  10 #endif
  11
  12 #include "af-list.h"
  13 #include "alloc-util.h"
  14 #include "dirent-util.h"
  15 #include "dns-domain.h"
  16 #include "fd-util.h"
  17 #include "fileio-label.h"
  18 #include "hostname-util.h"
  19 #include "io-util.h"
  20 #include "netlink-util.h"
  21 #include "network-internal.h"
  22 #include "ordered-set.h"
  23 #include "parse-util.h"
  24 #include "random-util.h"
  25 #include "resolved-bus.h"
  26 #include "resolved-conf.h"
  27 #include "resolved-dnssd.h"
  28 #include "resolved-dns-stub.h"
  29 #include "resolved-etc-hosts.h"
  30 #include "resolved-llmnr.h"
  31 #include "resolved-manager.h"
  32 #include "resolved-mdns.h"
  33 #include "resolved-resolv-conf.h"
  34 #include "socket-util.h"
  35 #include "string-table.h"
  36 #include "string-util.h"
  37 #include "utf8.h"
  38
  39 #define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC)
  40
  41 static int manager_process_link(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
  42         Manager *m = userdata;
  43         uint16_t type;
  44         Link *l;
  45         int ifindex, r;
  46
  47         assert(rtnl);
  48         assert(m);
  49         assert(mm);
  50
  51         r = sd_netlink_message_get_type(mm, &type);
  52         if (r < 0)
  53                 goto fail;
  54
  55         r = sd_rtnl_message_link_get_ifindex(mm, &ifindex);
  56         if (r < 0)
  57                 goto fail;
  58
  59         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
  60
  61         switch (type) {
  62
  63         case RTM_NEWLINK:{
  64                 bool is_new = !l;
  65
  66                 if (!l) {
  67                         r = link_new(m, &l, ifindex);
  68                         if (r < 0)
  69                                 goto fail;
  70                 }
  71
  72                 r = link_process_rtnl(l, mm);
  73                 if (r < 0)
  74                         goto fail;
  75
  76                 r = link_update(l);
  77                 if (r < 0)
  78                         goto fail;
  79
  80                 if (is_new)
  81                         log_debug("Found new link %i/%s", ifindex, l->name);
  82
  83                 break;
  84         }
  85
  86         case RTM_DELLINK:
  87                 if (l) {
  88                         log_debug("Removing link %i/%s", l->ifindex, l->name);
  89                         link_remove_user(l);
  90                         link_free(l);
  91                 }
  92
  93                 break;
  94         }
  95
  96         return 0;
  97
  98 fail:
  99         log_warning_errno(r, "Failed to process RTNL link message: %m");
 100         return 0;
 101 }
 102
 103 static int manager_process_address(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
 104         Manager *m = userdata;
 105         union in_addr_union address;
 106         uint16_t type;
 107         int r, ifindex, family;
 108         LinkAddress *a;
 109         Link *l;
 110
 111         assert(rtnl);
 112         assert(mm);
 113         assert(m);
 114
 115         r = sd_netlink_message_get_type(mm, &type);
 116         if (r < 0)
 117                 goto fail;
 118
 119         r = sd_rtnl_message_addr_get_ifindex(mm, &ifindex);
 120         if (r < 0)
 121                 goto fail;
 122
 123         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
 124         if (!l)
 125                 return 0;
 126
 127         r = sd_rtnl_message_addr_get_family(mm, &family);
 128         if (r < 0)
 129                 goto fail;
 130
 131         switch (family) {
 132
 133         case AF_INET:
 134                 r = sd_netlink_message_read_in_addr(mm, IFA_LOCAL, &address.in);
 135                 if (r < 0) {
 136                         r = sd_netlink_message_read_in_addr(mm, IFA_ADDRESS, &address.in);
 137                         if (r < 0)
 138                                 goto fail;
 139                 }
 140
 141                 break;
 142
 143         case AF_INET6:
 144                 r = sd_netlink_message_read_in6_addr(mm, IFA_LOCAL, &address.in6);
 145                 if (r < 0) {
 146                         r = sd_netlink_message_read_in6_addr(mm, IFA_ADDRESS, &address.in6);
 147                         if (r < 0)
 148                                 goto fail;
 149                 }
 150
 151                 break;
 152
 153         default:
 154                 return 0;
 155         }
 156
 157         a = link_find_address(l, family, &address);
 158
 159         switch (type) {
 160
 161         case RTM_NEWADDR:
 162
 163                 if (!a) {
 164                         r = link_address_new(l, &a, family, &address);
 165                         if (r < 0)
 166                                 return r;
 167                 }
 168
 169                 r = link_address_update_rtnl(a, mm);
 170                 if (r < 0)
 171                         return r;
 172
 173                 break;
 174
 175         case RTM_DELADDR:
 176                 link_address_free(a);
 177                 break;
 178         }
 179
 180         return 0;
 181
 182 fail:
 183         log_warning_errno(r, "Failed to process RTNL address message: %m");
 184         return 0;
 185 }
 186
 187 static int manager_rtnl_listen(Manager *m) {
 188         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
 189         sd_netlink_message *i;
 190         int r;
 191
 192         assert(m);
 193
 194         /* First, subscribe to interfaces coming and going */
 195         r = sd_netlink_open(&m->rtnl);
 196         if (r < 0)
 197                 return r;
 198
 199         r = sd_netlink_attach_event(m->rtnl, m->event, SD_EVENT_PRIORITY_IMPORTANT);
 200         if (r < 0)
 201                 return r;
 202
 203         r = sd_netlink_add_match(m->rtnl, NULL, RTM_NEWLINK, manager_process_link, NULL, m, "resolve-NEWLINK");
 204         if (r < 0)
 205                 return r;
 206
 207         r = sd_netlink_add_match(m->rtnl, NULL, RTM_DELLINK, manager_process_link, NULL, m, "resolve-DELLINK");
 208         if (r < 0)
 209                 return r;
 210
 211         r = sd_netlink_add_match(m->rtnl, NULL, RTM_NEWADDR, manager_process_address, NULL, m, "resolve-NEWADDR");
 212         if (r < 0)
 213                 return r;
 214
 215         r = sd_netlink_add_match(m->rtnl, NULL, RTM_DELADDR, manager_process_address, NULL, m, "resolve-DELADDR");
 216         if (r < 0)
 217                 return r;
 218
 219         /* Then, enumerate all links */
 220         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
 221         if (r < 0)
 222                 return r;
 223
 224         r = sd_netlink_message_request_dump(req, true);
 225         if (r < 0)
 226                 return r;
 227
 228         r = sd_netlink_call(m->rtnl, req, 0, &reply);
 229         if (r < 0)
 230                 return r;
 231
 232         for (i = reply; i; i = sd_netlink_message_next(i)) {
 233                 r = manager_process_link(m->rtnl, i, m);
 234                 if (r < 0)
 235                         return r;
 236         }
 237
 238         req = sd_netlink_message_unref(req);
 239         reply = sd_netlink_message_unref(reply);
 240
 241         /* Finally, enumerate all addresses, too */
 242         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, AF_UNSPEC);
 243         if (r < 0)
 244                 return r;
 245
 246         r = sd_netlink_message_request_dump(req, true);
 247         if (r < 0)
 248                 return r;
 249
 250         r = sd_netlink_call(m->rtnl, req, 0, &reply);
 251         if (r < 0)
 252                 return r;
 253
 254         for (i = reply; i; i = sd_netlink_message_next(i)) {
 255                 r = manager_process_address(m->rtnl, i, m);
 256                 if (r < 0)
 257                         return r;
 258         }
 259
 260         return r;
 261 }
 262
 263 static int on_network_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 264         Manager *m = userdata;
 265         Iterator i;
 266         Link *l;
 267         int r;
 268
 269         assert(m);
 270
 271         sd_network_monitor_flush(m->network_monitor);
 272
 273         HASHMAP_FOREACH(l, m->links, i) {
 274                 r = link_update(l);
 275                 if (r < 0)
 276                         log_warning_errno(r, "Failed to update monitor information for %i: %m", l->ifindex);
 277         }
 278
 279         (void) manager_write_resolv_conf(m);
 280
 281         return 0;
 282 }
 283
 284 static int manager_network_monitor_listen(Manager *m) {
 285         int r, fd, events;
 286
 287         assert(m);
 288
 289         r = sd_network_monitor_new(&m->network_monitor, NULL);
 290         if (r < 0)
 291                 return r;
 292
 293         fd = sd_network_monitor_get_fd(m->network_monitor);
 294         if (fd < 0)
 295                 return fd;
 296
 297         events = sd_network_monitor_get_events(m->network_monitor);
 298         if (events < 0)
 299                 return events;
 300
 301         r = sd_event_add_io(m->event, &m->network_event_source, fd, events, &on_network_event, m);
 302         if (r < 0)
 303                 return r;
 304
 305         r = sd_event_source_set_priority(m->network_event_source, SD_EVENT_PRIORITY_IMPORTANT+5);
 306         if (r < 0)
 307                 return r;
 308
 309         (void) sd_event_source_set_description(m->network_event_source, "network-monitor");
 310
 311         return 0;
 312 }
 313
 314 static int determine_hostname(char **full_hostname, char **llmnr_hostname, char **mdns_hostname) {
 315         _cleanup_free_ char *h = NULL, *n = NULL;
 316 #if HAVE_LIBIDN2
 317         _cleanup_free_ char *utf8 = NULL;
 318 #elif HAVE_LIBIDN
 319         int k;
 320 #endif
 321         char label[DNS_LABEL_MAX];
 322         const char *p, *decoded;
 323         int r;
 324
 325         assert(full_hostname);
 326         assert(llmnr_hostname);
 327         assert(mdns_hostname);
 328
 329         /* Extract and normalize the first label of the locally configured hostname, and check it's not "localhost". */
 330
 331         r = gethostname_strict(&h);
 332         if (r < 0)
 333                 return log_debug_errno(r, "Can't determine system hostname: %m");
 334
 335         p = h;
 336         r = dns_label_unescape(&p, label, sizeof label);
 337         if (r < 0)
 338                 return log_error_errno(r, "Failed to unescape host name: %m");
 339         if (r == 0)
 340                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 341                                        "Couldn't find a single label in hostname.");
 342
 343 #if HAVE_LIBIDN2
 344         r = idn2_to_unicode_8z8z(label, &utf8, 0);
 345         if (r != IDN2_OK)
 346                 return log_error("Failed to undo IDNA: %s", idn2_strerror(r));
 347         assert(utf8_is_valid(utf8));
 348
 349         r = strlen(utf8);
 350         decoded = utf8;
 351 #elif HAVE_LIBIDN
 352         k = dns_label_undo_idna(label, r, label, sizeof label);
 353         if (k < 0)
 354                 return log_error_errno(k, "Failed to undo IDNA: %m");
 355         if (k > 0)
 356                 r = k;
 357
 358         if (!utf8_is_valid(label))
 359                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 360                                        "System hostname is not UTF-8 clean.");
 361         decoded = label;
 362 #else
 363         decoded = label; /* no decoding */
 364 #endif
 365
 366         r = dns_label_escape_new(decoded, r, &n);
 367         if (r < 0)
 368                 return log_error_errno(r, "Failed to escape host name: %m");
 369
 370         if (is_localhost(n))
 371                 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
 372                                        "System hostname is 'localhost', ignoring.");
 373
 374         r = dns_name_concat(n, "local", mdns_hostname);
 375         if (r < 0)
 376                 return log_error_errno(r, "Failed to determine mDNS hostname: %m");
 377
 378         *llmnr_hostname = TAKE_PTR(n);
 379         *full_hostname = TAKE_PTR(h);
 380
 381         return 0;
 382 }
 383
 384 static const char *fallback_hostname(void) {
 385
 386         /* Determine the fall back hostname. For exposing this system to the outside world, we cannot have it to be
 387          * "localhost" even if that's the compiled in hostname. In this case, let's revert to "linux" instead. */
 388
 389         if (is_localhost(FALLBACK_HOSTNAME))
 390                 return "linux";
 391
 392         return FALLBACK_HOSTNAME;
 393 }
 394
 395 static int make_fallback_hostnames(char **full_hostname, char **llmnr_hostname, char **mdns_hostname) {
 396         _cleanup_free_ char *n = NULL, *m = NULL;
 397         char label[DNS_LABEL_MAX], *h;
 398         const char *p;
 399         int r;
 400
 401         assert(full_hostname);
 402         assert(llmnr_hostname);
 403         assert(mdns_hostname);
 404
 405         p = fallback_hostname();
 406         r = dns_label_unescape(&p, label, sizeof(label));
 407         if (r < 0)
 408                 return log_error_errno(r, "Failed to unescape fallback host name: %m");
 409
 410         assert(r > 0); /* The fallback hostname must have at least one label */
 411
 412         r = dns_label_escape_new(label, r, &n);
 413         if (r < 0)
 414                 return log_error_errno(r, "Failed to escape fallback hostname: %m");
 415
 416         r = dns_name_concat(n, "local", &m);
 417         if (r < 0)
 418                 return log_error_errno(r, "Failed to concatenate mDNS hostname: %m");
 419
 420         h = strdup(fallback_hostname());
 421         if (!h)
 422                 return log_oom();
 423
 424         *llmnr_hostname = TAKE_PTR(n);
 425         *mdns_hostname = TAKE_PTR(m);
 426
 427         *full_hostname = h;
 428
 429         return 0;
 430 }
 431
 432 static int on_hostname_change(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
 433         _cleanup_free_ char *full_hostname = NULL, *llmnr_hostname = NULL, *mdns_hostname = NULL;
 434         Manager *m = userdata;
 435         int r;
 436
 437         assert(m);
 438
 439         r = determine_hostname(&full_hostname, &llmnr_hostname, &mdns_hostname);
 440         if (r < 0)
 441                 return 0; /* ignore invalid hostnames */
 442
 443         if (streq(full_hostname, m->full_hostname) &&
 444             streq(llmnr_hostname, m->llmnr_hostname) &&
 445             streq(mdns_hostname, m->mdns_hostname))
 446                 return 0;
 447
 448         log_info("System hostname changed to '%s'.", full_hostname);
 449
 450         free_and_replace(m->full_hostname, full_hostname);
 451         free_and_replace(m->llmnr_hostname, llmnr_hostname);
 452         free_and_replace(m->mdns_hostname, mdns_hostname);
 453
 454         manager_refresh_rrs(m);
 455
 456         return 0;
 457 }
 458
 459 static int manager_watch_hostname(Manager *m) {
 460         int r;
 461
 462         assert(m);
 463
 464         m->hostname_fd = open("/proc/sys/kernel/hostname",
 465                               O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
 466         if (m->hostname_fd < 0) {
 467                 log_warning_errno(errno, "Failed to watch hostname: %m");
 468                 return 0;
 469         }
 470
 471         r = sd_event_add_io(m->event, &m->hostname_event_source, m->hostname_fd, 0, on_hostname_change, m);
 472         if (r < 0) {
 473                 if (r == -EPERM)
 474                         /* kernels prior to 3.2 don't support polling this file. Ignore the failure. */
 475                         m->hostname_fd = safe_close(m->hostname_fd);
 476                 else
 477                         return log_error_errno(r, "Failed to add hostname event source: %m");
 478         }
 479
 480         (void) sd_event_source_set_description(m->hostname_event_source, "hostname");
 481
 482         r = determine_hostname(&m->full_hostname, &m->llmnr_hostname, &m->mdns_hostname);
 483         if (r < 0) {
 484                 log_info("Defaulting to hostname '%s'.", fallback_hostname());
 485
 486                 r = make_fallback_hostnames(&m->full_hostname, &m->llmnr_hostname, &m->mdns_hostname);
 487                 if (r < 0)
 488                         return r;
 489         } else
 490                 log_info("Using system hostname '%s'.", m->full_hostname);
 491
 492         return 0;
 493 }
 494
 495 static int manager_sigusr1(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
 496         _cleanup_free_ char *buffer = NULL;
 497         _cleanup_fclose_ FILE *f = NULL;
 498         Manager *m = userdata;
 499         DnsServer *server;
 500         size_t size = 0;
 501         DnsScope *scope;
 502         Iterator i;
 503         Link *l;
 504
 505         assert(s);
 506         assert(si);
 507         assert(m);
 508
 509         f = open_memstream(&buffer, &size);
 510         if (!f)
 511                 return log_oom();
 512
 513         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
 514
 515         LIST_FOREACH(scopes, scope, m->dns_scopes)
 516                 dns_scope_dump(scope, f);
 517
 518         LIST_FOREACH(servers, server, m->dns_servers)
 519                 dns_server_dump(server, f);
 520         LIST_FOREACH(servers, server, m->fallback_dns_servers)
 521                 dns_server_dump(server, f);
 522         HASHMAP_FOREACH(l, m->links, i)
 523                 LIST_FOREACH(servers, server, l->dns_servers)
 524                         dns_server_dump(server, f);
 525
 526         if (fflush_and_check(f) < 0)
 527                 return log_oom();
 528
 529         log_dump(LOG_INFO, buffer);
 530         return 0;
 531 }
 532
 533 static int manager_sigusr2(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
 534         Manager *m = userdata;
 535
 536         assert(s);
 537         assert(si);
 538         assert(m);
 539
 540         manager_flush_caches(m);
 541
 542         return 0;
 543 }
 544
 545 static int manager_sigrtmin1(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
 546         Manager *m = userdata;
 547
 548         assert(s);
 549         assert(si);
 550         assert(m);
 551
 552         manager_reset_server_features(m);
 553         return 0;
 554 }
 555
 556 int manager_new(Manager **ret) {
 557         _cleanup_(manager_freep) Manager *m = NULL;
 558         int r;
 559
 560         assert(ret);
 561
 562         m = new(Manager, 1);
 563         if (!m)
 564                 return -ENOMEM;
 565
 566         *m = (Manager) {
 567                 .llmnr_ipv4_udp_fd = -1,
 568                 .llmnr_ipv6_udp_fd = -1,
 569                 .llmnr_ipv4_tcp_fd = -1,
 570                 .llmnr_ipv6_tcp_fd = -1,
 571                 .mdns_ipv4_fd = -1,
 572                 .mdns_ipv6_fd = -1,
 573                 .dns_stub_udp_fd = -1,
 574                 .dns_stub_tcp_fd = -1,
 575                 .hostname_fd = -1,
 576
 577                 .llmnr_support = RESOLVE_SUPPORT_YES,
 578                 .mdns_support = RESOLVE_SUPPORT_YES,
 579                 .dnssec_mode = DEFAULT_DNSSEC_MODE,
 580                 .dns_over_tls_mode = DEFAULT_DNS_OVER_TLS_MODE,
 581                 .enable_cache = true,
 582                 .dns_stub_listener_mode = DNS_STUB_LISTENER_UDP,
 583                 .read_resolv_conf = true,
 584                 .need_builtin_fallbacks = true,
 585                 .etc_hosts_last = USEC_INFINITY,
 586                 .etc_hosts_mtime = USEC_INFINITY,
 587                 .read_etc_hosts = true,
 588         };
 589
 590         r = dns_trust_anchor_load(&m->trust_anchor);
 591         if (r < 0)
 592                 return r;
 593
 594         r = manager_parse_config_file(m);
 595         if (r < 0)
 596                 log_warning_errno(r, "Failed to parse configuration file: %m");
 597
 598         r = sd_event_default(&m->event);
 599         if (r < 0)
 600                 return r;
 601
 602         (void) sd_event_add_signal(m->event, NULL, SIGTERM, NULL,  NULL);
 603         (void) sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
 604
 605         (void) sd_event_set_watchdog(m->event, true);
 606
 607         r = manager_watch_hostname(m);
 608         if (r < 0)
 609                 return r;
 610
 611         r = dnssd_load(m);
 612         if (r < 0)
 613                 log_warning_errno(r, "Failed to load DNS-SD configuration files: %m");
 614
 615         r = dns_scope_new(m, &m->unicast_scope, NULL, DNS_PROTOCOL_DNS, AF_UNSPEC);
 616         if (r < 0)
 617                 return r;
 618
 619         r = manager_network_monitor_listen(m);
 620         if (r < 0)
 621                 return r;
 622
 623         r = manager_rtnl_listen(m);
 624         if (r < 0)
 625                 return r;
 626
 627         r = manager_connect_bus(m);
 628         if (r < 0)
 629                 return r;
 630
 631         (void) sd_event_add_signal(m->event, &m->sigusr1_event_source, SIGUSR1, manager_sigusr1, m);
 632         (void) sd_event_add_signal(m->event, &m->sigusr2_event_source, SIGUSR2, manager_sigusr2, m);
 633         (void) sd_event_add_signal(m->event, &m->sigrtmin1_event_source, SIGRTMIN+1, manager_sigrtmin1, m);
 634
 635         manager_cleanup_saved_user(m);
 636
 637         *ret = TAKE_PTR(m);
 638
 639         return 0;
 640 }
 641
 642 int manager_start(Manager *m) {
 643         int r;
 644
 645         assert(m);
 646
 647         r = manager_dns_stub_start(m);
 648         if (r < 0)
 649                 return r;
 650
 651         return 0;
 652 }
 653
 654 Manager *manager_free(Manager *m) {
 655         Link *l;
 656         DnssdService *s;
 657
 658         if (!m)
 659                 return NULL;
 660
 661         dns_server_unlink_all(m->dns_servers);
 662         dns_server_unlink_all(m->fallback_dns_servers);
 663         dns_search_domain_unlink_all(m->search_domains);
 664
 665         while ((l = hashmap_first(m->links)))
 666                link_free(l);
 667
 668         while (m->dns_queries)
 669                 dns_query_free(m->dns_queries);
 670
 671         dns_scope_free(m->unicast_scope);
 672
 673         /* At this point only orphaned streams should remain. All others should have been freed already by their
 674          * owners */
 675         while (m->dns_streams)
 676                 dns_stream_unref(m->dns_streams);
 677
 678         hashmap_free(m->links);
 679         hashmap_free(m->dns_transactions);
 680
 681         sd_event_source_unref(m->network_event_source);
 682         sd_network_monitor_unref(m->network_monitor);
 683
 684         sd_netlink_unref(m->rtnl);
 685         sd_event_source_unref(m->rtnl_event_source);
 686
 687         manager_llmnr_stop(m);
 688         manager_mdns_stop(m);
 689         manager_dns_stub_stop(m);
 690
 691         sd_bus_unref(m->bus);
 692
 693         sd_event_source_unref(m->sigusr1_event_source);
 694         sd_event_source_unref(m->sigusr2_event_source);
 695         sd_event_source_unref(m->sigrtmin1_event_source);
 696
 697         sd_event_unref(m->event);
 698
 699         dns_resource_key_unref(m->llmnr_host_ipv4_key);
 700         dns_resource_key_unref(m->llmnr_host_ipv6_key);
 701         dns_resource_key_unref(m->mdns_host_ipv4_key);
 702         dns_resource_key_unref(m->mdns_host_ipv6_key);
 703
 704         sd_event_source_unref(m->hostname_event_source);
 705         safe_close(m->hostname_fd);
 706
 707         free(m->full_hostname);
 708         free(m->llmnr_hostname);
 709         free(m->mdns_hostname);
 710
 711         while ((s = hashmap_first(m->dnssd_services)))
 712                dnssd_service_free(s);
 713         hashmap_free(m->dnssd_services);
 714
 715         dns_trust_anchor_flush(&m->trust_anchor);
 716         manager_etc_hosts_flush(m);
 717
 718         return mfree(m);
 719 }
 720
 721 int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) {
 722         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 723         union {
 724                 struct cmsghdr header; /* For alignment */
 725                 uint8_t buffer[CMSG_SPACE(MAXSIZE(struct in_pktinfo, struct in6_pktinfo))
 726                                + CMSG_SPACE(int) /* ttl/hoplimit */
 727                                + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */];
 728         } control;
 729         union sockaddr_union sa;
 730         struct iovec iov;
 731         struct msghdr mh = {
 732                 .msg_name = &sa.sa,
 733                 .msg_namelen = sizeof(sa),
 734                 .msg_iov = &iov,
 735                 .msg_iovlen = 1,
 736                 .msg_control = &control,
 737                 .msg_controllen = sizeof(control),
 738         };
 739         struct cmsghdr *cmsg;
 740         ssize_t ms, l;
 741         int r;
 742
 743         assert(m);
 744         assert(fd >= 0);
 745         assert(ret);
 746
 747         ms = next_datagram_size_fd(fd);
 748         if (ms < 0)
 749                 return ms;
 750
 751         r = dns_packet_new(&p, protocol, ms, DNS_PACKET_SIZE_MAX);
 752         if (r < 0)
 753                 return r;
 754
 755         iov = (struct iovec) {
 756                 .iov_base = DNS_PACKET_DATA(p),
 757                 iov.iov_len = p->allocated,
 758         };
 759
 760         l = recvmsg(fd, &mh, 0);
 761         if (l == 0)
 762                 return 0;
 763         if (l < 0) {
 764                 if (IN_SET(errno, EAGAIN, EINTR))
 765                         return 0;
 766
 767                 return -errno;
 768         }
 769
 770         assert(!(mh.msg_flags & MSG_CTRUNC));
 771         assert(!(mh.msg_flags & MSG_TRUNC));
 772
 773         p->size = (size_t) l;
 774
 775         p->family = sa.sa.sa_family;
 776         p->ipproto = IPPROTO_UDP;
 777         if (p->family == AF_INET) {
 778                 p->sender.in = sa.in.sin_addr;
 779                 p->sender_port = be16toh(sa.in.sin_port);
 780         } else if (p->family == AF_INET6) {
 781                 p->sender.in6 = sa.in6.sin6_addr;
 782                 p->sender_port = be16toh(sa.in6.sin6_port);
 783                 p->ifindex = sa.in6.sin6_scope_id;
 784         } else
 785                 return -EAFNOSUPPORT;
 786
 787         CMSG_FOREACH(cmsg, &mh) {
 788
 789                 if (cmsg->cmsg_level == IPPROTO_IPV6) {
 790                         assert(p->family == AF_INET6);
 791
 792                         switch (cmsg->cmsg_type) {
 793
 794                         case IPV6_PKTINFO: {
 795                                 struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg);
 796
 797                                 if (p->ifindex <= 0)
 798                                         p->ifindex = i->ipi6_ifindex;
 799
 800                                 p->destination.in6 = i->ipi6_addr;
 801                                 break;
 802                         }
 803
 804                         case IPV6_HOPLIMIT:
 805                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 806                                 break;
 807
 808                         }
 809                 } else if (cmsg->cmsg_level == IPPROTO_IP) {
 810                         assert(p->family == AF_INET);
 811
 812                         switch (cmsg->cmsg_type) {
 813
 814                         case IP_PKTINFO: {
 815                                 struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg);
 816
 817                                 if (p->ifindex <= 0)
 818                                         p->ifindex = i->ipi_ifindex;
 819
 820                                 p->destination.in = i->ipi_addr;
 821                                 break;
 822                         }
 823
 824                         case IP_TTL:
 825                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 826                                 break;
 827                         }
 828                 }
 829         }
 830
 831         /* The Linux kernel sets the interface index to the loopback
 832          * device if the packet came from the local host since it
 833          * avoids the routing table in such a case. Let's unset the
 834          * interface index in such a case. */
 835         if (p->ifindex == LOOPBACK_IFINDEX)
 836                 p->ifindex = 0;
 837
 838         if (protocol != DNS_PROTOCOL_DNS) {
 839                 /* If we don't know the interface index still, we look for the
 840                  * first local interface with a matching address. Yuck! */
 841                 if (p->ifindex <= 0)
 842                         p->ifindex = manager_find_ifindex(m, p->family, &p->destination);
 843         }
 844
 845         *ret = TAKE_PTR(p);
 846
 847         return 1;
 848 }
 849
 850 static int sendmsg_loop(int fd, struct msghdr *mh, int flags) {
 851         int r;
 852
 853         assert(fd >= 0);
 854         assert(mh);
 855
 856         for (;;) {
 857                 if (sendmsg(fd, mh, flags) >= 0)
 858                         return 0;
 859
 860                 if (errno == EINTR)
 861                         continue;
 862
 863                 if (errno != EAGAIN)
 864                         return -errno;
 865
 866                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
 867                 if (r < 0)
 868                         return r;
 869                 if (r == 0)
 870                         return -ETIMEDOUT;
 871         }
 872 }
 873
 874 static int write_loop(int fd, void *message, size_t length) {
 875         int r;
 876
 877         assert(fd >= 0);
 878         assert(message);
 879
 880         for (;;) {
 881                 if (write(fd, message, length) >= 0)
 882                         return 0;
 883
 884                 if (errno == EINTR)
 885                         continue;
 886
 887                 if (errno != EAGAIN)
 888                         return -errno;
 889
 890                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
 891                 if (r < 0)
 892                         return r;
 893                 if (r == 0)
 894                         return -ETIMEDOUT;
 895         }
 896 }
 897
 898 int manager_write(Manager *m, int fd, DnsPacket *p) {
 899         int r;
 900
 901         log_debug("Sending %s packet with id %" PRIu16 ".", DNS_PACKET_QR(p) ? "response" : "query", DNS_PACKET_ID(p));
 902
 903         r = write_loop(fd, DNS_PACKET_DATA(p), p->size);
 904         if (r < 0)
 905                 return r;
 906
 907         return 0;
 908 }
 909
 910 static int manager_ipv4_send(
 911                 Manager *m,
 912                 int fd,
 913                 int ifindex,
 914                 const struct in_addr *destination,
 915                 uint16_t port,
 916                 const struct in_addr *source,
 917                 DnsPacket *p) {
 918         union {
 919                 struct cmsghdr header; /* For alignment */
 920                 uint8_t buffer[CMSG_SPACE(sizeof(struct in_pktinfo))];
 921         } control = {};
 922         union sockaddr_union sa;
 923         struct iovec iov;
 924         struct msghdr mh = {
 925                 .msg_iov = &iov,
 926                 .msg_iovlen = 1,
 927                 .msg_name = &sa.sa,
 928                 .msg_namelen = sizeof(sa.in),
 929         };
 930
 931         assert(m);
 932         assert(fd >= 0);
 933         assert(destination);
 934         assert(port > 0);
 935         assert(p);
 936
 937         iov = (struct iovec) {
 938                 .iov_base = DNS_PACKET_DATA(p),
 939                 .iov_len = p->size,
 940         };
 941
 942         sa = (union sockaddr_union) {
 943                 .in.sin_family = AF_INET,
 944                 .in.sin_addr = *destination,
 945                 .in.sin_port = htobe16(port),
 946         };
 947
 948         if (ifindex > 0) {
 949                 struct cmsghdr *cmsg;
 950                 struct in_pktinfo *pi;
 951
 952                 mh.msg_control = &control;
 953                 mh.msg_controllen = CMSG_LEN(sizeof(struct in_pktinfo));
 954
 955                 cmsg = CMSG_FIRSTHDR(&mh);
 956                 cmsg->cmsg_len = mh.msg_controllen;
 957                 cmsg->cmsg_level = IPPROTO_IP;
 958                 cmsg->cmsg_type = IP_PKTINFO;
 959
 960                 pi = (struct in_pktinfo*) CMSG_DATA(cmsg);
 961                 pi->ipi_ifindex = ifindex;
 962
 963                 if (source)
 964                         pi->ipi_spec_dst = *source;
 965         }
 966
 967         return sendmsg_loop(fd, &mh, 0);
 968 }
 969
 970 static int manager_ipv6_send(
 971                 Manager *m,
 972                 int fd,
 973                 int ifindex,
 974                 const struct in6_addr *destination,
 975                 uint16_t port,
 976                 const struct in6_addr *source,
 977                 DnsPacket *p) {
 978
 979         union {
 980                 struct cmsghdr header; /* For alignment */
 981                 uint8_t buffer[CMSG_SPACE(sizeof(struct in6_pktinfo))];
 982         } control = {};
 983         union sockaddr_union sa;
 984         struct iovec iov;
 985         struct msghdr mh = {
 986                 .msg_iov = &iov,
 987                 .msg_iovlen = 1,
 988                 .msg_name = &sa.sa,
 989                 .msg_namelen = sizeof(sa.in6),
 990         };
 991
 992         assert(m);
 993         assert(fd >= 0);
 994         assert(destination);
 995         assert(port > 0);
 996         assert(p);
 997
 998         iov = (struct iovec) {
 999                 .iov_base = DNS_PACKET_DATA(p),
1000                 .iov_len = p->size,
1001         };
1002
1003         sa = (union sockaddr_union) {
1004                 .in6.sin6_family = AF_INET6,
1005                 .in6.sin6_addr = *destination,
1006                 .in6.sin6_port = htobe16(port),
1007                 .in6.sin6_scope_id = ifindex,
1008         };
1009
1010         if (ifindex > 0) {
1011                 struct cmsghdr *cmsg;
1012                 struct in6_pktinfo *pi;
1013
1014                 mh.msg_control = &control;
1015                 mh.msg_controllen = CMSG_LEN(sizeof(struct in6_pktinfo));
1016
1017                 cmsg = CMSG_FIRSTHDR(&mh);
1018                 cmsg->cmsg_len = mh.msg_controllen;
1019                 cmsg->cmsg_level = IPPROTO_IPV6;
1020                 cmsg->cmsg_type = IPV6_PKTINFO;
1021
1022                 pi = (struct in6_pktinfo*) CMSG_DATA(cmsg);
1023                 pi->ipi6_ifindex = ifindex;
1024
1025                 if (source)
1026                         pi->ipi6_addr = *source;
1027         }
1028
1029         return sendmsg_loop(fd, &mh, 0);
1030 }
1031
1032 int manager_send(
1033                 Manager *m,
1034                 int fd,
1035                 int ifindex,
1036                 int family,
1037                 const union in_addr_union *destination,
1038                 uint16_t port,
1039                 const union in_addr_union *source,
1040                 DnsPacket *p) {
1041
1042         assert(m);
1043         assert(fd >= 0);
1044         assert(destination);
1045         assert(port > 0);
1046         assert(p);
1047
1048         log_debug("Sending %s packet with id %" PRIu16 " on interface %i/%s.", DNS_PACKET_QR(p) ? "response" : "query", DNS_PACKET_ID(p), ifindex, af_to_name(family));
1049
1050         if (family == AF_INET)
1051                 return manager_ipv4_send(m, fd, ifindex, &destination->in, port, source ? &source->in : NULL, p);
1052         if (family == AF_INET6)
1053                 return manager_ipv6_send(m, fd, ifindex, &destination->in6, port, source ? &source->in6 : NULL, p);
1054
1055         return -EAFNOSUPPORT;
1056 }
1057
1058 uint32_t manager_find_mtu(Manager *m) {
1059         uint32_t mtu = 0;
1060         Link *l;
1061         Iterator i;
1062
1063         /* If we don't know on which link a DNS packet would be
1064          * delivered, let's find the largest MTU that works on all
1065          * interfaces we know of */
1066
1067         HASHMAP_FOREACH(l, m->links, i) {
1068                 if (l->mtu <= 0)
1069                         continue;
1070
1071                 if (mtu <= 0 || l->mtu < mtu)
1072                         mtu = l->mtu;
1073         }
1074
1075         return mtu;
1076 }
1077
1078 int manager_find_ifindex(Manager *m, int family, const union in_addr_union *in_addr) {
1079         LinkAddress *a;
1080
1081         assert(m);
1082
1083         a = manager_find_link_address(m, family, in_addr);
1084         if (a)
1085                 return a->link->ifindex;
1086
1087         return 0;
1088 }
1089
1090 void manager_refresh_rrs(Manager *m) {
1091         Iterator i;
1092         Link *l;
1093         DnssdService *s;
1094
1095         assert(m);
1096
1097         m->llmnr_host_ipv4_key = dns_resource_key_unref(m->llmnr_host_ipv4_key);
1098         m->llmnr_host_ipv6_key = dns_resource_key_unref(m->llmnr_host_ipv6_key);
1099         m->mdns_host_ipv4_key = dns_resource_key_unref(m->mdns_host_ipv4_key);
1100         m->mdns_host_ipv6_key = dns_resource_key_unref(m->mdns_host_ipv6_key);
1101
1102         if (m->mdns_support == RESOLVE_SUPPORT_YES)
1103                 HASHMAP_FOREACH(s, m->dnssd_services, i)
1104                         if (dnssd_update_rrs(s) < 0)
1105                                 log_warning("Failed to refresh DNS-SD service '%s'", s->name);
1106
1107         HASHMAP_FOREACH(l, m->links, i) {
1108                 link_add_rrs(l, true);
1109                 link_add_rrs(l, false);
1110         }
1111 }
1112
1113 static int manager_next_random_name(const char *old, char **ret_new) {
1114         const char *p;
1115         uint64_t u, a;
1116         char *n;
1117
1118         p = strchr(old, 0);
1119         assert(p);
1120
1121         while (p > old) {
1122                 if (!strchr(DIGITS, p[-1]))
1123                         break;
1124
1125                 p--;
1126         }
1127
1128         if (*p == 0 || safe_atou64(p, &u) < 0 || u <= 0)
1129                 u = 1;
1130
1131         /* Add a random number to the old value. This way we can avoid
1132          * that two hosts pick the same hostname, win on IPv4 and lose
1133          * on IPv6 (or vice versa), and pick the same hostname
1134          * replacement hostname, ad infinitum. We still want the
1135          * numbers to go up monotonically, hence we just add a random
1136          * value 1..10 */
1137
1138         random_bytes(&a, sizeof(a));
1139         u += 1 + a % 10;
1140
1141         if (asprintf(&n, "%.*s%" PRIu64, (int) (p - old), old, u) < 0)
1142                 return -ENOMEM;
1143
1144         *ret_new = n;
1145
1146         return 0;
1147 }
1148
1149 int manager_next_hostname(Manager *m) {
1150         _cleanup_free_ char *h = NULL, *k = NULL;
1151         int r;
1152
1153         assert(m);
1154
1155         r = manager_next_random_name(m->llmnr_hostname, &h);
1156         if (r < 0)
1157                 return r;
1158
1159         r = dns_name_concat(h, "local", &k);
1160         if (r < 0)
1161                 return r;
1162
1163         log_info("Hostname conflict, changing published hostname from '%s' to '%s'.", m->llmnr_hostname, h);
1164
1165         free_and_replace(m->llmnr_hostname, h);
1166         free_and_replace(m->mdns_hostname, k);
1167
1168         manager_refresh_rrs(m);
1169
1170         return 0;
1171 }
1172
1173 LinkAddress* manager_find_link_address(Manager *m, int family, const union in_addr_union *in_addr) {
1174         Iterator i;
1175         Link *l;
1176
1177         assert(m);
1178
1179         HASHMAP_FOREACH(l, m->links, i) {
1180                 LinkAddress *a;
1181
1182                 a = link_find_address(l, family, in_addr);
1183                 if (a)
1184                         return a;
1185         }
1186
1187         return NULL;
1188 }
1189
1190 bool manager_our_packet(Manager *m, DnsPacket *p) {
1191         assert(m);
1192         assert(p);
1193
1194         return !!manager_find_link_address(m, p->family, &p->sender);
1195 }
1196
1197 DnsScope* manager_find_scope(Manager *m, DnsPacket *p) {
1198         Link *l;
1199
1200         assert(m);
1201         assert(p);
1202
1203         l = hashmap_get(m->links, INT_TO_PTR(p->ifindex));
1204         if (!l)
1205                 return NULL;
1206
1207         switch (p->protocol) {
1208         case DNS_PROTOCOL_LLMNR:
1209                 if (p->family == AF_INET)
1210                         return l->llmnr_ipv4_scope;
1211                 else if (p->family == AF_INET6)
1212                         return l->llmnr_ipv6_scope;
1213
1214                 break;
1215
1216         case DNS_PROTOCOL_MDNS:
1217                 if (p->family == AF_INET)
1218                         return l->mdns_ipv4_scope;
1219                 else if (p->family == AF_INET6)
1220                         return l->mdns_ipv6_scope;
1221
1222                 break;
1223
1224         default:
1225                 break;
1226         }
1227
1228         return NULL;
1229 }
1230
1231 void manager_verify_all(Manager *m) {
1232         DnsScope *s;
1233
1234         assert(m);
1235
1236         LIST_FOREACH(scopes, s, m->dns_scopes)
1237                 dns_zone_verify_all(&s->zone);
1238 }
1239
1240 int manager_is_own_hostname(Manager *m, const char *name) {
1241         int r;
1242
1243         assert(m);
1244         assert(name);
1245
1246         if (m->llmnr_hostname) {
1247                 r = dns_name_equal(name, m->llmnr_hostname);
1248                 if (r != 0)
1249                         return r;
1250         }
1251
1252         if (m->mdns_hostname) {
1253                 r = dns_name_equal(name, m->mdns_hostname);
1254                 if (r != 0)
1255                         return r;
1256         }
1257
1258         if (m->full_hostname)
1259                 return dns_name_equal(name, m->full_hostname);
1260
1261         return 0;
1262 }
1263
1264 int manager_compile_dns_servers(Manager *m, OrderedSet **dns) {
1265         DnsServer *s;
1266         Iterator i;
1267         Link *l;
1268         int r;
1269
1270         assert(m);
1271         assert(dns);
1272
1273         r = ordered_set_ensure_allocated(dns, &dns_server_hash_ops);
1274         if (r < 0)
1275                 return r;
1276
1277         /* First add the system-wide servers and domains */
1278         LIST_FOREACH(servers, s, m->dns_servers) {
1279                 r = ordered_set_put(*dns, s);
1280                 if (r == -EEXIST)
1281                         continue;
1282                 if (r < 0)
1283                         return r;
1284         }
1285
1286         /* Then, add the per-link servers */
1287         HASHMAP_FOREACH(l, m->links, i) {
1288                 LIST_FOREACH(servers, s, l->dns_servers) {
1289                         r = ordered_set_put(*dns, s);
1290                         if (r == -EEXIST)
1291                                 continue;
1292                         if (r < 0)
1293                                 return r;
1294                 }
1295         }
1296
1297         /* If we found nothing, add the fallback servers */
1298         if (ordered_set_isempty(*dns)) {
1299                 LIST_FOREACH(servers, s, m->fallback_dns_servers) {
1300                         r = ordered_set_put(*dns, s);
1301                         if (r == -EEXIST)
1302                                 continue;
1303                         if (r < 0)
1304                                 return r;
1305                 }
1306         }
1307
1308         return 0;
1309 }
1310
1311 /* filter_route is a tri-state:
1312  *   < 0: no filtering
1313  *   = 0 or false: return only domains which should be used for searching
1314  *   > 0 or true: return only domains which are for routing only
1315  */
1316 int manager_compile_search_domains(Manager *m, OrderedSet **domains, int filter_route) {
1317         DnsSearchDomain *d;
1318         Iterator i;
1319         Link *l;
1320         int r;
1321
1322         assert(m);
1323         assert(domains);
1324
1325         r = ordered_set_ensure_allocated(domains, &dns_name_hash_ops);
1326         if (r < 0)
1327                 return r;
1328
1329         LIST_FOREACH(domains, d, m->search_domains) {
1330
1331                 if (filter_route >= 0 &&
1332                     d->route_only != !!filter_route)
1333                         continue;
1334
1335                 r = ordered_set_put(*domains, d->name);
1336                 if (r == -EEXIST)
1337                         continue;
1338                 if (r < 0)
1339                         return r;
1340         }
1341
1342         HASHMAP_FOREACH(l, m->links, i) {
1343
1344                 LIST_FOREACH(domains, d, l->search_domains) {
1345
1346                         if (filter_route >= 0 &&
1347                             d->route_only != !!filter_route)
1348                                 continue;
1349
1350                         r = ordered_set_put(*domains, d->name);
1351                         if (r == -EEXIST)
1352                                 continue;
1353                         if (r < 0)
1354                                 return r;
1355                 }
1356         }
1357
1358         return 0;
1359 }
1360
1361 DnssecMode manager_get_dnssec_mode(Manager *m) {
1362         assert(m);
1363
1364         if (m->dnssec_mode != _DNSSEC_MODE_INVALID)
1365                 return m->dnssec_mode;
1366
1367         return DNSSEC_NO;
1368 }
1369
1370 bool manager_dnssec_supported(Manager *m) {
1371         DnsServer *server;
1372         Iterator i;
1373         Link *l;
1374
1375         assert(m);
1376
1377         if (manager_get_dnssec_mode(m) == DNSSEC_NO)
1378                 return false;
1379
1380         server = manager_get_dns_server(m);
1381         if (server && !dns_server_dnssec_supported(server))
1382                 return false;
1383
1384         HASHMAP_FOREACH(l, m->links, i)
1385                 if (!link_dnssec_supported(l))
1386                         return false;
1387
1388         return true;
1389 }
1390
1391 DnsOverTlsMode manager_get_dns_over_tls_mode(Manager *m) {
1392         assert(m);
1393
1394         if (m->dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID)
1395                 return m->dns_over_tls_mode;
1396
1397         return DNS_OVER_TLS_NO;
1398 }
1399
1400 void manager_dnssec_verdict(Manager *m, DnssecVerdict verdict, const DnsResourceKey *key) {
1401
1402         assert(verdict >= 0);
1403         assert(verdict < _DNSSEC_VERDICT_MAX);
1404
1405         if (DEBUG_LOGGING) {
1406                 char s[DNS_RESOURCE_KEY_STRING_MAX];
1407
1408                 log_debug("Found verdict for lookup %s: %s",
1409                           dns_resource_key_to_string(key, s, sizeof s),
1410                           dnssec_verdict_to_string(verdict));
1411         }
1412
1413         m->n_dnssec_verdict[verdict]++;
1414 }
1415
1416 bool manager_routable(Manager *m, int family) {
1417         Iterator i;
1418         Link *l;
1419
1420         assert(m);
1421
1422         /* Returns true if the host has at least one interface with a routable address of the specified type */
1423
1424         HASHMAP_FOREACH(l, m->links, i)
1425                 if (link_relevant(l, family, false))
1426                         return true;
1427
1428         return false;
1429 }
1430
1431 void manager_flush_caches(Manager *m) {
1432         DnsScope *scope;
1433
1434         assert(m);
1435
1436         LIST_FOREACH(scopes, scope, m->dns_scopes)
1437                 dns_cache_flush(&scope->cache);
1438
1439         log_info("Flushed all caches.");
1440 }
1441
1442 void manager_reset_server_features(Manager *m) {
1443         Iterator i;
1444         Link *l;
1445
1446         dns_server_reset_features_all(m->dns_servers);
1447         dns_server_reset_features_all(m->fallback_dns_servers);
1448
1449         HASHMAP_FOREACH(l, m->links, i)
1450                 dns_server_reset_features_all(l->dns_servers);
1451
1452         log_info("Resetting learnt feature levels on all servers.");
1453 }
1454
1455 void manager_cleanup_saved_user(Manager *m) {
1456         _cleanup_closedir_ DIR *d = NULL;
1457         struct dirent *de;
1458         int r;
1459
1460         assert(m);
1461
1462         /* Clean up all saved per-link files in /run/systemd/resolve/netif/ that don't have a matching interface
1463          * anymore. These files are created to persist settings pushed in by the user via the bus, so that resolved can
1464          * be restarted without losing this data. */
1465
1466         d = opendir("/run/systemd/resolve/netif/");
1467         if (!d) {
1468                 if (errno == ENOENT)
1469                         return;
1470
1471                 log_warning_errno(errno, "Failed to open interface directory: %m");
1472                 return;
1473         }
1474
1475         FOREACH_DIRENT_ALL(de, d, log_error_errno(errno, "Failed to read interface directory: %m")) {
1476                 _cleanup_free_ char *p = NULL;
1477                 int ifindex;
1478                 Link *l;
1479
1480                 if (!IN_SET(de->d_type, DT_UNKNOWN, DT_REG))
1481                         continue;
1482
1483                 if (dot_or_dot_dot(de->d_name))
1484                         continue;
1485
1486                 r = parse_ifindex(de->d_name, &ifindex);
1487                 if (r < 0) /* Probably some temporary file from a previous run. Delete it */
1488                         goto rm;
1489
1490                 l = hashmap_get(m->links, INT_TO_PTR(ifindex));
1491                 if (!l) /* link vanished */
1492                         goto rm;
1493
1494                 if (l->is_managed) /* now managed by networkd, hence the bus settings are useless */
1495                         goto rm;
1496
1497                 continue;
1498
1499         rm:
1500                 p = strappend("/run/systemd/resolve/netif/", de->d_name);
1501                 if (!p) {
1502                         log_oom();
1503                         return;
1504                 }
1505
1506                 (void) unlink(p);
1507         }
1508 }
1509
1510 bool manager_next_dnssd_names(Manager *m) {
1511         Iterator i;
1512         DnssdService *s;
1513         bool tried = false;
1514         int r;
1515
1516         assert(m);
1517
1518         HASHMAP_FOREACH(s, m->dnssd_services, i) {
1519                 _cleanup_free_ char * new_name = NULL;
1520
1521                 if (!s->withdrawn)
1522                         continue;
1523
1524                 r = manager_next_random_name(s->name_template, &new_name);
1525                 if (r < 0) {
1526                         log_warning_errno(r, "Failed to get new name for service '%s': %m", s->name);
1527                         continue;
1528                 }
1529
1530                 free_and_replace(s->name_template, new_name);
1531
1532                 s->withdrawn = false;
1533
1534                 tried = true;
1535         }
1536
1537         if (tried)
1538                 manager_refresh_rrs(m);
1539
1540         return tried;
1541 }