src/resolve/resolved-manager.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2014 Tom Gundersen <teg@jklm.no>
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20  ***/
  21
  22 #include <netinet/in.h>
  23 #include <poll.h>
  24 #include <resolv.h>
  25 #include <sys/ioctl.h>
  26
  27 #include "af-list.h"
  28 #include "alloc-util.h"
  29 #include "dns-domain.h"
  30 #include "fd-util.h"
  31 #include "fileio-label.h"
  32 #include "hostname-util.h"
  33 #include "io-util.h"
  34 #include "netlink-util.h"
  35 #include "network-internal.h"
  36 #include "ordered-set.h"
  37 #include "parse-util.h"
  38 #include "random-util.h"
  39 #include "resolved-bus.h"
  40 #include "resolved-conf.h"
  41 #include "resolved-llmnr.h"
  42 #include "resolved-manager.h"
  43 #include "socket-util.h"
  44 #include "string-table.h"
  45 #include "string-util.h"
  46 #include "utf8.h"
  47
  48 #define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC)
  49
  50 static int manager_process_link(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
  51         Manager *m = userdata;
  52         uint16_t type;
  53         Link *l;
  54         int ifindex, r;
  55
  56         assert(rtnl);
  57         assert(m);
  58         assert(mm);
  59
  60         r = sd_netlink_message_get_type(mm, &type);
  61         if (r < 0)
  62                 goto fail;
  63
  64         r = sd_rtnl_message_link_get_ifindex(mm, &ifindex);
  65         if (r < 0)
  66                 goto fail;
  67
  68         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
  69
  70         switch (type) {
  71
  72         case RTM_NEWLINK:{
  73                 bool is_new = !l;
  74
  75                 if (!l) {
  76                         r = link_new(m, &l, ifindex);
  77                         if (r < 0)
  78                                 goto fail;
  79                 }
  80
  81                 r = link_update_rtnl(l, mm);
  82                 if (r < 0)
  83                         goto fail;
  84
  85                 r = link_update_monitor(l);
  86                 if (r < 0)
  87                         goto fail;
  88
  89                 if (is_new)
  90                         log_debug("Found new link %i/%s", ifindex, l->name);
  91
  92                 break;
  93         }
  94
  95         case RTM_DELLINK:
  96                 if (l) {
  97                         log_debug("Removing link %i/%s", l->ifindex, l->name);
  98                         link_free(l);
  99                 }
 100
 101                 break;
 102         }
 103
 104         return 0;
 105
 106 fail:
 107         log_warning_errno(r, "Failed to process RTNL link message: %m");
 108         return 0;
 109 }
 110
 111 static int manager_process_address(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
 112         Manager *m = userdata;
 113         union in_addr_union address;
 114         uint16_t type;
 115         int r, ifindex, family;
 116         LinkAddress *a;
 117         Link *l;
 118
 119         assert(rtnl);
 120         assert(mm);
 121         assert(m);
 122
 123         r = sd_netlink_message_get_type(mm, &type);
 124         if (r < 0)
 125                 goto fail;
 126
 127         r = sd_rtnl_message_addr_get_ifindex(mm, &ifindex);
 128         if (r < 0)
 129                 goto fail;
 130
 131         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
 132         if (!l)
 133                 return 0;
 134
 135         r = sd_rtnl_message_addr_get_family(mm, &family);
 136         if (r < 0)
 137                 goto fail;
 138
 139         switch (family) {
 140
 141         case AF_INET:
 142                 r = sd_netlink_message_read_in_addr(mm, IFA_LOCAL, &address.in);
 143                 if (r < 0) {
 144                         r = sd_netlink_message_read_in_addr(mm, IFA_ADDRESS, &address.in);
 145                         if (r < 0)
 146                                 goto fail;
 147                 }
 148
 149                 break;
 150
 151         case AF_INET6:
 152                 r = sd_netlink_message_read_in6_addr(mm, IFA_LOCAL, &address.in6);
 153                 if (r < 0) {
 154                         r = sd_netlink_message_read_in6_addr(mm, IFA_ADDRESS, &address.in6);
 155                         if (r < 0)
 156                                 goto fail;
 157                 }
 158
 159                 break;
 160
 161         default:
 162                 return 0;
 163         }
 164
 165         a = link_find_address(l, family, &address);
 166
 167         switch (type) {
 168
 169         case RTM_NEWADDR:
 170
 171                 if (!a) {
 172                         r = link_address_new(l, &a, family, &address);
 173                         if (r < 0)
 174                                 return r;
 175                 }
 176
 177                 r = link_address_update_rtnl(a, mm);
 178                 if (r < 0)
 179                         return r;
 180
 181                 break;
 182
 183         case RTM_DELADDR:
 184                 link_address_free(a);
 185                 break;
 186         }
 187
 188         return 0;
 189
 190 fail:
 191         log_warning_errno(r, "Failed to process RTNL address message: %m");
 192         return 0;
 193 }
 194
 195 static int manager_rtnl_listen(Manager *m) {
 196         _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
 197         sd_netlink_message *i;
 198         int r;
 199
 200         assert(m);
 201
 202         /* First, subscribe to interfaces coming and going */
 203         r = sd_netlink_open(&m->rtnl);
 204         if (r < 0)
 205                 return r;
 206
 207         r = sd_netlink_attach_event(m->rtnl, m->event, 0);
 208         if (r < 0)
 209                 return r;
 210
 211         r = sd_netlink_add_match(m->rtnl, RTM_NEWLINK, manager_process_link, m);
 212         if (r < 0)
 213                 return r;
 214
 215         r = sd_netlink_add_match(m->rtnl, RTM_DELLINK, manager_process_link, m);
 216         if (r < 0)
 217                 return r;
 218
 219         r = sd_netlink_add_match(m->rtnl, RTM_NEWADDR, manager_process_address, m);
 220         if (r < 0)
 221                 return r;
 222
 223         r = sd_netlink_add_match(m->rtnl, RTM_DELADDR, manager_process_address, m);
 224         if (r < 0)
 225                 return r;
 226
 227         /* Then, enumerate all links */
 228         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
 229         if (r < 0)
 230                 return r;
 231
 232         r = sd_netlink_message_request_dump(req, true);
 233         if (r < 0)
 234                 return r;
 235
 236         r = sd_netlink_call(m->rtnl, req, 0, &reply);
 237         if (r < 0)
 238                 return r;
 239
 240         for (i = reply; i; i = sd_netlink_message_next(i)) {
 241                 r = manager_process_link(m->rtnl, i, m);
 242                 if (r < 0)
 243                         return r;
 244         }
 245
 246         req = sd_netlink_message_unref(req);
 247         reply = sd_netlink_message_unref(reply);
 248
 249         /* Finally, enumerate all addresses, too */
 250         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, AF_UNSPEC);
 251         if (r < 0)
 252                 return r;
 253
 254         r = sd_netlink_message_request_dump(req, true);
 255         if (r < 0)
 256                 return r;
 257
 258         r = sd_netlink_call(m->rtnl, req, 0, &reply);
 259         if (r < 0)
 260                 return r;
 261
 262         for (i = reply; i; i = sd_netlink_message_next(i)) {
 263                 r = manager_process_address(m->rtnl, i, m);
 264                 if (r < 0)
 265                         return r;
 266         }
 267
 268         return r;
 269 }
 270
 271 static int on_network_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 272         Manager *m = userdata;
 273         Iterator i;
 274         Link *l;
 275         int r;
 276
 277         assert(m);
 278
 279         sd_network_monitor_flush(m->network_monitor);
 280
 281         HASHMAP_FOREACH(l, m->links, i) {
 282                 r = link_update_monitor(l);
 283                 if (r < 0)
 284                         log_warning_errno(r, "Failed to update monitor information for %i: %m", l->ifindex);
 285         }
 286
 287         r = manager_write_resolv_conf(m);
 288         if (r < 0)
 289                 log_warning_errno(r, "Could not update resolv.conf: %m");
 290
 291         return 0;
 292 }
 293
 294 static int manager_network_monitor_listen(Manager *m) {
 295         int r, fd, events;
 296
 297         assert(m);
 298
 299         r = sd_network_monitor_new(&m->network_monitor, NULL);
 300         if (r < 0)
 301                 return r;
 302
 303         fd = sd_network_monitor_get_fd(m->network_monitor);
 304         if (fd < 0)
 305                 return fd;
 306
 307         events = sd_network_monitor_get_events(m->network_monitor);
 308         if (events < 0)
 309                 return events;
 310
 311         r = sd_event_add_io(m->event, &m->network_event_source, fd, events, &on_network_event, m);
 312         if (r < 0)
 313                 return r;
 314
 315         return 0;
 316 }
 317
 318 static int determine_hostname(char **llmnr_hostname, char **mdns_hostname) {
 319         _cleanup_free_ char *h = NULL, *n = NULL;
 320         char label[DNS_LABEL_MAX];
 321         const char *p;
 322         int r, k;
 323
 324         assert(llmnr_hostname);
 325         assert(mdns_hostname);
 326
 327         /* Extract and normalize the first label of the locally
 328          * configured hostname, and check it's not "localhost". */
 329
 330         h = gethostname_malloc();
 331         if (!h)
 332                 return log_oom();
 333
 334         p = h;
 335         r = dns_label_unescape(&p, label, sizeof(label));
 336         if (r < 0)
 337                 return log_error_errno(r, "Failed to unescape host name: %m");
 338         if (r == 0) {
 339                 log_error("Couldn't find a single label in hosntame.");
 340                 return -EINVAL;
 341         }
 342
 343         k = dns_label_undo_idna(label, r, label, sizeof(label));
 344         if (k < 0)
 345                 return log_error_errno(k, "Failed to undo IDNA: %m");
 346         if (k > 0)
 347                 r = k;
 348
 349         if (!utf8_is_valid(label)) {
 350                 log_error("System hostname is not UTF-8 clean.");
 351                 return -EINVAL;
 352         }
 353
 354         r = dns_label_escape(label, r, &n);
 355         if (r < 0)
 356                 return log_error_errno(r, "Failed to escape host name: %m");
 357
 358         if (is_localhost(n)) {
 359                 log_debug("System hostname is 'localhost', ignoring.");
 360                 return -EINVAL;
 361         }
 362
 363         r = dns_name_concat(n, "local", mdns_hostname);
 364         if (r < 0)
 365                 return log_error_errno(r, "Failed to determine mDNS hostname: %m");
 366
 367         *llmnr_hostname = n;
 368         n = NULL;
 369
 370         return 0;
 371 }
 372
 373 static int on_hostname_change(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
 374         _cleanup_free_ char *llmnr_hostname = NULL, *mdns_hostname = NULL;
 375         Manager *m = userdata;
 376         int r;
 377
 378         assert(m);
 379
 380         r = determine_hostname(&llmnr_hostname, &mdns_hostname);
 381         if (r < 0)
 382                 return 0; /* ignore invalid hostnames */
 383
 384         if (streq(llmnr_hostname, m->llmnr_hostname) && streq(mdns_hostname, m->mdns_hostname))
 385                 return 0;
 386
 387         log_info("System hostname changed to '%s'.", llmnr_hostname);
 388
 389         free(m->llmnr_hostname);
 390         free(m->mdns_hostname);
 391
 392         m->llmnr_hostname = llmnr_hostname;
 393         m->mdns_hostname = mdns_hostname;
 394
 395         llmnr_hostname = mdns_hostname = NULL;
 396
 397         manager_refresh_rrs(m);
 398
 399         return 0;
 400 }
 401
 402 static int manager_watch_hostname(Manager *m) {
 403         int r;
 404
 405         assert(m);
 406
 407         m->hostname_fd = open("/proc/sys/kernel/hostname", O_RDONLY|O_CLOEXEC|O_NDELAY|O_NOCTTY);
 408         if (m->hostname_fd < 0) {
 409                 log_warning_errno(errno, "Failed to watch hostname: %m");
 410                 return 0;
 411         }
 412
 413         r = sd_event_add_io(m->event, &m->hostname_event_source, m->hostname_fd, 0, on_hostname_change, m);
 414         if (r < 0) {
 415                 if (r == -EPERM)
 416                         /* kernels prior to 3.2 don't support polling this file. Ignore the failure. */
 417                         m->hostname_fd = safe_close(m->hostname_fd);
 418                 else
 419                         return log_error_errno(r, "Failed to add hostname event source: %m");
 420         }
 421
 422         r = determine_hostname(&m->llmnr_hostname, &m->mdns_hostname);
 423         if (r < 0) {
 424                 log_info("Defaulting to hostname 'linux'.");
 425                 m->llmnr_hostname = strdup("linux");
 426                 if (!m->llmnr_hostname)
 427                         return log_oom();
 428
 429                 m->mdns_hostname = strdup("linux.local");
 430                 if (!m->mdns_hostname)
 431                         return log_oom();
 432         } else
 433                 log_info("Using system hostname '%s'.", m->llmnr_hostname);
 434
 435         return 0;
 436 }
 437
 438 static int manager_sigusr1(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
 439         _cleanup_free_ char *buffer = NULL;
 440         _cleanup_fclose_ FILE *f = NULL;
 441         Manager *m = userdata;
 442         size_t size = 0;
 443         DnsScope *scope;
 444
 445         assert(s);
 446         assert(si);
 447         assert(m);
 448
 449         f = open_memstream(&buffer, &size);
 450         if (!f)
 451                 return log_oom();
 452
 453         LIST_FOREACH(scopes, scope, m->dns_scopes)
 454                 dns_scope_dump(scope, f);
 455
 456         if (fflush_and_check(f) < 0)
 457                 return log_oom();
 458
 459         log_dump(LOG_INFO, buffer);
 460         return 0;
 461 }
 462
 463 int manager_new(Manager **ret) {
 464         _cleanup_(manager_freep) Manager *m = NULL;
 465         int r;
 466
 467         assert(ret);
 468
 469         m = new0(Manager, 1);
 470         if (!m)
 471                 return -ENOMEM;
 472
 473         m->llmnr_ipv4_udp_fd = m->llmnr_ipv6_udp_fd = -1;
 474         m->llmnr_ipv4_tcp_fd = m->llmnr_ipv6_tcp_fd = -1;
 475         m->hostname_fd = -1;
 476
 477         m->llmnr_support = SUPPORT_YES;
 478         m->read_resolv_conf = true;
 479
 480         r = manager_parse_dns_server(m, DNS_SERVER_FALLBACK, DNS_SERVERS);
 481         if (r < 0)
 482                 return r;
 483
 484         r = sd_event_default(&m->event);
 485         if (r < 0)
 486                 return r;
 487
 488         sd_event_add_signal(m->event, NULL, SIGTERM, NULL,  NULL);
 489         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
 490
 491         sd_event_set_watchdog(m->event, true);
 492
 493         r = manager_watch_hostname(m);
 494         if (r < 0)
 495                 return r;
 496
 497         r = dns_scope_new(m, &m->unicast_scope, NULL, DNS_PROTOCOL_DNS, AF_UNSPEC);
 498         if (r < 0)
 499                 return r;
 500
 501         r = manager_network_monitor_listen(m);
 502         if (r < 0)
 503                 return r;
 504
 505         r = manager_rtnl_listen(m);
 506         if (r < 0)
 507                 return r;
 508
 509         r = manager_connect_bus(m);
 510         if (r < 0)
 511                 return r;
 512
 513         (void) sd_event_add_signal(m->event, &m->sigusr1_event_source, SIGUSR1, manager_sigusr1, m);
 514
 515         *ret = m;
 516         m = NULL;
 517
 518         return 0;
 519 }
 520
 521 int manager_start(Manager *m) {
 522         int r;
 523
 524         assert(m);
 525
 526         r = manager_llmnr_start(m);
 527         if (r < 0)
 528                 return r;
 529
 530         return 0;
 531 }
 532
 533 Manager *manager_free(Manager *m) {
 534         Link *l;
 535
 536         if (!m)
 537                 return NULL;
 538
 539         while ((l = hashmap_first(m->links)))
 540                link_free(l);
 541
 542         while (m->dns_queries)
 543                 dns_query_free(m->dns_queries);
 544
 545         manager_flush_dns_servers(m, DNS_SERVER_SYSTEM);
 546         manager_flush_dns_servers(m, DNS_SERVER_FALLBACK);
 547
 548         dns_scope_free(m->unicast_scope);
 549
 550         hashmap_free(m->links);
 551         hashmap_free(m->dns_transactions);
 552
 553         sd_event_source_unref(m->network_event_source);
 554         sd_network_monitor_unref(m->network_monitor);
 555
 556         sd_netlink_unref(m->rtnl);
 557         sd_event_source_unref(m->rtnl_event_source);
 558
 559         manager_llmnr_stop(m);
 560
 561         sd_bus_slot_unref(m->prepare_for_sleep_slot);
 562         sd_event_source_unref(m->bus_retry_event_source);
 563         sd_bus_unref(m->bus);
 564
 565         sd_event_source_unref(m->sigusr1_event_source);
 566
 567         sd_event_unref(m->event);
 568
 569         dns_resource_key_unref(m->llmnr_host_ipv4_key);
 570         dns_resource_key_unref(m->llmnr_host_ipv6_key);
 571
 572         sd_event_source_unref(m->hostname_event_source);
 573         safe_close(m->hostname_fd);
 574         free(m->llmnr_hostname);
 575         free(m->mdns_hostname);
 576
 577         free(m);
 578
 579         return NULL;
 580 }
 581
 582 int manager_read_resolv_conf(Manager *m) {
 583         _cleanup_fclose_ FILE *f = NULL;
 584         struct stat st, own;
 585         char line[LINE_MAX];
 586         DnsServer *s, *nx;
 587         usec_t t;
 588         int r;
 589
 590         assert(m);
 591
 592         /* Reads the system /etc/resolv.conf, if it exists and is not
 593          * symlinked to our own resolv.conf instance */
 594
 595         if (!m->read_resolv_conf)
 596                 return 0;
 597
 598         r = stat("/etc/resolv.conf", &st);
 599         if (r < 0) {
 600                 if (errno == ENOENT)
 601                         r = 0;
 602                 else
 603                         r = log_warning_errno(errno, "Failed to open /etc/resolv.conf: %m");
 604                 goto clear;
 605         }
 606
 607         /* Have we already seen the file? */
 608         t = timespec_load(&st.st_mtim);
 609         if (t == m->resolv_conf_mtime)
 610                 return 0;
 611
 612         m->resolv_conf_mtime = t;
 613
 614         /* Is it symlinked to our own file? */
 615         if (stat("/run/systemd/resolve/resolv.conf", &own) >= 0 &&
 616             st.st_dev == own.st_dev &&
 617             st.st_ino == own.st_ino) {
 618                 r = 0;
 619                 goto clear;
 620         }
 621
 622         f = fopen("/etc/resolv.conf", "re");
 623         if (!f) {
 624                 if (errno == ENOENT)
 625                         r = 0;
 626                 else
 627                         r = log_warning_errno(errno, "Failed to open /etc/resolv.conf: %m");
 628                 goto clear;
 629         }
 630
 631         if (fstat(fileno(f), &st) < 0) {
 632                 r = log_error_errno(errno, "Failed to stat open file: %m");
 633                 goto clear;
 634         }
 635
 636         LIST_FOREACH(servers, s, m->dns_servers)
 637                 s->marked = true;
 638
 639         FOREACH_LINE(line, f, r = -errno; goto clear) {
 640                 union in_addr_union address;
 641                 int family;
 642                 char *l;
 643                 const char *a;
 644
 645                 truncate_nl(line);
 646
 647                 l = strstrip(line);
 648                 if (*l == '#' || *l == ';')
 649                         continue;
 650
 651                 a = first_word(l, "nameserver");
 652                 if (!a)
 653                         continue;
 654
 655                 r = in_addr_from_string_auto(a, &family, &address);
 656                 if (r < 0) {
 657                         log_warning("Failed to parse name server %s.", a);
 658                         continue;
 659                 }
 660
 661                 LIST_FOREACH(servers, s, m->dns_servers)
 662                         if (s->family == family && in_addr_equal(family, &s->address, &address) > 0)
 663                                 break;
 664
 665                 if (s)
 666                         s->marked = false;
 667                 else {
 668                         r = dns_server_new(m, NULL, DNS_SERVER_SYSTEM, NULL, family, &address);
 669                         if (r < 0)
 670                                 goto clear;
 671                 }
 672         }
 673
 674         LIST_FOREACH_SAFE(servers, s, nx, m->dns_servers)
 675                 if (s->marked) {
 676                         LIST_REMOVE(servers, m->dns_servers, s);
 677                         dns_server_unref(s);
 678                 }
 679
 680         /* Whenever /etc/resolv.conf changes, start using the first
 681          * DNS server of it. This is useful to deal with broken
 682          * network managing implementations (like NetworkManager),
 683          * that when connecting to a VPN place both the VPN DNS
 684          * servers and the local ones in /etc/resolv.conf. Without
 685          * resetting the DNS server to use back to the first entry we
 686          * will continue to use the local one thus being unable to
 687          * resolve VPN domains. */
 688         manager_set_dns_server(m, m->dns_servers);
 689
 690         return 0;
 691
 692 clear:
 693         while (m->dns_servers) {
 694                 s = m->dns_servers;
 695
 696                 LIST_REMOVE(servers, m->dns_servers, s);
 697                 dns_server_unref(s);
 698         }
 699
 700         return r;
 701 }
 702
 703 static void write_resolv_conf_server(DnsServer *s, FILE *f, unsigned *count) {
 704         _cleanup_free_ char *t  = NULL;
 705         int r;
 706
 707         assert(s);
 708         assert(f);
 709         assert(count);
 710
 711         r = in_addr_to_string(s->family, &s->address, &t);
 712         if (r < 0) {
 713                 log_warning_errno(r, "Invalid DNS address. Ignoring: %m");
 714                 return;
 715         }
 716
 717         if (*count == MAXNS)
 718                 fputs("# Too many DNS servers configured, the following entries may be ignored.\n", f);
 719
 720         fprintf(f, "nameserver %s\n", t);
 721         (*count) ++;
 722 }
 723
 724 static void write_resolv_conf_search(
 725                 const char *domain, FILE *f,
 726                 unsigned *count,
 727                 unsigned *length) {
 728
 729         assert(domain);
 730         assert(f);
 731         assert(length);
 732
 733         if (*count >= MAXDNSRCH ||
 734             *length + strlen(domain) > 256) {
 735                 if (*count == MAXDNSRCH)
 736                         fputs(" # Too many search domains configured, remaining ones ignored.", f);
 737                 if (*length <= 256)
 738                         fputs(" # Total length of all search domains is too long, remaining ones ignored.", f);
 739
 740                 return;
 741         }
 742
 743         fprintf(f, " %s", domain);
 744
 745         (*length) += strlen(domain);
 746         (*count) ++;
 747 }
 748
 749 static int write_resolv_conf_contents(FILE *f, OrderedSet *dns, OrderedSet *domains) {
 750         Iterator i;
 751
 752         fputs("# This file is managed by systemd-resolved(8). Do not edit.\n#\n"
 753               "# Third party programs must not access this file directly, but\n"
 754               "# only through the symlink at /etc/resolv.conf. To manage\n"
 755               "# resolv.conf(5) in a different way, replace the symlink by a\n"
 756               "# static file or a different symlink.\n\n", f);
 757
 758         if (ordered_set_isempty(dns))
 759                 fputs("# No DNS servers known.\n", f);
 760         else {
 761                 DnsServer *s;
 762                 unsigned count = 0;
 763
 764                 ORDERED_SET_FOREACH(s, dns, i)
 765                         write_resolv_conf_server(s, f, &count);
 766         }
 767
 768         if (!ordered_set_isempty(domains)) {
 769                 unsigned length = 0, count = 0;
 770                 char *domain;
 771
 772                 fputs("search", f);
 773                 ORDERED_SET_FOREACH(domain, domains, i)
 774                         write_resolv_conf_search(domain, f, &count, &length);
 775                 fputs("\n", f);
 776         }
 777
 778         return fflush_and_check(f);
 779 }
 780
 781 int manager_write_resolv_conf(Manager *m) {
 782         static const char path[] = "/run/systemd/resolve/resolv.conf";
 783         _cleanup_free_ char *temp_path = NULL;
 784         _cleanup_fclose_ FILE *f = NULL;
 785         _cleanup_ordered_set_free_ OrderedSet *dns = NULL, *domains = NULL;
 786         DnsServer *s;
 787         Iterator i;
 788         Link *l;
 789         int r;
 790
 791         assert(m);
 792
 793         /* Read the system /etc/resolv.conf first */
 794         manager_read_resolv_conf(m);
 795
 796         /* Add the full list to a set, to filter out duplicates */
 797         dns = ordered_set_new(&dns_server_hash_ops);
 798         if (!dns)
 799                 return -ENOMEM;
 800
 801         domains = ordered_set_new(&dns_name_hash_ops);
 802         if (!domains)
 803                 return -ENOMEM;
 804
 805         /* First add the system-wide servers */
 806         LIST_FOREACH(servers, s, m->dns_servers) {
 807                 r = ordered_set_put(dns, s);
 808                 if (r == -EEXIST)
 809                         continue;
 810                 if (r < 0)
 811                         return r;
 812         }
 813
 814         /* Then, add the per-link servers and domains */
 815         HASHMAP_FOREACH(l, m->links, i) {
 816                 char **domain;
 817
 818                 LIST_FOREACH(servers, s, l->dns_servers) {
 819                         r = ordered_set_put(dns, s);
 820                         if (r == -EEXIST)
 821                                 continue;
 822                         if (r < 0)
 823                                 return r;
 824                 }
 825
 826                 if (!l->unicast_scope)
 827                         continue;
 828
 829                 STRV_FOREACH(domain, l->unicast_scope->domains) {
 830                         r = ordered_set_put(domains, *domain);
 831                         if (r == -EEXIST)
 832                                 continue;
 833                         if (r < 0)
 834                                 return r;
 835                 }
 836         }
 837
 838         /* If we found nothing, add the fallback servers */
 839         if (ordered_set_isempty(dns)) {
 840                 LIST_FOREACH(servers, s, m->fallback_dns_servers) {
 841                         r = ordered_set_put(dns, s);
 842                         if (r == -EEXIST)
 843                                 continue;
 844                         if (r < 0)
 845                                 return r;
 846                 }
 847         }
 848
 849         r = fopen_temporary_label(path, path, &f, &temp_path);
 850         if (r < 0)
 851                 return r;
 852
 853         fchmod(fileno(f), 0644);
 854
 855         r = write_resolv_conf_contents(f, dns, domains);
 856         if (r < 0)
 857                 goto fail;
 858
 859         if (rename(temp_path, path) < 0) {
 860                 r = -errno;
 861                 goto fail;
 862         }
 863
 864         return 0;
 865
 866 fail:
 867         (void) unlink(path);
 868         (void) unlink(temp_path);
 869         return r;
 870 }
 871
 872 int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) {
 873         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 874         union {
 875                 struct cmsghdr header; /* For alignment */
 876                 uint8_t buffer[CMSG_SPACE(MAXSIZE(struct in_pktinfo, struct in6_pktinfo))
 877                                + CMSG_SPACE(int) /* ttl/hoplimit */
 878                                + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */];
 879         } control;
 880         union sockaddr_union sa;
 881         struct msghdr mh = {};
 882         struct cmsghdr *cmsg;
 883         struct iovec iov;
 884         int ms = 0, r;
 885         ssize_t l;
 886
 887         assert(m);
 888         assert(fd >= 0);
 889         assert(ret);
 890
 891         r = ioctl(fd, FIONREAD, &ms);
 892         if (r < 0)
 893                 return -errno;
 894         if (ms < 0)
 895                 return -EIO;
 896
 897         r = dns_packet_new(&p, protocol, ms);
 898         if (r < 0)
 899                 return r;
 900
 901         iov.iov_base = DNS_PACKET_DATA(p);
 902         iov.iov_len = p->allocated;
 903
 904         mh.msg_name = &sa.sa;
 905         mh.msg_namelen = sizeof(sa);
 906         mh.msg_iov = &iov;
 907         mh.msg_iovlen = 1;
 908         mh.msg_control = &control;
 909         mh.msg_controllen = sizeof(control);
 910
 911         l = recvmsg(fd, &mh, 0);
 912         if (l < 0) {
 913                 if (errno == EAGAIN || errno == EINTR)
 914                         return 0;
 915
 916                 return -errno;
 917         }
 918
 919         if (l <= 0)
 920                 return -EIO;
 921
 922         assert(!(mh.msg_flags & MSG_CTRUNC));
 923         assert(!(mh.msg_flags & MSG_TRUNC));
 924
 925         p->size = (size_t) l;
 926
 927         p->family = sa.sa.sa_family;
 928         p->ipproto = IPPROTO_UDP;
 929         if (p->family == AF_INET) {
 930                 p->sender.in = sa.in.sin_addr;
 931                 p->sender_port = be16toh(sa.in.sin_port);
 932         } else if (p->family == AF_INET6) {
 933                 p->sender.in6 = sa.in6.sin6_addr;
 934                 p->sender_port = be16toh(sa.in6.sin6_port);
 935                 p->ifindex = sa.in6.sin6_scope_id;
 936         } else
 937                 return -EAFNOSUPPORT;
 938
 939         CMSG_FOREACH(cmsg, &mh) {
 940
 941                 if (cmsg->cmsg_level == IPPROTO_IPV6) {
 942                         assert(p->family == AF_INET6);
 943
 944                         switch (cmsg->cmsg_type) {
 945
 946                         case IPV6_PKTINFO: {
 947                                 struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg);
 948
 949                                 if (p->ifindex <= 0)
 950                                         p->ifindex = i->ipi6_ifindex;
 951
 952                                 p->destination.in6 = i->ipi6_addr;
 953                                 break;
 954                         }
 955
 956                         case IPV6_HOPLIMIT:
 957                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 958                                 break;
 959
 960                         }
 961                 } else if (cmsg->cmsg_level == IPPROTO_IP) {
 962                         assert(p->family == AF_INET);
 963
 964                         switch (cmsg->cmsg_type) {
 965
 966                         case IP_PKTINFO: {
 967                                 struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg);
 968
 969                                 if (p->ifindex <= 0)
 970                                         p->ifindex = i->ipi_ifindex;
 971
 972                                 p->destination.in = i->ipi_addr;
 973                                 break;
 974                         }
 975
 976                         case IP_TTL:
 977                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 978                                 break;
 979                         }
 980                 }
 981         }
 982
 983         /* The Linux kernel sets the interface index to the loopback
 984          * device if the packet came from the local host since it
 985          * avoids the routing table in such a case. Let's unset the
 986          * interface index in such a case. */
 987         if (p->ifindex == LOOPBACK_IFINDEX)
 988                 p->ifindex = 0;
 989
 990         if (protocol != DNS_PROTOCOL_DNS) {
 991                 /* If we don't know the interface index still, we look for the
 992                  * first local interface with a matching address. Yuck! */
 993                 if (p->ifindex <= 0)
 994                         p->ifindex = manager_find_ifindex(m, p->family, &p->destination);
 995         }
 996
 997         *ret = p;
 998         p = NULL;
 999
1000         return 1;
1001 }
1002
1003 static int sendmsg_loop(int fd, struct msghdr *mh, int flags) {
1004         int r;
1005
1006         assert(fd >= 0);
1007         assert(mh);
1008
1009         for (;;) {
1010                 if (sendmsg(fd, mh, flags) >= 0)
1011                         return 0;
1012
1013                 if (errno == EINTR)
1014                         continue;
1015
1016                 if (errno != EAGAIN)
1017                         return -errno;
1018
1019                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
1020                 if (r < 0)
1021                         return r;
1022                 if (r == 0)
1023                         return -ETIMEDOUT;
1024         }
1025 }
1026
1027 static int write_loop(int fd, void *message, size_t length) {
1028         int r;
1029
1030         assert(fd >= 0);
1031         assert(message);
1032
1033         for (;;) {
1034                 if (write(fd, message, length) >= 0)
1035                         return 0;
1036
1037                 if (errno == EINTR)
1038                         continue;
1039
1040                 if (errno != EAGAIN)
1041                         return -errno;
1042
1043                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
1044                 if (r < 0)
1045                         return r;
1046                 if (r == 0)
1047                         return -ETIMEDOUT;
1048         }
1049 }
1050
1051 int manager_write(Manager *m, int fd, DnsPacket *p) {
1052         int r;
1053
1054         log_debug("Sending %s packet with id %u", DNS_PACKET_QR(p) ? "response" : "query", DNS_PACKET_ID(p));
1055
1056         r = write_loop(fd, DNS_PACKET_DATA(p), p->size);
1057         if (r < 0)
1058                 return r;
1059
1060         return 0;
1061 }
1062
1063 static int manager_ipv4_send(Manager *m, int fd, int ifindex, const struct in_addr *addr, uint16_t port, DnsPacket *p) {
1064         union sockaddr_union sa = {
1065                 .in.sin_family = AF_INET,
1066         };
1067         union {
1068                 struct cmsghdr header; /* For alignment */
1069                 uint8_t buffer[CMSG_SPACE(sizeof(struct in_pktinfo))];
1070         } control;
1071         struct msghdr mh = {};
1072         struct iovec iov;
1073
1074         assert(m);
1075         assert(fd >= 0);
1076         assert(addr);
1077         assert(port > 0);
1078         assert(p);
1079
1080         iov.iov_base = DNS_PACKET_DATA(p);
1081         iov.iov_len = p->size;
1082
1083         sa.in.sin_addr = *addr;
1084         sa.in.sin_port = htobe16(port),
1085
1086         mh.msg_iov = &iov;
1087         mh.msg_iovlen = 1;
1088         mh.msg_name = &sa.sa;
1089         mh.msg_namelen = sizeof(sa.in);
1090
1091         if (ifindex > 0) {
1092                 struct cmsghdr *cmsg;
1093                 struct in_pktinfo *pi;
1094
1095                 zero(control);
1096
1097                 mh.msg_control = &control;
1098                 mh.msg_controllen = CMSG_LEN(sizeof(struct in_pktinfo));
1099
1100                 cmsg = CMSG_FIRSTHDR(&mh);
1101                 cmsg->cmsg_len = mh.msg_controllen;
1102                 cmsg->cmsg_level = IPPROTO_IP;
1103                 cmsg->cmsg_type = IP_PKTINFO;
1104
1105                 pi = (struct in_pktinfo*) CMSG_DATA(cmsg);
1106                 pi->ipi_ifindex = ifindex;
1107         }
1108
1109         return sendmsg_loop(fd, &mh, 0);
1110 }
1111
1112 static int manager_ipv6_send(Manager *m, int fd, int ifindex, const struct in6_addr *addr, uint16_t port, DnsPacket *p) {
1113         union sockaddr_union sa = {
1114                 .in6.sin6_family = AF_INET6,
1115         };
1116         union {
1117                 struct cmsghdr header; /* For alignment */
1118                 uint8_t buffer[CMSG_SPACE(sizeof(struct in6_pktinfo))];
1119         } control;
1120         struct msghdr mh = {};
1121         struct iovec iov;
1122
1123         assert(m);
1124         assert(fd >= 0);
1125         assert(addr);
1126         assert(port > 0);
1127         assert(p);
1128
1129         iov.iov_base = DNS_PACKET_DATA(p);
1130         iov.iov_len = p->size;
1131
1132         sa.in6.sin6_addr = *addr;
1133         sa.in6.sin6_port = htobe16(port),
1134         sa.in6.sin6_scope_id = ifindex;
1135
1136         mh.msg_iov = &iov;
1137         mh.msg_iovlen = 1;
1138         mh.msg_name = &sa.sa;
1139         mh.msg_namelen = sizeof(sa.in6);
1140
1141         if (ifindex > 0) {
1142                 struct cmsghdr *cmsg;
1143                 struct in6_pktinfo *pi;
1144
1145                 zero(control);
1146
1147                 mh.msg_control = &control;
1148                 mh.msg_controllen = CMSG_LEN(sizeof(struct in6_pktinfo));
1149
1150                 cmsg = CMSG_FIRSTHDR(&mh);
1151                 cmsg->cmsg_len = mh.msg_controllen;
1152                 cmsg->cmsg_level = IPPROTO_IPV6;
1153                 cmsg->cmsg_type = IPV6_PKTINFO;
1154
1155                 pi = (struct in6_pktinfo*) CMSG_DATA(cmsg);
1156                 pi->ipi6_ifindex = ifindex;
1157         }
1158
1159         return sendmsg_loop(fd, &mh, 0);
1160 }
1161
1162 int manager_send(Manager *m, int fd, int ifindex, int family, const union in_addr_union *addr, uint16_t port, DnsPacket *p) {
1163         assert(m);
1164         assert(fd >= 0);
1165         assert(addr);
1166         assert(port > 0);
1167         assert(p);
1168
1169         log_debug("Sending %s packet with id %u on interface %i/%s", DNS_PACKET_QR(p) ? "response" : "query", DNS_PACKET_ID(p), ifindex, af_to_name(family));
1170
1171         if (family == AF_INET)
1172                 return manager_ipv4_send(m, fd, ifindex, &addr->in, port, p);
1173         else if (family == AF_INET6)
1174                 return manager_ipv6_send(m, fd, ifindex, &addr->in6, port, p);
1175
1176         return -EAFNOSUPPORT;
1177 }
1178
1179 DnsServer* manager_find_dns_server(Manager *m, int family, const union in_addr_union *in_addr) {
1180         DnsServer *s;
1181
1182         assert(m);
1183         assert(in_addr);
1184
1185         LIST_FOREACH(servers, s, m->dns_servers)
1186                 if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0)
1187                         return s;
1188
1189         LIST_FOREACH(servers, s, m->fallback_dns_servers)
1190                 if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0)
1191                         return s;
1192
1193         return NULL;
1194 }
1195
1196 DnsServer *manager_set_dns_server(Manager *m, DnsServer *s) {
1197         assert(m);
1198
1199         if (m->current_dns_server == s)
1200                 return s;
1201
1202         if (s) {
1203                 _cleanup_free_ char *ip = NULL;
1204
1205                 in_addr_to_string(s->family, &s->address, &ip);
1206                 log_info("Switching to system DNS server %s.", strna(ip));
1207         }
1208
1209         m->current_dns_server = s;
1210
1211         if (m->unicast_scope)
1212                 dns_cache_flush(&m->unicast_scope->cache);
1213
1214         return s;
1215 }
1216
1217 DnsServer *manager_get_dns_server(Manager *m) {
1218         Link *l;
1219         assert(m);
1220
1221         /* Try to read updates resolv.conf */
1222         manager_read_resolv_conf(m);
1223
1224         if (!m->current_dns_server)
1225                 manager_set_dns_server(m, m->dns_servers);
1226
1227         if (!m->current_dns_server) {
1228                 bool found = false;
1229                 Iterator i;
1230
1231                 /* No DNS servers configured, let's see if there are
1232                  * any on any links. If not, we use the fallback
1233                  * servers */
1234
1235                 HASHMAP_FOREACH(l, m->links, i)
1236                         if (l->dns_servers) {
1237                                 found = true;
1238                                 break;
1239                         }
1240
1241                 if (!found)
1242                         manager_set_dns_server(m, m->fallback_dns_servers);
1243         }
1244
1245         return m->current_dns_server;
1246 }
1247
1248 void manager_next_dns_server(Manager *m) {
1249         assert(m);
1250
1251         /* If there's currently no DNS server set, then the next
1252          * manager_get_dns_server() will find one */
1253         if (!m->current_dns_server)
1254                 return;
1255
1256         /* Change to the next one */
1257         if (m->current_dns_server->servers_next) {
1258                 manager_set_dns_server(m, m->current_dns_server->servers_next);
1259                 return;
1260         }
1261
1262         /* If there was no next one, then start from the beginning of
1263          * the list */
1264         if (m->current_dns_server->type == DNS_SERVER_FALLBACK)
1265                 manager_set_dns_server(m, m->fallback_dns_servers);
1266         else
1267                 manager_set_dns_server(m, m->dns_servers);
1268 }
1269
1270 uint32_t manager_find_mtu(Manager *m) {
1271         uint32_t mtu = 0;
1272         Link *l;
1273         Iterator i;
1274
1275         /* If we don't know on which link a DNS packet would be
1276          * delivered, let's find the largest MTU that works on all
1277          * interfaces we know of */
1278
1279         HASHMAP_FOREACH(l, m->links, i) {
1280                 if (l->mtu <= 0)
1281                         continue;
1282
1283                 if (mtu <= 0 || l->mtu < mtu)
1284                         mtu = l->mtu;
1285         }
1286
1287         return mtu;
1288 }
1289
1290 int manager_find_ifindex(Manager *m, int family, const union in_addr_union *in_addr) {
1291         LinkAddress *a;
1292
1293         assert(m);
1294
1295         a = manager_find_link_address(m, family, in_addr);
1296         if (a)
1297                 return a->link->ifindex;
1298
1299         return 0;
1300 }
1301
1302 void manager_refresh_rrs(Manager *m) {
1303         Iterator i;
1304         Link *l;
1305
1306         assert(m);
1307
1308         m->llmnr_host_ipv4_key = dns_resource_key_unref(m->llmnr_host_ipv4_key);
1309         m->llmnr_host_ipv6_key = dns_resource_key_unref(m->llmnr_host_ipv6_key);
1310
1311         HASHMAP_FOREACH(l, m->links, i) {
1312                 link_add_rrs(l, true);
1313                 link_add_rrs(l, false);
1314         }
1315 }
1316
1317 int manager_next_hostname(Manager *m) {
1318         const char *p;
1319         uint64_t u, a;
1320         char *h, *k;
1321         int r;
1322
1323         assert(m);
1324
1325         p = strchr(m->llmnr_hostname, 0);
1326         assert(p);
1327
1328         while (p > m->llmnr_hostname) {
1329                 if (!strchr("0123456789", p[-1]))
1330                         break;
1331
1332                 p--;
1333         }
1334
1335         if (*p == 0 || safe_atou64(p, &u) < 0 || u <= 0)
1336                 u = 1;
1337
1338         /* Add a random number to the old value. This way we can avoid
1339          * that two hosts pick the same hostname, win on IPv4 and lose
1340          * on IPv6 (or vice versa), and pick the same hostname
1341          * replacement hostname, ad infinitum. We still want the
1342          * numbers to go up monotonically, hence we just add a random
1343          * value 1..10 */
1344
1345         random_bytes(&a, sizeof(a));
1346         u += 1 + a % 10;
1347
1348         if (asprintf(&h, "%.*s%" PRIu64, (int) (p - m->llmnr_hostname), m->llmnr_hostname, u) < 0)
1349                 return -ENOMEM;
1350
1351         r = dns_name_concat(h, "local", &k);
1352         if (r < 0) {
1353                 free(h);
1354                 return r;
1355         }
1356
1357         log_info("Hostname conflict, changing published hostname from '%s' to '%s'.", m->llmnr_hostname, h);
1358
1359         free(m->llmnr_hostname);
1360         m->llmnr_hostname = h;
1361
1362         free(m->mdns_hostname);
1363         m->mdns_hostname = k;
1364
1365         manager_refresh_rrs(m);
1366
1367         return 0;
1368 }
1369
1370 LinkAddress* manager_find_link_address(Manager *m, int family, const union in_addr_union *in_addr) {
1371         Iterator i;
1372         Link *l;
1373
1374         assert(m);
1375
1376         HASHMAP_FOREACH(l, m->links, i) {
1377                 LinkAddress *a;
1378
1379                 a = link_find_address(l, family, in_addr);
1380                 if (a)
1381                         return a;
1382         }
1383
1384         return NULL;
1385 }
1386
1387 bool manager_our_packet(Manager *m, DnsPacket *p) {
1388         assert(m);
1389         assert(p);
1390
1391         return !!manager_find_link_address(m, p->family, &p->sender);
1392 }
1393
1394 DnsScope* manager_find_scope(Manager *m, DnsPacket *p) {
1395         Link *l;
1396
1397         assert(m);
1398         assert(p);
1399
1400         l = hashmap_get(m->links, INT_TO_PTR(p->ifindex));
1401         if (!l)
1402                 return NULL;
1403
1404         if (p->protocol == DNS_PROTOCOL_LLMNR) {
1405                 if (p->family == AF_INET)
1406                         return l->llmnr_ipv4_scope;
1407                 else if (p->family == AF_INET6)
1408                         return l->llmnr_ipv6_scope;
1409         }
1410
1411         return NULL;
1412 }
1413
1414 void manager_verify_all(Manager *m) {
1415         DnsScope *s;
1416
1417         assert(m);
1418
1419         LIST_FOREACH(scopes, s, m->dns_scopes)
1420                 dns_zone_verify_all(&s->zone);
1421 }
1422
1423 void manager_flush_dns_servers(Manager *m, DnsServerType t) {
1424         DnsServer *s;
1425
1426         assert(m);
1427
1428         if (t == DNS_SERVER_SYSTEM)
1429                 while (m->dns_servers) {
1430                         s = m->dns_servers;
1431
1432                         LIST_REMOVE(servers, m->dns_servers, s);
1433                         dns_server_unref(s);
1434                 }
1435
1436         if (t == DNS_SERVER_FALLBACK)
1437                 while (m->fallback_dns_servers) {
1438                         s = m->fallback_dns_servers;
1439
1440                         LIST_REMOVE(servers, m->fallback_dns_servers, s);
1441                         dns_server_unref(s);
1442                 }
1443 }
1444
1445 int manager_is_own_hostname(Manager *m, const char *name) {
1446         int r;
1447
1448         assert(m);
1449         assert(name);
1450
1451         if (m->llmnr_hostname) {
1452                 r = dns_name_equal(name, m->llmnr_hostname);
1453                 if (r != 0)
1454                         return r;
1455         }
1456
1457         if (m->mdns_hostname)
1458                 return dns_name_equal(name, m->mdns_hostname);
1459
1460         return 0;
1461 }
1462
1463 static const char* const support_table[_SUPPORT_MAX] = {
1464         [SUPPORT_NO] = "no",
1465         [SUPPORT_YES] = "yes",
1466         [SUPPORT_RESOLVE] = "resolve",
1467 };
1468 DEFINE_STRING_TABLE_LOOKUP(support, Support);