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 #if ENABLE_DNS_OVER_TLS
 601         r = dnstls_manager_init(m);
 602         if (r < 0)
 603                 return r;
 604 #endif
 605
 606         r = sd_event_default(&m->event);
 607         if (r < 0)
 608                 return r;
 609
 610         (void) sd_event_add_signal(m->event, NULL, SIGTERM, NULL,  NULL);
 611         (void) sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
 612
 613         (void) sd_event_set_watchdog(m->event, true);
 614
 615         r = manager_watch_hostname(m);
 616         if (r < 0)
 617                 return r;
 618
 619         r = dnssd_load(m);
 620         if (r < 0)
 621                 log_warning_errno(r, "Failed to load DNS-SD configuration files: %m");
 622
 623         r = dns_scope_new(m, &m->unicast_scope, NULL, DNS_PROTOCOL_DNS, AF_UNSPEC);
 624         if (r < 0)
 625                 return r;
 626
 627         r = manager_network_monitor_listen(m);
 628         if (r < 0)
 629                 return r;
 630
 631         r = manager_rtnl_listen(m);
 632         if (r < 0)
 633                 return r;
 634
 635         r = manager_connect_bus(m);
 636         if (r < 0)
 637                 return r;
 638
 639         (void) sd_event_add_signal(m->event, &m->sigusr1_event_source, SIGUSR1, manager_sigusr1, m);
 640         (void) sd_event_add_signal(m->event, &m->sigusr2_event_source, SIGUSR2, manager_sigusr2, m);
 641         (void) sd_event_add_signal(m->event, &m->sigrtmin1_event_source, SIGRTMIN+1, manager_sigrtmin1, m);
 642
 643         manager_cleanup_saved_user(m);
 644
 645         *ret = TAKE_PTR(m);
 646
 647         return 0;
 648 }
 649
 650 int manager_start(Manager *m) {
 651         int r;
 652
 653         assert(m);
 654
 655         r = manager_dns_stub_start(m);
 656         if (r < 0)
 657                 return r;
 658
 659         return 0;
 660 }
 661
 662 Manager *manager_free(Manager *m) {
 663         Link *l;
 664         DnssdService *s;
 665
 666         if (!m)
 667                 return NULL;
 668
 669         dns_server_unlink_all(m->dns_servers);
 670         dns_server_unlink_all(m->fallback_dns_servers);
 671         dns_search_domain_unlink_all(m->search_domains);
 672
 673         while ((l = hashmap_first(m->links)))
 674                link_free(l);
 675
 676         while (m->dns_queries)
 677                 dns_query_free(m->dns_queries);
 678
 679         dns_scope_free(m->unicast_scope);
 680
 681         /* At this point only orphaned streams should remain. All others should have been freed already by their
 682          * owners */
 683         while (m->dns_streams)
 684                 dns_stream_unref(m->dns_streams);
 685
 686 #if ENABLE_DNS_OVER_TLS
 687         dnstls_manager_free(m);
 688 #endif
 689
 690         hashmap_free(m->links);
 691         hashmap_free(m->dns_transactions);
 692
 693         sd_event_source_unref(m->network_event_source);
 694         sd_network_monitor_unref(m->network_monitor);
 695
 696         sd_netlink_unref(m->rtnl);
 697         sd_event_source_unref(m->rtnl_event_source);
 698
 699         manager_llmnr_stop(m);
 700         manager_mdns_stop(m);
 701         manager_dns_stub_stop(m);
 702
 703         sd_bus_flush_close_unref(m->bus);
 704
 705         sd_event_source_unref(m->sigusr1_event_source);
 706         sd_event_source_unref(m->sigusr2_event_source);
 707         sd_event_source_unref(m->sigrtmin1_event_source);
 708
 709         sd_event_unref(m->event);
 710
 711         dns_resource_key_unref(m->llmnr_host_ipv4_key);
 712         dns_resource_key_unref(m->llmnr_host_ipv6_key);
 713         dns_resource_key_unref(m->mdns_host_ipv4_key);
 714         dns_resource_key_unref(m->mdns_host_ipv6_key);
 715
 716         sd_event_source_unref(m->hostname_event_source);
 717         safe_close(m->hostname_fd);
 718
 719         free(m->full_hostname);
 720         free(m->llmnr_hostname);
 721         free(m->mdns_hostname);
 722
 723         while ((s = hashmap_first(m->dnssd_services)))
 724                dnssd_service_free(s);
 725         hashmap_free(m->dnssd_services);
 726
 727         dns_trust_anchor_flush(&m->trust_anchor);
 728         manager_etc_hosts_flush(m);
 729
 730         return mfree(m);
 731 }
 732
 733 int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) {
 734         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 735         union {
 736                 struct cmsghdr header; /* For alignment */
 737                 uint8_t buffer[CMSG_SPACE(MAXSIZE(struct in_pktinfo, struct in6_pktinfo))
 738                                + CMSG_SPACE(int) /* ttl/hoplimit */
 739                                + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */];
 740         } control;
 741         union sockaddr_union sa;
 742         struct iovec iov;
 743         struct msghdr mh = {
 744                 .msg_name = &sa.sa,
 745                 .msg_namelen = sizeof(sa),
 746                 .msg_iov = &iov,
 747                 .msg_iovlen = 1,
 748                 .msg_control = &control,
 749                 .msg_controllen = sizeof(control),
 750         };
 751         struct cmsghdr *cmsg;
 752         ssize_t ms, l;
 753         int r;
 754
 755         assert(m);
 756         assert(fd >= 0);
 757         assert(ret);
 758
 759         ms = next_datagram_size_fd(fd);
 760         if (ms < 0)
 761                 return ms;
 762
 763         r = dns_packet_new(&p, protocol, ms, DNS_PACKET_SIZE_MAX);
 764         if (r < 0)
 765                 return r;
 766
 767         iov = IOVEC_MAKE(DNS_PACKET_DATA(p), p->allocated);
 768
 769         l = recvmsg(fd, &mh, 0);
 770         if (l < 0) {
 771                 if (IN_SET(errno, EAGAIN, EINTR))
 772                         return 0;
 773
 774                 return -errno;
 775         }
 776         if (l == 0)
 777                 return 0;
 778
 779         assert(!(mh.msg_flags & MSG_CTRUNC));
 780         assert(!(mh.msg_flags & MSG_TRUNC));
 781
 782         p->size = (size_t) l;
 783
 784         p->family = sa.sa.sa_family;
 785         p->ipproto = IPPROTO_UDP;
 786         if (p->family == AF_INET) {
 787                 p->sender.in = sa.in.sin_addr;
 788                 p->sender_port = be16toh(sa.in.sin_port);
 789         } else if (p->family == AF_INET6) {
 790                 p->sender.in6 = sa.in6.sin6_addr;
 791                 p->sender_port = be16toh(sa.in6.sin6_port);
 792                 p->ifindex = sa.in6.sin6_scope_id;
 793         } else
 794                 return -EAFNOSUPPORT;
 795
 796         CMSG_FOREACH(cmsg, &mh) {
 797
 798                 if (cmsg->cmsg_level == IPPROTO_IPV6) {
 799                         assert(p->family == AF_INET6);
 800
 801                         switch (cmsg->cmsg_type) {
 802
 803                         case IPV6_PKTINFO: {
 804                                 struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg);
 805
 806                                 if (p->ifindex <= 0)
 807                                         p->ifindex = i->ipi6_ifindex;
 808
 809                                 p->destination.in6 = i->ipi6_addr;
 810                                 break;
 811                         }
 812
 813                         case IPV6_HOPLIMIT:
 814                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 815                                 break;
 816
 817                         }
 818                 } else if (cmsg->cmsg_level == IPPROTO_IP) {
 819                         assert(p->family == AF_INET);
 820
 821                         switch (cmsg->cmsg_type) {
 822
 823                         case IP_PKTINFO: {
 824                                 struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg);
 825
 826                                 if (p->ifindex <= 0)
 827                                         p->ifindex = i->ipi_ifindex;
 828
 829                                 p->destination.in = i->ipi_addr;
 830                                 break;
 831                         }
 832
 833                         case IP_TTL:
 834                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 835                                 break;
 836                         }
 837                 }
 838         }
 839
 840         /* The Linux kernel sets the interface index to the loopback
 841          * device if the packet came from the local host since it
 842          * avoids the routing table in such a case. Let's unset the
 843          * interface index in such a case. */
 844         if (p->ifindex == LOOPBACK_IFINDEX)
 845                 p->ifindex = 0;
 846
 847         if (protocol != DNS_PROTOCOL_DNS) {
 848                 /* If we don't know the interface index still, we look for the
 849                  * first local interface with a matching address. Yuck! */
 850                 if (p->ifindex <= 0)
 851                         p->ifindex = manager_find_ifindex(m, p->family, &p->destination);
 852         }
 853
 854         *ret = TAKE_PTR(p);
 855
 856         return 1;
 857 }
 858
 859 static int sendmsg_loop(int fd, struct msghdr *mh, int flags) {
 860         int r;
 861
 862         assert(fd >= 0);
 863         assert(mh);
 864
 865         for (;;) {
 866                 if (sendmsg(fd, mh, flags) >= 0)
 867                         return 0;
 868
 869                 if (errno == EINTR)
 870                         continue;
 871
 872                 if (errno != EAGAIN)
 873                         return -errno;
 874
 875                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
 876                 if (r < 0)
 877                         return r;
 878                 if (r == 0)
 879                         return -ETIMEDOUT;
 880         }
 881 }
 882
 883 static int write_loop(int fd, void *message, size_t length) {
 884         int r;
 885
 886         assert(fd >= 0);
 887         assert(message);
 888
 889         for (;;) {
 890                 if (write(fd, message, length) >= 0)
 891                         return 0;
 892
 893                 if (errno == EINTR)
 894                         continue;
 895
 896                 if (errno != EAGAIN)
 897                         return -errno;
 898
 899                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
 900                 if (r < 0)
 901                         return r;
 902                 if (r == 0)
 903                         return -ETIMEDOUT;
 904         }
 905 }
 906
 907 int manager_write(Manager *m, int fd, DnsPacket *p) {
 908         int r;
 909
 910         log_debug("Sending %s packet with id %" PRIu16 ".", DNS_PACKET_QR(p) ? "response" : "query", DNS_PACKET_ID(p));
 911
 912         r = write_loop(fd, DNS_PACKET_DATA(p), p->size);
 913         if (r < 0)
 914                 return r;
 915
 916         return 0;
 917 }
 918
 919 static int manager_ipv4_send(
 920                 Manager *m,
 921                 int fd,
 922                 int ifindex,
 923                 const struct in_addr *destination,
 924                 uint16_t port,
 925                 const struct in_addr *source,
 926                 DnsPacket *p) {
 927         union {
 928                 struct cmsghdr header; /* For alignment */
 929                 uint8_t buffer[CMSG_SPACE(sizeof(struct in_pktinfo))];
 930         } control = {};
 931         union sockaddr_union sa;
 932         struct iovec iov;
 933         struct msghdr mh = {
 934                 .msg_iov = &iov,
 935                 .msg_iovlen = 1,
 936                 .msg_name = &sa.sa,
 937                 .msg_namelen = sizeof(sa.in),
 938         };
 939
 940         assert(m);
 941         assert(fd >= 0);
 942         assert(destination);
 943         assert(port > 0);
 944         assert(p);
 945
 946         iov = IOVEC_MAKE(DNS_PACKET_DATA(p), p->size);
 947
 948         sa = (union sockaddr_union) {
 949                 .in.sin_family = AF_INET,
 950                 .in.sin_addr = *destination,
 951                 .in.sin_port = htobe16(port),
 952         };
 953
 954         if (ifindex > 0) {
 955                 struct cmsghdr *cmsg;
 956                 struct in_pktinfo *pi;
 957
 958                 mh.msg_control = &control;
 959                 mh.msg_controllen = CMSG_LEN(sizeof(struct in_pktinfo));
 960
 961                 cmsg = CMSG_FIRSTHDR(&mh);
 962                 cmsg->cmsg_len = mh.msg_controllen;
 963                 cmsg->cmsg_level = IPPROTO_IP;
 964                 cmsg->cmsg_type = IP_PKTINFO;
 965
 966                 pi = (struct in_pktinfo*) CMSG_DATA(cmsg);
 967                 pi->ipi_ifindex = ifindex;
 968
 969                 if (source)
 970                         pi->ipi_spec_dst = *source;
 971         }
 972
 973         return sendmsg_loop(fd, &mh, 0);
 974 }
 975
 976 static int manager_ipv6_send(
 977                 Manager *m,
 978                 int fd,
 979                 int ifindex,
 980                 const struct in6_addr *destination,
 981                 uint16_t port,
 982                 const struct in6_addr *source,
 983                 DnsPacket *p) {
 984
 985         union {
 986                 struct cmsghdr header; /* For alignment */
 987                 uint8_t buffer[CMSG_SPACE(sizeof(struct in6_pktinfo))];
 988         } control = {};
 989         union sockaddr_union sa;
 990         struct iovec iov;
 991         struct msghdr mh = {
 992                 .msg_iov = &iov,
 993                 .msg_iovlen = 1,
 994                 .msg_name = &sa.sa,
 995                 .msg_namelen = sizeof(sa.in6),
 996         };
 997
 998         assert(m);
 999         assert(fd >= 0);
1000         assert(destination);
1001         assert(port > 0);
1002         assert(p);
1003
1004         iov = IOVEC_MAKE(DNS_PACKET_DATA(p), p->size);
1005
1006         sa = (union sockaddr_union) {
1007                 .in6.sin6_family = AF_INET6,
1008                 .in6.sin6_addr = *destination,
1009                 .in6.sin6_port = htobe16(port),
1010                 .in6.sin6_scope_id = ifindex,
1011         };
1012
1013         if (ifindex > 0) {
1014                 struct cmsghdr *cmsg;
1015                 struct in6_pktinfo *pi;
1016
1017                 mh.msg_control = &control;
1018                 mh.msg_controllen = CMSG_LEN(sizeof(struct in6_pktinfo));
1019
1020                 cmsg = CMSG_FIRSTHDR(&mh);
1021                 cmsg->cmsg_len = mh.msg_controllen;
1022                 cmsg->cmsg_level = IPPROTO_IPV6;
1023                 cmsg->cmsg_type = IPV6_PKTINFO;
1024
1025                 pi = (struct in6_pktinfo*) CMSG_DATA(cmsg);
1026                 pi->ipi6_ifindex = ifindex;
1027
1028                 if (source)
1029                         pi->ipi6_addr = *source;
1030         }
1031
1032         return sendmsg_loop(fd, &mh, 0);
1033 }
1034
1035 int manager_send(
1036                 Manager *m,
1037                 int fd,
1038                 int ifindex,
1039                 int family,
1040                 const union in_addr_union *destination,
1041                 uint16_t port,
1042                 const union in_addr_union *source,
1043                 DnsPacket *p) {
1044
1045         assert(m);
1046         assert(fd >= 0);
1047         assert(destination);
1048         assert(port > 0);
1049         assert(p);
1050
1051         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));
1052
1053         if (family == AF_INET)
1054                 return manager_ipv4_send(m, fd, ifindex, &destination->in, port, source ? &source->in : NULL, p);
1055         if (family == AF_INET6)
1056                 return manager_ipv6_send(m, fd, ifindex, &destination->in6, port, source ? &source->in6 : NULL, p);
1057
1058         return -EAFNOSUPPORT;
1059 }
1060
1061 uint32_t manager_find_mtu(Manager *m) {
1062         uint32_t mtu = 0;
1063         Link *l;
1064         Iterator i;
1065
1066         /* If we don't know on which link a DNS packet would be
1067          * delivered, let's find the largest MTU that works on all
1068          * interfaces we know of */
1069
1070         HASHMAP_FOREACH(l, m->links, i) {
1071                 if (l->mtu <= 0)
1072                         continue;
1073
1074                 if (mtu <= 0 || l->mtu < mtu)
1075                         mtu = l->mtu;
1076         }
1077
1078         return mtu;
1079 }
1080
1081 int manager_find_ifindex(Manager *m, int family, const union in_addr_union *in_addr) {
1082         LinkAddress *a;
1083
1084         assert(m);
1085
1086         a = manager_find_link_address(m, family, in_addr);
1087         if (a)
1088                 return a->link->ifindex;
1089
1090         return 0;
1091 }
1092
1093 void manager_refresh_rrs(Manager *m) {
1094         Iterator i;
1095         Link *l;
1096         DnssdService *s;
1097
1098         assert(m);
1099
1100         m->llmnr_host_ipv4_key = dns_resource_key_unref(m->llmnr_host_ipv4_key);
1101         m->llmnr_host_ipv6_key = dns_resource_key_unref(m->llmnr_host_ipv6_key);
1102         m->mdns_host_ipv4_key = dns_resource_key_unref(m->mdns_host_ipv4_key);
1103         m->mdns_host_ipv6_key = dns_resource_key_unref(m->mdns_host_ipv6_key);
1104
1105         if (m->mdns_support == RESOLVE_SUPPORT_YES)
1106                 HASHMAP_FOREACH(s, m->dnssd_services, i)
1107                         if (dnssd_update_rrs(s) < 0)
1108                                 log_warning("Failed to refresh DNS-SD service '%s'", s->name);
1109
1110         HASHMAP_FOREACH(l, m->links, i) {
1111                 link_add_rrs(l, true);
1112                 link_add_rrs(l, false);
1113         }
1114 }
1115
1116 static int manager_next_random_name(const char *old, char **ret_new) {
1117         const char *p;
1118         uint64_t u, a;
1119         char *n;
1120
1121         p = strchr(old, 0);
1122         assert(p);
1123
1124         while (p > old) {
1125                 if (!strchr(DIGITS, p[-1]))
1126                         break;
1127
1128                 p--;
1129         }
1130
1131         if (*p == 0 || safe_atou64(p, &u) < 0 || u <= 0)
1132                 u = 1;
1133
1134         /* Add a random number to the old value. This way we can avoid
1135          * that two hosts pick the same hostname, win on IPv4 and lose
1136          * on IPv6 (or vice versa), and pick the same hostname
1137          * replacement hostname, ad infinitum. We still want the
1138          * numbers to go up monotonically, hence we just add a random
1139          * value 1..10 */
1140
1141         random_bytes(&a, sizeof(a));
1142         u += 1 + a % 10;
1143
1144         if (asprintf(&n, "%.*s%" PRIu64, (int) (p - old), old, u) < 0)
1145                 return -ENOMEM;
1146
1147         *ret_new = n;
1148
1149         return 0;
1150 }
1151
1152 int manager_next_hostname(Manager *m) {
1153         _cleanup_free_ char *h = NULL, *k = NULL;
1154         int r;
1155
1156         assert(m);
1157
1158         r = manager_next_random_name(m->llmnr_hostname, &h);
1159         if (r < 0)
1160                 return r;
1161
1162         r = dns_name_concat(h, "local", 0, &k);
1163         if (r < 0)
1164                 return r;
1165
1166         log_info("Hostname conflict, changing published hostname from '%s' to '%s'.", m->llmnr_hostname, h);
1167
1168         free_and_replace(m->llmnr_hostname, h);
1169         free_and_replace(m->mdns_hostname, k);
1170
1171         manager_refresh_rrs(m);
1172
1173         return 0;
1174 }
1175
1176 LinkAddress* manager_find_link_address(Manager *m, int family, const union in_addr_union *in_addr) {
1177         Iterator i;
1178         Link *l;
1179
1180         assert(m);
1181
1182         HASHMAP_FOREACH(l, m->links, i) {
1183                 LinkAddress *a;
1184
1185                 a = link_find_address(l, family, in_addr);
1186                 if (a)
1187                         return a;
1188         }
1189
1190         return NULL;
1191 }
1192
1193 bool manager_our_packet(Manager *m, DnsPacket *p) {
1194         assert(m);
1195         assert(p);
1196
1197         return !!manager_find_link_address(m, p->family, &p->sender);
1198 }
1199
1200 DnsScope* manager_find_scope(Manager *m, DnsPacket *p) {
1201         Link *l;
1202
1203         assert(m);
1204         assert(p);
1205
1206         l = hashmap_get(m->links, INT_TO_PTR(p->ifindex));
1207         if (!l)
1208                 return NULL;
1209
1210         switch (p->protocol) {
1211         case DNS_PROTOCOL_LLMNR:
1212                 if (p->family == AF_INET)
1213                         return l->llmnr_ipv4_scope;
1214                 else if (p->family == AF_INET6)
1215                         return l->llmnr_ipv6_scope;
1216
1217                 break;
1218
1219         case DNS_PROTOCOL_MDNS:
1220                 if (p->family == AF_INET)
1221                         return l->mdns_ipv4_scope;
1222                 else if (p->family == AF_INET6)
1223                         return l->mdns_ipv6_scope;
1224
1225                 break;
1226
1227         default:
1228                 break;
1229         }
1230
1231         return NULL;
1232 }
1233
1234 void manager_verify_all(Manager *m) {
1235         DnsScope *s;
1236
1237         assert(m);
1238
1239         LIST_FOREACH(scopes, s, m->dns_scopes)
1240                 dns_zone_verify_all(&s->zone);
1241 }
1242
1243 int manager_is_own_hostname(Manager *m, const char *name) {
1244         int r;
1245
1246         assert(m);
1247         assert(name);
1248
1249         if (m->llmnr_hostname) {
1250                 r = dns_name_equal(name, m->llmnr_hostname);
1251                 if (r != 0)
1252                         return r;
1253         }
1254
1255         if (m->mdns_hostname) {
1256                 r = dns_name_equal(name, m->mdns_hostname);
1257                 if (r != 0)
1258                         return r;
1259         }
1260
1261         if (m->full_hostname)
1262                 return dns_name_equal(name, m->full_hostname);
1263
1264         return 0;
1265 }
1266
1267 int manager_compile_dns_servers(Manager *m, OrderedSet **dns) {
1268         DnsServer *s;
1269         Iterator i;
1270         Link *l;
1271         int r;
1272
1273         assert(m);
1274         assert(dns);
1275
1276         r = ordered_set_ensure_allocated(dns, &dns_server_hash_ops);
1277         if (r < 0)
1278                 return r;
1279
1280         /* First add the system-wide servers and domains */
1281         LIST_FOREACH(servers, s, m->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         /* Then, add the per-link servers */
1290         HASHMAP_FOREACH(l, m->links, i) {
1291                 LIST_FOREACH(servers, s, l->dns_servers) {
1292                         r = ordered_set_put(*dns, s);
1293                         if (r == -EEXIST)
1294                                 continue;
1295                         if (r < 0)
1296                                 return r;
1297                 }
1298         }
1299
1300         /* If we found nothing, add the fallback servers */
1301         if (ordered_set_isempty(*dns)) {
1302                 LIST_FOREACH(servers, s, m->fallback_dns_servers) {
1303                         r = ordered_set_put(*dns, s);
1304                         if (r == -EEXIST)
1305                                 continue;
1306                         if (r < 0)
1307                                 return r;
1308                 }
1309         }
1310
1311         return 0;
1312 }
1313
1314 /* filter_route is a tri-state:
1315  *   < 0: no filtering
1316  *   = 0 or false: return only domains which should be used for searching
1317  *   > 0 or true: return only domains which are for routing only
1318  */
1319 int manager_compile_search_domains(Manager *m, OrderedSet **domains, int filter_route) {
1320         DnsSearchDomain *d;
1321         Iterator i;
1322         Link *l;
1323         int r;
1324
1325         assert(m);
1326         assert(domains);
1327
1328         r = ordered_set_ensure_allocated(domains, &dns_name_hash_ops);
1329         if (r < 0)
1330                 return r;
1331
1332         LIST_FOREACH(domains, d, m->search_domains) {
1333
1334                 if (filter_route >= 0 &&
1335                     d->route_only != !!filter_route)
1336                         continue;
1337
1338                 r = ordered_set_put(*domains, d->name);
1339                 if (r == -EEXIST)
1340                         continue;
1341                 if (r < 0)
1342                         return r;
1343         }
1344
1345         HASHMAP_FOREACH(l, m->links, i) {
1346
1347                 LIST_FOREACH(domains, d, l->search_domains) {
1348
1349                         if (filter_route >= 0 &&
1350                             d->route_only != !!filter_route)
1351                                 continue;
1352
1353                         r = ordered_set_put(*domains, d->name);
1354                         if (r == -EEXIST)
1355                                 continue;
1356                         if (r < 0)
1357                                 return r;
1358                 }
1359         }
1360
1361         return 0;
1362 }
1363
1364 DnssecMode manager_get_dnssec_mode(Manager *m) {
1365         assert(m);
1366
1367         if (m->dnssec_mode != _DNSSEC_MODE_INVALID)
1368                 return m->dnssec_mode;
1369
1370         return DNSSEC_NO;
1371 }
1372
1373 bool manager_dnssec_supported(Manager *m) {
1374         DnsServer *server;
1375         Iterator i;
1376         Link *l;
1377
1378         assert(m);
1379
1380         if (manager_get_dnssec_mode(m) == DNSSEC_NO)
1381                 return false;
1382
1383         server = manager_get_dns_server(m);
1384         if (server && !dns_server_dnssec_supported(server))
1385                 return false;
1386
1387         HASHMAP_FOREACH(l, m->links, i)
1388                 if (!link_dnssec_supported(l))
1389                         return false;
1390
1391         return true;
1392 }
1393
1394 DnsOverTlsMode manager_get_dns_over_tls_mode(Manager *m) {
1395         assert(m);
1396
1397         if (m->dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID)
1398                 return m->dns_over_tls_mode;
1399
1400         return DNS_OVER_TLS_NO;
1401 }
1402
1403 void manager_dnssec_verdict(Manager *m, DnssecVerdict verdict, const DnsResourceKey *key) {
1404
1405         assert(verdict >= 0);
1406         assert(verdict < _DNSSEC_VERDICT_MAX);
1407
1408         if (DEBUG_LOGGING) {
1409                 char s[DNS_RESOURCE_KEY_STRING_MAX];
1410
1411                 log_debug("Found verdict for lookup %s: %s",
1412                           dns_resource_key_to_string(key, s, sizeof s),
1413                           dnssec_verdict_to_string(verdict));
1414         }
1415
1416         m->n_dnssec_verdict[verdict]++;
1417 }
1418
1419 bool manager_routable(Manager *m, int family) {
1420         Iterator i;
1421         Link *l;
1422
1423         assert(m);
1424
1425         /* Returns true if the host has at least one interface with a routable address of the specified type */
1426
1427         HASHMAP_FOREACH(l, m->links, i)
1428                 if (link_relevant(l, family, false))
1429                         return true;
1430
1431         return false;
1432 }
1433
1434 void manager_flush_caches(Manager *m) {
1435         DnsScope *scope;
1436
1437         assert(m);
1438
1439         LIST_FOREACH(scopes, scope, m->dns_scopes)
1440                 dns_cache_flush(&scope->cache);
1441
1442         log_info("Flushed all caches.");
1443 }
1444
1445 void manager_reset_server_features(Manager *m) {
1446         Iterator i;
1447         Link *l;
1448
1449         dns_server_reset_features_all(m->dns_servers);
1450         dns_server_reset_features_all(m->fallback_dns_servers);
1451
1452         HASHMAP_FOREACH(l, m->links, i)
1453                 dns_server_reset_features_all(l->dns_servers);
1454
1455         log_info("Resetting learnt feature levels on all servers.");
1456 }
1457
1458 void manager_cleanup_saved_user(Manager *m) {
1459         _cleanup_closedir_ DIR *d = NULL;
1460         struct dirent *de;
1461         int r;
1462
1463         assert(m);
1464
1465         /* Clean up all saved per-link files in /run/systemd/resolve/netif/ that don't have a matching interface
1466          * anymore. These files are created to persist settings pushed in by the user via the bus, so that resolved can
1467          * be restarted without losing this data. */
1468
1469         d = opendir("/run/systemd/resolve/netif/");
1470         if (!d) {
1471                 if (errno == ENOENT)
1472                         return;
1473
1474                 log_warning_errno(errno, "Failed to open interface directory: %m");
1475                 return;
1476         }
1477
1478         FOREACH_DIRENT_ALL(de, d, log_error_errno(errno, "Failed to read interface directory: %m")) {
1479                 _cleanup_free_ char *p = NULL;
1480                 int ifindex;
1481                 Link *l;
1482
1483                 if (!IN_SET(de->d_type, DT_UNKNOWN, DT_REG))
1484                         continue;
1485
1486                 if (dot_or_dot_dot(de->d_name))
1487                         continue;
1488
1489                 r = parse_ifindex(de->d_name, &ifindex);
1490                 if (r < 0) /* Probably some temporary file from a previous run. Delete it */
1491                         goto rm;
1492
1493                 l = hashmap_get(m->links, INT_TO_PTR(ifindex));
1494                 if (!l) /* link vanished */
1495                         goto rm;
1496
1497                 if (l->is_managed) /* now managed by networkd, hence the bus settings are useless */
1498                         goto rm;
1499
1500                 continue;
1501
1502         rm:
1503                 p = strappend("/run/systemd/resolve/netif/", de->d_name);
1504                 if (!p) {
1505                         log_oom();
1506                         return;
1507                 }
1508
1509                 (void) unlink(p);
1510         }
1511 }
1512
1513 bool manager_next_dnssd_names(Manager *m) {
1514         Iterator i;
1515         DnssdService *s;
1516         bool tried = false;
1517         int r;
1518
1519         assert(m);
1520
1521         HASHMAP_FOREACH(s, m->dnssd_services, i) {
1522                 _cleanup_free_ char * new_name = NULL;
1523
1524                 if (!s->withdrawn)
1525                         continue;
1526
1527                 r = manager_next_random_name(s->name_template, &new_name);
1528                 if (r < 0) {
1529                         log_warning_errno(r, "Failed to get new name for service '%s': %m", s->name);
1530                         continue;
1531                 }
1532
1533                 free_and_replace(s->name_template, new_name);
1534
1535                 s->withdrawn = false;
1536
1537                 tried = true;
1538         }
1539
1540         if (tried)
1541                 manager_refresh_rrs(m);
1542
1543         return tried;
1544 }