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_string_and_warn(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;
 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         manager_mark_dns_servers(m, DNS_SERVER_SYSTEM);
 637
 638         FOREACH_LINE(line, f, r = -errno; goto clear) {
 639                 _cleanup_strv_free_ char **d = NULL;
 640                 const char *a;
 641                 char *l;
 642
 643                 truncate_nl(line);
 644
 645                 l = strstrip(line);
 646                 if (*l == '#' || *l == ';')
 647                         continue;
 648
 649                 a = first_word(l, "nameserver");
 650                 if (a) {
 651                         r = manager_add_dns_server_by_string(m, DNS_SERVER_SYSTEM, a);
 652                         if (r < 0)
 653                                 log_warning_errno(r, "Failed to parse DNS server address '%s', ignoring.", a);
 654
 655                         continue;
 656                 }
 657         }
 658
 659         manager_flush_marked_dns_servers(m, DNS_SERVER_SYSTEM);
 660
 661         /* Whenever /etc/resolv.conf changes, start using the first
 662          * DNS server of it. This is useful to deal with broken
 663          * network managing implementations (like NetworkManager),
 664          * that when connecting to a VPN place both the VPN DNS
 665          * servers and the local ones in /etc/resolv.conf. Without
 666          * resetting the DNS server to use back to the first entry we
 667          * will continue to use the local one thus being unable to
 668          * resolve VPN domains. */
 669         manager_set_dns_server(m, m->dns_servers);
 670
 671         return 0;
 672
 673 clear:
 674         while (m->dns_servers) {
 675                 s = m->dns_servers;
 676
 677                 LIST_REMOVE(servers, m->dns_servers, s);
 678                 dns_server_unref(s);
 679         }
 680
 681         return r;
 682 }
 683
 684 static void write_resolv_conf_server(DnsServer *s, FILE *f, unsigned *count) {
 685         _cleanup_free_ char *t  = NULL;
 686         int r;
 687
 688         assert(s);
 689         assert(f);
 690         assert(count);
 691
 692         r = in_addr_to_string(s->family, &s->address, &t);
 693         if (r < 0) {
 694                 log_warning_errno(r, "Invalid DNS address. Ignoring: %m");
 695                 return;
 696         }
 697
 698         if (*count == MAXNS)
 699                 fputs("# Too many DNS servers configured, the following entries may be ignored.\n", f);
 700         (*count) ++;
 701
 702         fprintf(f, "nameserver %s\n", t);
 703 }
 704
 705 static void write_resolv_conf_search(
 706                 const char *domain,
 707                 FILE *f,
 708                 unsigned *count,
 709                 unsigned *length) {
 710
 711         assert(domain);
 712         assert(f);
 713         assert(length);
 714
 715         if (*count >= MAXDNSRCH ||
 716             *length + strlen(domain) > 256) {
 717                 if (*count == MAXDNSRCH)
 718                         fputs(" # Too many search domains configured, remaining ones ignored.", f);
 719                 if (*length <= 256)
 720                         fputs(" # Total length of all search domains is too long, remaining ones ignored.", f);
 721
 722                 return;
 723         }
 724
 725         (*length) += strlen(domain);
 726         (*count) ++;
 727
 728         fputc(' ', f);
 729         fputs(domain, f);
 730 }
 731
 732 static int write_resolv_conf_contents(FILE *f, OrderedSet *dns, OrderedSet *domains) {
 733         Iterator i;
 734
 735         fputs("# This file is managed by systemd-resolved(8). Do not edit.\n#\n"
 736               "# Third party programs must not access this file directly, but\n"
 737               "# only through the symlink at /etc/resolv.conf. To manage\n"
 738               "# resolv.conf(5) in a different way, replace the symlink by a\n"
 739               "# static file or a different symlink.\n\n", f);
 740
 741         if (ordered_set_isempty(dns))
 742                 fputs("# No DNS servers known.\n", f);
 743         else {
 744                 unsigned count = 0;
 745                 DnsServer *s;
 746
 747                 ORDERED_SET_FOREACH(s, dns, i)
 748                         write_resolv_conf_server(s, f, &count);
 749         }
 750
 751         if (!ordered_set_isempty(domains)) {
 752                 unsigned length = 0, count = 0;
 753                 char *domain;
 754
 755                 fputs("search", f);
 756                 ORDERED_SET_FOREACH(domain, domains, i)
 757                         write_resolv_conf_search(domain, f, &count, &length);
 758                 fputs("\n", f);
 759         }
 760
 761         return fflush_and_check(f);
 762 }
 763
 764 int manager_write_resolv_conf(Manager *m) {
 765         static const char path[] = "/run/systemd/resolve/resolv.conf";
 766         _cleanup_free_ char *temp_path = NULL;
 767         _cleanup_fclose_ FILE *f = NULL;
 768         _cleanup_ordered_set_free_ OrderedSet *dns = NULL, *domains = NULL;
 769         DnsServer *s;
 770         Iterator i;
 771         Link *l;
 772         int r;
 773
 774         assert(m);
 775
 776         /* Read the system /etc/resolv.conf first */
 777         manager_read_resolv_conf(m);
 778
 779         /* Add the full list to a set, to filter out duplicates */
 780         dns = ordered_set_new(&dns_server_hash_ops);
 781         if (!dns)
 782                 return -ENOMEM;
 783
 784         domains = ordered_set_new(&dns_name_hash_ops);
 785         if (!domains)
 786                 return -ENOMEM;
 787
 788         /* First add the system-wide servers and domains */
 789         LIST_FOREACH(servers, s, m->dns_servers) {
 790                 r = ordered_set_put(dns, s);
 791                 if (r == -EEXIST)
 792                         continue;
 793                 if (r < 0)
 794                         return r;
 795         }
 796
 797         /* Then, add the per-link servers and domains */
 798         HASHMAP_FOREACH(l, m->links, i) {
 799                 char **domain;
 800
 801                 LIST_FOREACH(servers, s, l->dns_servers) {
 802                         r = ordered_set_put(dns, s);
 803                         if (r == -EEXIST)
 804                                 continue;
 805                         if (r < 0)
 806                                 return r;
 807                 }
 808
 809                 if (!l->unicast_scope)
 810                         continue;
 811
 812                 STRV_FOREACH(domain, l->unicast_scope->domains) {
 813                         r = ordered_set_put(domains, *domain);
 814                         if (r == -EEXIST)
 815                                 continue;
 816                         if (r < 0)
 817                                 return r;
 818                 }
 819         }
 820
 821         /* If we found nothing, add the fallback servers */
 822         if (ordered_set_isempty(dns)) {
 823                 LIST_FOREACH(servers, s, m->fallback_dns_servers) {
 824                         r = ordered_set_put(dns, s);
 825                         if (r == -EEXIST)
 826                                 continue;
 827                         if (r < 0)
 828                                 return r;
 829                 }
 830         }
 831
 832         r = fopen_temporary_label(path, path, &f, &temp_path);
 833         if (r < 0)
 834                 return r;
 835
 836         fchmod(fileno(f), 0644);
 837
 838         r = write_resolv_conf_contents(f, dns, domains);
 839         if (r < 0)
 840                 goto fail;
 841
 842         if (rename(temp_path, path) < 0) {
 843                 r = -errno;
 844                 goto fail;
 845         }
 846
 847         return 0;
 848
 849 fail:
 850         (void) unlink(path);
 851         (void) unlink(temp_path);
 852         return r;
 853 }
 854
 855 int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) {
 856         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 857         union {
 858                 struct cmsghdr header; /* For alignment */
 859                 uint8_t buffer[CMSG_SPACE(MAXSIZE(struct in_pktinfo, struct in6_pktinfo))
 860                                + CMSG_SPACE(int) /* ttl/hoplimit */
 861                                + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */];
 862         } control;
 863         union sockaddr_union sa;
 864         struct msghdr mh = {};
 865         struct cmsghdr *cmsg;
 866         struct iovec iov;
 867         int ms = 0, r;
 868         ssize_t l;
 869
 870         assert(m);
 871         assert(fd >= 0);
 872         assert(ret);
 873
 874         r = ioctl(fd, FIONREAD, &ms);
 875         if (r < 0)
 876                 return -errno;
 877         if (ms < 0)
 878                 return -EIO;
 879
 880         r = dns_packet_new(&p, protocol, ms);
 881         if (r < 0)
 882                 return r;
 883
 884         iov.iov_base = DNS_PACKET_DATA(p);
 885         iov.iov_len = p->allocated;
 886
 887         mh.msg_name = &sa.sa;
 888         mh.msg_namelen = sizeof(sa);
 889         mh.msg_iov = &iov;
 890         mh.msg_iovlen = 1;
 891         mh.msg_control = &control;
 892         mh.msg_controllen = sizeof(control);
 893
 894         l = recvmsg(fd, &mh, 0);
 895         if (l < 0) {
 896                 if (errno == EAGAIN || errno == EINTR)
 897                         return 0;
 898
 899                 return -errno;
 900         }
 901
 902         if (l <= 0)
 903                 return -EIO;
 904
 905         assert(!(mh.msg_flags & MSG_CTRUNC));
 906         assert(!(mh.msg_flags & MSG_TRUNC));
 907
 908         p->size = (size_t) l;
 909
 910         p->family = sa.sa.sa_family;
 911         p->ipproto = IPPROTO_UDP;
 912         if (p->family == AF_INET) {
 913                 p->sender.in = sa.in.sin_addr;
 914                 p->sender_port = be16toh(sa.in.sin_port);
 915         } else if (p->family == AF_INET6) {
 916                 p->sender.in6 = sa.in6.sin6_addr;
 917                 p->sender_port = be16toh(sa.in6.sin6_port);
 918                 p->ifindex = sa.in6.sin6_scope_id;
 919         } else
 920                 return -EAFNOSUPPORT;
 921
 922         CMSG_FOREACH(cmsg, &mh) {
 923
 924                 if (cmsg->cmsg_level == IPPROTO_IPV6) {
 925                         assert(p->family == AF_INET6);
 926
 927                         switch (cmsg->cmsg_type) {
 928
 929                         case IPV6_PKTINFO: {
 930                                 struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg);
 931
 932                                 if (p->ifindex <= 0)
 933                                         p->ifindex = i->ipi6_ifindex;
 934
 935                                 p->destination.in6 = i->ipi6_addr;
 936                                 break;
 937                         }
 938
 939                         case IPV6_HOPLIMIT:
 940                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 941                                 break;
 942
 943                         }
 944                 } else if (cmsg->cmsg_level == IPPROTO_IP) {
 945                         assert(p->family == AF_INET);
 946
 947                         switch (cmsg->cmsg_type) {
 948
 949                         case IP_PKTINFO: {
 950                                 struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg);
 951
 952                                 if (p->ifindex <= 0)
 953                                         p->ifindex = i->ipi_ifindex;
 954
 955                                 p->destination.in = i->ipi_addr;
 956                                 break;
 957                         }
 958
 959                         case IP_TTL:
 960                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 961                                 break;
 962                         }
 963                 }
 964         }
 965
 966         /* The Linux kernel sets the interface index to the loopback
 967          * device if the packet came from the local host since it
 968          * avoids the routing table in such a case. Let's unset the
 969          * interface index in such a case. */
 970         if (p->ifindex == LOOPBACK_IFINDEX)
 971                 p->ifindex = 0;
 972
 973         if (protocol != DNS_PROTOCOL_DNS) {
 974                 /* If we don't know the interface index still, we look for the
 975                  * first local interface with a matching address. Yuck! */
 976                 if (p->ifindex <= 0)
 977                         p->ifindex = manager_find_ifindex(m, p->family, &p->destination);
 978         }
 979
 980         *ret = p;
 981         p = NULL;
 982
 983         return 1;
 984 }
 985
 986 static int sendmsg_loop(int fd, struct msghdr *mh, int flags) {
 987         int r;
 988
 989         assert(fd >= 0);
 990         assert(mh);
 991
 992         for (;;) {
 993                 if (sendmsg(fd, mh, flags) >= 0)
 994                         return 0;
 995
 996                 if (errno == EINTR)
 997                         continue;
 998
 999                 if (errno != EAGAIN)
1000                         return -errno;
1001
1002                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
1003                 if (r < 0)
1004                         return r;
1005                 if (r == 0)
1006                         return -ETIMEDOUT;
1007         }
1008 }
1009
1010 static int write_loop(int fd, void *message, size_t length) {
1011         int r;
1012
1013         assert(fd >= 0);
1014         assert(message);
1015
1016         for (;;) {
1017                 if (write(fd, message, length) >= 0)
1018                         return 0;
1019
1020                 if (errno == EINTR)
1021                         continue;
1022
1023                 if (errno != EAGAIN)
1024                         return -errno;
1025
1026                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
1027                 if (r < 0)
1028                         return r;
1029                 if (r == 0)
1030                         return -ETIMEDOUT;
1031         }
1032 }
1033
1034 int manager_write(Manager *m, int fd, DnsPacket *p) {
1035         int r;
1036
1037         log_debug("Sending %s packet with id %u", DNS_PACKET_QR(p) ? "response" : "query", DNS_PACKET_ID(p));
1038
1039         r = write_loop(fd, DNS_PACKET_DATA(p), p->size);
1040         if (r < 0)
1041                 return r;
1042
1043         return 0;
1044 }
1045
1046 static int manager_ipv4_send(Manager *m, int fd, int ifindex, const struct in_addr *addr, uint16_t port, DnsPacket *p) {
1047         union sockaddr_union sa = {
1048                 .in.sin_family = AF_INET,
1049         };
1050         union {
1051                 struct cmsghdr header; /* For alignment */
1052                 uint8_t buffer[CMSG_SPACE(sizeof(struct in_pktinfo))];
1053         } control;
1054         struct msghdr mh = {};
1055         struct iovec iov;
1056
1057         assert(m);
1058         assert(fd >= 0);
1059         assert(addr);
1060         assert(port > 0);
1061         assert(p);
1062
1063         iov.iov_base = DNS_PACKET_DATA(p);
1064         iov.iov_len = p->size;
1065
1066         sa.in.sin_addr = *addr;
1067         sa.in.sin_port = htobe16(port),
1068
1069         mh.msg_iov = &iov;
1070         mh.msg_iovlen = 1;
1071         mh.msg_name = &sa.sa;
1072         mh.msg_namelen = sizeof(sa.in);
1073
1074         if (ifindex > 0) {
1075                 struct cmsghdr *cmsg;
1076                 struct in_pktinfo *pi;
1077
1078                 zero(control);
1079
1080                 mh.msg_control = &control;
1081                 mh.msg_controllen = CMSG_LEN(sizeof(struct in_pktinfo));
1082
1083                 cmsg = CMSG_FIRSTHDR(&mh);
1084                 cmsg->cmsg_len = mh.msg_controllen;
1085                 cmsg->cmsg_level = IPPROTO_IP;
1086                 cmsg->cmsg_type = IP_PKTINFO;
1087
1088                 pi = (struct in_pktinfo*) CMSG_DATA(cmsg);
1089                 pi->ipi_ifindex = ifindex;
1090         }
1091
1092         return sendmsg_loop(fd, &mh, 0);
1093 }
1094
1095 static int manager_ipv6_send(Manager *m, int fd, int ifindex, const struct in6_addr *addr, uint16_t port, DnsPacket *p) {
1096         union sockaddr_union sa = {
1097                 .in6.sin6_family = AF_INET6,
1098         };
1099         union {
1100                 struct cmsghdr header; /* For alignment */
1101                 uint8_t buffer[CMSG_SPACE(sizeof(struct in6_pktinfo))];
1102         } control;
1103         struct msghdr mh = {};
1104         struct iovec iov;
1105
1106         assert(m);
1107         assert(fd >= 0);
1108         assert(addr);
1109         assert(port > 0);
1110         assert(p);
1111
1112         iov.iov_base = DNS_PACKET_DATA(p);
1113         iov.iov_len = p->size;
1114
1115         sa.in6.sin6_addr = *addr;
1116         sa.in6.sin6_port = htobe16(port),
1117         sa.in6.sin6_scope_id = ifindex;
1118
1119         mh.msg_iov = &iov;
1120         mh.msg_iovlen = 1;
1121         mh.msg_name = &sa.sa;
1122         mh.msg_namelen = sizeof(sa.in6);
1123
1124         if (ifindex > 0) {
1125                 struct cmsghdr *cmsg;
1126                 struct in6_pktinfo *pi;
1127
1128                 zero(control);
1129
1130                 mh.msg_control = &control;
1131                 mh.msg_controllen = CMSG_LEN(sizeof(struct in6_pktinfo));
1132
1133                 cmsg = CMSG_FIRSTHDR(&mh);
1134                 cmsg->cmsg_len = mh.msg_controllen;
1135                 cmsg->cmsg_level = IPPROTO_IPV6;
1136                 cmsg->cmsg_type = IPV6_PKTINFO;
1137
1138                 pi = (struct in6_pktinfo*) CMSG_DATA(cmsg);
1139                 pi->ipi6_ifindex = ifindex;
1140         }
1141
1142         return sendmsg_loop(fd, &mh, 0);
1143 }
1144
1145 int manager_send(Manager *m, int fd, int ifindex, int family, const union in_addr_union *addr, uint16_t port, DnsPacket *p) {
1146         assert(m);
1147         assert(fd >= 0);
1148         assert(addr);
1149         assert(port > 0);
1150         assert(p);
1151
1152         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));
1153
1154         if (family == AF_INET)
1155                 return manager_ipv4_send(m, fd, ifindex, &addr->in, port, p);
1156         else if (family == AF_INET6)
1157                 return manager_ipv6_send(m, fd, ifindex, &addr->in6, port, p);
1158
1159         return -EAFNOSUPPORT;
1160 }
1161
1162 DnsServer* manager_find_dns_server(Manager *m, int family, const union in_addr_union *in_addr) {
1163         DnsServer *s;
1164
1165         assert(m);
1166         assert(in_addr);
1167
1168         LIST_FOREACH(servers, s, m->dns_servers)
1169                 if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0)
1170                         return s;
1171
1172         LIST_FOREACH(servers, s, m->fallback_dns_servers)
1173                 if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0)
1174                         return s;
1175
1176         return NULL;
1177 }
1178
1179 DnsServer *manager_set_dns_server(Manager *m, DnsServer *s) {
1180         assert(m);
1181
1182         if (m->current_dns_server == s)
1183                 return s;
1184
1185         if (s) {
1186                 _cleanup_free_ char *ip = NULL;
1187
1188                 in_addr_to_string(s->family, &s->address, &ip);
1189                 log_info("Switching to system DNS server %s.", strna(ip));
1190         }
1191
1192         m->current_dns_server = s;
1193
1194         if (m->unicast_scope)
1195                 dns_cache_flush(&m->unicast_scope->cache);
1196
1197         return s;
1198 }
1199
1200 DnsServer *manager_get_dns_server(Manager *m) {
1201         Link *l;
1202         assert(m);
1203
1204         /* Try to read updates resolv.conf */
1205         manager_read_resolv_conf(m);
1206
1207         if (!m->current_dns_server)
1208                 manager_set_dns_server(m, m->dns_servers);
1209
1210         if (!m->current_dns_server) {
1211                 bool found = false;
1212                 Iterator i;
1213
1214                 /* No DNS servers configured, let's see if there are
1215                  * any on any links. If not, we use the fallback
1216                  * servers */
1217
1218                 HASHMAP_FOREACH(l, m->links, i)
1219                         if (l->dns_servers) {
1220                                 found = true;
1221                                 break;
1222                         }
1223
1224                 if (!found)
1225                         manager_set_dns_server(m, m->fallback_dns_servers);
1226         }
1227
1228         return m->current_dns_server;
1229 }
1230
1231 void manager_next_dns_server(Manager *m) {
1232         assert(m);
1233
1234         /* If there's currently no DNS server set, then the next
1235          * manager_get_dns_server() will find one */
1236         if (!m->current_dns_server)
1237                 return;
1238
1239         /* Change to the next one */
1240         if (m->current_dns_server->servers_next) {
1241                 manager_set_dns_server(m, m->current_dns_server->servers_next);
1242                 return;
1243         }
1244
1245         /* If there was no next one, then start from the beginning of
1246          * the list */
1247         if (m->current_dns_server->type == DNS_SERVER_FALLBACK)
1248                 manager_set_dns_server(m, m->fallback_dns_servers);
1249         else
1250                 manager_set_dns_server(m, m->dns_servers);
1251 }
1252
1253 uint32_t manager_find_mtu(Manager *m) {
1254         uint32_t mtu = 0;
1255         Link *l;
1256         Iterator i;
1257
1258         /* If we don't know on which link a DNS packet would be
1259          * delivered, let's find the largest MTU that works on all
1260          * interfaces we know of */
1261
1262         HASHMAP_FOREACH(l, m->links, i) {
1263                 if (l->mtu <= 0)
1264                         continue;
1265
1266                 if (mtu <= 0 || l->mtu < mtu)
1267                         mtu = l->mtu;
1268         }
1269
1270         return mtu;
1271 }
1272
1273 int manager_find_ifindex(Manager *m, int family, const union in_addr_union *in_addr) {
1274         LinkAddress *a;
1275
1276         assert(m);
1277
1278         a = manager_find_link_address(m, family, in_addr);
1279         if (a)
1280                 return a->link->ifindex;
1281
1282         return 0;
1283 }
1284
1285 void manager_refresh_rrs(Manager *m) {
1286         Iterator i;
1287         Link *l;
1288
1289         assert(m);
1290
1291         m->llmnr_host_ipv4_key = dns_resource_key_unref(m->llmnr_host_ipv4_key);
1292         m->llmnr_host_ipv6_key = dns_resource_key_unref(m->llmnr_host_ipv6_key);
1293
1294         HASHMAP_FOREACH(l, m->links, i) {
1295                 link_add_rrs(l, true);
1296                 link_add_rrs(l, false);
1297         }
1298 }
1299
1300 int manager_next_hostname(Manager *m) {
1301         const char *p;
1302         uint64_t u, a;
1303         char *h, *k;
1304         int r;
1305
1306         assert(m);
1307
1308         p = strchr(m->llmnr_hostname, 0);
1309         assert(p);
1310
1311         while (p > m->llmnr_hostname) {
1312                 if (!strchr("0123456789", p[-1]))
1313                         break;
1314
1315                 p--;
1316         }
1317
1318         if (*p == 0 || safe_atou64(p, &u) < 0 || u <= 0)
1319                 u = 1;
1320
1321         /* Add a random number to the old value. This way we can avoid
1322          * that two hosts pick the same hostname, win on IPv4 and lose
1323          * on IPv6 (or vice versa), and pick the same hostname
1324          * replacement hostname, ad infinitum. We still want the
1325          * numbers to go up monotonically, hence we just add a random
1326          * value 1..10 */
1327
1328         random_bytes(&a, sizeof(a));
1329         u += 1 + a % 10;
1330
1331         if (asprintf(&h, "%.*s%" PRIu64, (int) (p - m->llmnr_hostname), m->llmnr_hostname, u) < 0)
1332                 return -ENOMEM;
1333
1334         r = dns_name_concat(h, "local", &k);
1335         if (r < 0) {
1336                 free(h);
1337                 return r;
1338         }
1339
1340         log_info("Hostname conflict, changing published hostname from '%s' to '%s'.", m->llmnr_hostname, h);
1341
1342         free(m->llmnr_hostname);
1343         m->llmnr_hostname = h;
1344
1345         free(m->mdns_hostname);
1346         m->mdns_hostname = k;
1347
1348         manager_refresh_rrs(m);
1349
1350         return 0;
1351 }
1352
1353 LinkAddress* manager_find_link_address(Manager *m, int family, const union in_addr_union *in_addr) {
1354         Iterator i;
1355         Link *l;
1356
1357         assert(m);
1358
1359         HASHMAP_FOREACH(l, m->links, i) {
1360                 LinkAddress *a;
1361
1362                 a = link_find_address(l, family, in_addr);
1363                 if (a)
1364                         return a;
1365         }
1366
1367         return NULL;
1368 }
1369
1370 bool manager_our_packet(Manager *m, DnsPacket *p) {
1371         assert(m);
1372         assert(p);
1373
1374         return !!manager_find_link_address(m, p->family, &p->sender);
1375 }
1376
1377 DnsScope* manager_find_scope(Manager *m, DnsPacket *p) {
1378         Link *l;
1379
1380         assert(m);
1381         assert(p);
1382
1383         l = hashmap_get(m->links, INT_TO_PTR(p->ifindex));
1384         if (!l)
1385                 return NULL;
1386
1387         if (p->protocol == DNS_PROTOCOL_LLMNR) {
1388                 if (p->family == AF_INET)
1389                         return l->llmnr_ipv4_scope;
1390                 else if (p->family == AF_INET6)
1391                         return l->llmnr_ipv6_scope;
1392         }
1393
1394         return NULL;
1395 }
1396
1397 void manager_verify_all(Manager *m) {
1398         DnsScope *s;
1399
1400         assert(m);
1401
1402         LIST_FOREACH(scopes, s, m->dns_scopes)
1403                 dns_zone_verify_all(&s->zone);
1404 }
1405
1406 int manager_is_own_hostname(Manager *m, const char *name) {
1407         int r;
1408
1409         assert(m);
1410         assert(name);
1411
1412         if (m->llmnr_hostname) {
1413                 r = dns_name_equal(name, m->llmnr_hostname);
1414                 if (r != 0)
1415                         return r;
1416         }
1417
1418         if (m->mdns_hostname)
1419                 return dns_name_equal(name, m->mdns_hostname);
1420
1421         return 0;
1422 }
1423
1424 static const char* const support_table[_SUPPORT_MAX] = {
1425         [SUPPORT_NO] = "no",
1426         [SUPPORT_YES] = "yes",
1427         [SUPPORT_RESOLVE] = "resolve",
1428 };
1429 DEFINE_STRING_TABLE_LOOKUP(support, Support);