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