src/resolve/resolved-manager.c

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