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 <arpa/inet.h>
  23 #include <resolv.h>
  24 #include <net/if.h>
  25 #include <sys/ioctl.h>
  26 #include <sys/poll.h>
  27 #include <netinet/in.h>
  28
  29 #include "rtnl-util.h"
  30 #include "event-util.h"
  31 #include "network-util.h"
  32 #include "network-internal.h"
  33 #include "conf-parser.h"
  34 #include "socket-util.h"
  35 #include "af-list.h"
  36 #include "utf8.h"
  37
  38 #include "resolved-dns-domain.h"
  39 #include "resolved-conf.h"
  40 #include "resolved-bus.h"
  41 #include "resolved-manager.h"
  42
  43 #define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC)
  44
  45 static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userdata) {
  46         Manager *m = userdata;
  47         uint16_t type;
  48         Link *l;
  49         int ifindex, r;
  50
  51         assert(rtnl);
  52         assert(m);
  53         assert(mm);
  54
  55         r = sd_rtnl_message_get_type(mm, &type);
  56         if (r < 0)
  57                 goto fail;
  58
  59         r = sd_rtnl_message_link_get_ifindex(mm, &ifindex);
  60         if (r < 0)
  61                 goto fail;
  62
  63         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
  64
  65         switch (type) {
  66
  67         case RTM_NEWLINK:{
  68                 bool is_new = !l;
  69
  70                 if (!l) {
  71                         r = link_new(m, &l, ifindex);
  72                         if (r < 0)
  73                                 goto fail;
  74                 }
  75
  76                 r = link_update_rtnl(l, mm);
  77                 if (r < 0)
  78                         goto fail;
  79
  80                 r = link_update_monitor(l);
  81                 if (r < 0)
  82                         goto fail;
  83
  84                 if (is_new)
  85                         log_debug("Found new link %i/%s", ifindex, l->name);
  86
  87                 break;
  88         }
  89
  90         case RTM_DELLINK:
  91                 if (l) {
  92                         log_debug("Removing link %i/%s", l->ifindex, l->name);
  93                         link_free(l);
  94                 }
  95
  96                 break;
  97         }
  98
  99         return 0;
 100
 101 fail:
 102         log_warning("Failed to process RTNL link message: %s", strerror(-r));
 103         return 0;
 104 }
 105
 106 static int manager_process_address(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userdata) {
 107         Manager *m = userdata;
 108         union in_addr_union address;
 109         uint16_t type;
 110         int r, ifindex, family;
 111         LinkAddress *a;
 112         Link *l;
 113
 114         assert(rtnl);
 115         assert(mm);
 116         assert(m);
 117
 118         r = sd_rtnl_message_get_type(mm, &type);
 119         if (r < 0)
 120                 goto fail;
 121
 122         r = sd_rtnl_message_addr_get_ifindex(mm, &ifindex);
 123         if (r < 0)
 124                 goto fail;
 125
 126         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
 127         if (!l)
 128                 return 0;
 129
 130         r = sd_rtnl_message_addr_get_family(mm, &family);
 131         if (r < 0)
 132                 goto fail;
 133
 134         switch (family) {
 135
 136         case AF_INET:
 137                 r = sd_rtnl_message_read_in_addr(mm, IFA_LOCAL, &address.in);
 138                 if (r < 0) {
 139                         r = sd_rtnl_message_read_in_addr(mm, IFA_ADDRESS, &address.in);
 140                         if (r < 0)
 141                                 goto fail;
 142                 }
 143
 144                 break;
 145
 146         case AF_INET6:
 147                 r = sd_rtnl_message_read_in6_addr(mm, IFA_LOCAL, &address.in6);
 148                 if (r < 0) {
 149                         r = sd_rtnl_message_read_in6_addr(mm, IFA_ADDRESS, &address.in6);
 150                         if (r < 0)
 151                                 goto fail;
 152                 }
 153
 154                 break;
 155
 156         default:
 157                 return 0;
 158         }
 159
 160         a = link_find_address(l, family, &address);
 161
 162         switch (type) {
 163
 164         case RTM_NEWADDR:
 165
 166                 if (!a) {
 167                         r = link_address_new(l, &a, family, &address);
 168                         if (r < 0)
 169                                 return r;
 170                 }
 171
 172                 r = link_address_update_rtnl(a, mm);
 173                 if (r < 0)
 174                         return r;
 175
 176                 break;
 177
 178         case RTM_DELADDR:
 179                 if (a)
 180                         link_address_free(a);
 181                 break;
 182         }
 183
 184         return 0;
 185
 186 fail:
 187         log_warning("Failed to process RTNL address message: %s", strerror(-r));
 188         return 0;
 189 }
 190
 191 static int manager_rtnl_listen(Manager *m) {
 192         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
 193         sd_rtnl_message *i;
 194         int r;
 195
 196         assert(m);
 197
 198         /* First, subscibe to interfaces coming and going */
 199         r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR, RTNLGRP_IPV6_IFADDR);
 200         if (r < 0)
 201                 return r;
 202
 203         r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
 204         if (r < 0)
 205                 return r;
 206
 207         r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, manager_process_link, m);
 208         if (r < 0)
 209                 return r;
 210
 211         r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, manager_process_link, m);
 212         if (r < 0)
 213                 return r;
 214
 215         r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, manager_process_address, m);
 216         if (r < 0)
 217                 return r;
 218
 219         r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, manager_process_address, m);
 220         if (r < 0)
 221                 return r;
 222
 223         /* Then, enumerate all links */
 224         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
 225         if (r < 0)
 226                 return r;
 227
 228         r = sd_rtnl_message_request_dump(req, true);
 229         if (r < 0)
 230                 return r;
 231
 232         r = sd_rtnl_call(m->rtnl, req, 0, &reply);
 233         if (r < 0)
 234                 return r;
 235
 236         for (i = reply; i; i = sd_rtnl_message_next(i)) {
 237                 r = manager_process_link(m->rtnl, i, m);
 238                 if (r < 0)
 239                         return r;
 240         }
 241
 242         req = sd_rtnl_message_unref(req);
 243         reply = sd_rtnl_message_unref(reply);
 244
 245         /* Finally, enumerate all addresses, too */
 246         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, AF_UNSPEC);
 247         if (r < 0)
 248                 return r;
 249
 250         r = sd_rtnl_message_request_dump(req, true);
 251         if (r < 0)
 252                 return r;
 253
 254         r = sd_rtnl_call(m->rtnl, req, 0, &reply);
 255         if (r < 0)
 256                 return r;
 257
 258         for (i = reply; i; i = sd_rtnl_message_next(i)) {
 259                 r = manager_process_address(m->rtnl, i, m);
 260                 if (r < 0)
 261                         return r;
 262         }
 263
 264         return r;
 265 }
 266
 267 static int on_network_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 268         Manager *m = userdata;
 269         Iterator i;
 270         Link *l;
 271         int r;
 272
 273         assert(m);
 274
 275         sd_network_monitor_flush(m->network_monitor);
 276
 277         HASHMAP_FOREACH(l, m->links, i) {
 278                 r = link_update_monitor(l);
 279                 if (r < 0)
 280                         log_warning("Failed to update monitor information for %i: %s", l->ifindex, strerror(-r));
 281         }
 282
 283         r = manager_write_resolv_conf(m);
 284         if (r < 0)
 285                 log_warning("Could not update resolv.conf: %s", strerror(-r));
 286
 287         return 0;
 288 }
 289
 290 static int manager_network_monitor_listen(Manager *m) {
 291         int r, fd, events;
 292
 293         assert(m);
 294
 295         r = sd_network_monitor_new(&m->network_monitor, NULL);
 296         if (r < 0)
 297                 return r;
 298
 299         fd = sd_network_monitor_get_fd(m->network_monitor);
 300         if (fd < 0)
 301                 return fd;
 302
 303         events = sd_network_monitor_get_events(m->network_monitor);
 304         if (events < 0)
 305                 return events;
 306
 307         r = sd_event_add_io(m->event, &m->network_event_source, fd, events, &on_network_event, m);
 308         if (r < 0)
 309                 return r;
 310
 311         return 0;
 312 }
 313
 314 static int determine_hostname(char **ret) {
 315         _cleanup_free_ char *h = NULL, *n = NULL;
 316         int r;
 317
 318         assert(ret);
 319
 320         h = gethostname_malloc();
 321         if (!h)
 322                 return log_oom();
 323
 324         if (!utf8_is_valid(h)) {
 325                 log_error("System hostname is not UTF-8 clean.");
 326                 return -EINVAL;
 327         }
 328
 329         r = dns_name_normalize(h, &n);
 330         if (r < 0) {
 331                 log_error("System hostname '%s' cannot be normalized.", h);
 332                 return r;
 333         }
 334
 335         *ret = n;
 336         n = NULL;
 337
 338         return 0;
 339 }
 340
 341 static int on_hostname_change(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
 342         _cleanup_free_ char *h = NULL;
 343         Manager *m = userdata;
 344         int r;
 345
 346         assert(m);
 347
 348         r = determine_hostname(&h);
 349         if (r < 0)
 350                 return 0; /* ignore invalid hostnames */
 351
 352         if (streq(h, m->hostname))
 353                 return 0;
 354
 355         log_info("System hostname changed to '%s'.", h);
 356         free(m->hostname);
 357         m->hostname = h;
 358         h = NULL;
 359
 360         manager_refresh_rrs(m);
 361
 362         return 0;
 363 }
 364
 365 static int manager_watch_hostname(Manager *m) {
 366         int r;
 367
 368         assert(m);
 369
 370         m->hostname_fd = open("/proc/sys/kernel/hostname", O_RDONLY|O_CLOEXEC|O_NDELAY|O_NOCTTY);
 371         if (m->hostname_fd < 0) {
 372                 log_warning("Failed to watch hostname: %m");
 373                 return 0;
 374         }
 375
 376         r = sd_event_add_io(m->event, &m->hostname_event_source, m->hostname_fd, 0, on_hostname_change, m);
 377         if (r < 0) {
 378                 if (r == -EPERM)
 379                         /* kernels prior to 3.2 don't support polling this file. Ignore the failure. */
 380                         m->hostname_fd = safe_close(m->hostname_fd);
 381                 else {
 382                         log_error("Failed to add hostname event source: %s", strerror(-r));
 383                         return r;
 384                 }
 385         }
 386
 387         r = determine_hostname(&m->hostname);
 388         if (r < 0) {
 389                 log_info("Defaulting to hostname 'linux'.");
 390                 m->hostname = strdup("linux");
 391                 if (!m->hostname)
 392                         return log_oom();
 393         } else
 394                 log_info("Using system hostname '%s'.", m->hostname);
 395
 396         return 0;
 397 }
 398
 399 static void manager_llmnr_stop(Manager *m) {
 400         assert(m);
 401
 402         m->llmnr_ipv4_udp_event_source = sd_event_source_unref(m->llmnr_ipv4_udp_event_source);
 403         m->llmnr_ipv4_udp_fd = safe_close(m->llmnr_ipv4_udp_fd);
 404
 405         m->llmnr_ipv6_udp_event_source = sd_event_source_unref(m->llmnr_ipv6_udp_event_source);
 406         m->llmnr_ipv6_udp_fd = safe_close(m->llmnr_ipv6_udp_fd);
 407
 408         m->llmnr_ipv4_tcp_event_source = sd_event_source_unref(m->llmnr_ipv4_tcp_event_source);
 409         m->llmnr_ipv4_tcp_fd = safe_close(m->llmnr_ipv4_tcp_fd);
 410
 411         m->llmnr_ipv6_tcp_event_source = sd_event_source_unref(m->llmnr_ipv6_tcp_event_source);
 412         m->llmnr_ipv6_tcp_fd = safe_close(m->llmnr_ipv6_tcp_fd);
 413 }
 414
 415 static int manager_llmnr_start(Manager *m) {
 416         int r;
 417
 418         assert(m);
 419
 420         if (m->llmnr_support == SUPPORT_NO)
 421                 return 0;
 422
 423         r = manager_llmnr_ipv4_udp_fd(m);
 424         if (r == -EADDRINUSE)
 425                 goto eaddrinuse;
 426         if (r < 0)
 427                 return r;
 428
 429         r = manager_llmnr_ipv6_udp_fd(m);
 430         if (r == -EADDRINUSE)
 431                 goto eaddrinuse;
 432         if (r < 0)
 433                 return r;
 434
 435         r = manager_llmnr_ipv4_tcp_fd(m);
 436         if (r == -EADDRINUSE)
 437                 goto eaddrinuse;
 438         if (r < 0)
 439                 return r;
 440
 441         r = manager_llmnr_ipv6_tcp_fd(m);
 442         if (r == -EADDRINUSE)
 443                 goto eaddrinuse;
 444         if (r < 0)
 445                 return r;
 446
 447         return 0;
 448
 449 eaddrinuse:
 450         log_warning("There appears to be another LLMNR respondering running. Turning off LLMNR support.");
 451         m->llmnr_support = SUPPORT_NO;
 452         manager_llmnr_stop(m);
 453         return 0;
 454 }
 455
 456 int manager_new(Manager **ret) {
 457         _cleanup_(manager_freep) Manager *m = NULL;
 458         int r;
 459
 460         assert(ret);
 461
 462         m = new0(Manager, 1);
 463         if (!m)
 464                 return -ENOMEM;
 465
 466         m->dns_ipv4_fd = m->dns_ipv6_fd = -1;
 467         m->llmnr_ipv4_udp_fd = m->llmnr_ipv6_udp_fd = -1;
 468         m->llmnr_ipv4_tcp_fd = m->llmnr_ipv6_tcp_fd = -1;
 469         m->hostname_fd = -1;
 470
 471         m->llmnr_support = SUPPORT_YES;
 472         m->read_resolv_conf = true;
 473
 474         r = manager_parse_dns_server(m, DNS_SERVER_FALLBACK, DNS_SERVERS);
 475         if (r < 0)
 476                 return r;
 477
 478         r = sd_event_default(&m->event);
 479         if (r < 0)
 480                 return r;
 481
 482         sd_event_add_signal(m->event, NULL, SIGTERM, NULL,  NULL);
 483         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
 484
 485         sd_event_set_watchdog(m->event, true);
 486
 487         r = manager_watch_hostname(m);
 488         if (r < 0)
 489                 return r;
 490
 491         r = dns_scope_new(m, &m->unicast_scope, NULL, DNS_PROTOCOL_DNS, AF_UNSPEC);
 492         if (r < 0)
 493                 return r;
 494
 495         r = manager_network_monitor_listen(m);
 496         if (r < 0)
 497                 return r;
 498
 499         r = manager_rtnl_listen(m);
 500         if (r < 0)
 501                 return r;
 502
 503         r = manager_connect_bus(m);
 504         if (r < 0)
 505                 return r;
 506
 507         *ret = m;
 508         m = NULL;
 509
 510         return 0;
 511 }
 512
 513 int manager_start(Manager *m) {
 514         int r;
 515
 516         assert(m);
 517
 518         r = manager_llmnr_start(m);
 519         if (r < 0)
 520                 return r;
 521
 522         return 0;
 523 }
 524
 525 Manager *manager_free(Manager *m) {
 526         Link *l;
 527
 528         if (!m)
 529                 return NULL;
 530
 531         while ((l = hashmap_first(m->links)))
 532                link_free(l);
 533
 534         while (m->dns_queries)
 535                 dns_query_free(m->dns_queries);
 536
 537         dns_scope_free(m->unicast_scope);
 538
 539         while (m->dns_servers)
 540                 dns_server_free(m->dns_servers);
 541         while (m->fallback_dns_servers)
 542                 dns_server_free(m->fallback_dns_servers);
 543
 544         hashmap_free(m->links);
 545         hashmap_free(m->dns_transactions);
 546
 547         sd_event_source_unref(m->network_event_source);
 548         sd_network_monitor_unref(m->network_monitor);
 549
 550         sd_event_source_unref(m->dns_ipv4_event_source);
 551         sd_event_source_unref(m->dns_ipv6_event_source);
 552         safe_close(m->dns_ipv4_fd);
 553         safe_close(m->dns_ipv6_fd);
 554
 555         manager_llmnr_stop(m);
 556
 557         sd_bus_slot_unref(m->prepare_for_sleep_slot);
 558         sd_event_source_unref(m->bus_retry_event_source);
 559         sd_bus_unref(m->bus);
 560
 561         sd_event_unref(m->event);
 562
 563         dns_resource_key_unref(m->host_ipv4_key);
 564         dns_resource_key_unref(m->host_ipv6_key);
 565
 566         safe_close(m->hostname_fd);
 567         sd_event_source_unref(m->hostname_event_source);
 568         free(m->hostname);
 569
 570         free(m);
 571
 572         return NULL;
 573 }
 574
 575 int manager_read_resolv_conf(Manager *m) {
 576         _cleanup_fclose_ FILE *f = NULL;
 577         struct stat st, own;
 578         char line[LINE_MAX];
 579         DnsServer *s, *nx;
 580         usec_t t;
 581         int r;
 582
 583         assert(m);
 584
 585         /* Reads the system /etc/resolv.conf, if it exists and is not
 586          * symlinked to our own resolv.conf instance */
 587
 588         if (!m->read_resolv_conf)
 589                 return 0;
 590
 591         r = stat("/etc/resolv.conf", &st);
 592         if (r < 0) {
 593                 if (errno != ENOENT)
 594                         log_warning("Failed to open /etc/resolv.conf: %m");
 595                 r = -errno;
 596                 goto clear;
 597         }
 598
 599         /* Have we already seen the file? */
 600         t = timespec_load(&st.st_mtim);
 601         if (t == m->resolv_conf_mtime)
 602                 return 0;
 603
 604         m->resolv_conf_mtime = t;
 605
 606         /* Is it symlinked to our own file? */
 607         if (stat("/run/systemd/resolve/resolv.conf", &own) >= 0 &&
 608             st.st_dev == own.st_dev &&
 609             st.st_ino == own.st_ino) {
 610                 r = 0;
 611                 goto clear;
 612         }
 613
 614         f = fopen("/etc/resolv.conf", "re");
 615         if (!f) {
 616                 if (errno != ENOENT)
 617                         log_warning("Failed to open /etc/resolv.conf: %m");
 618                 r = -errno;
 619                 goto clear;
 620         }
 621
 622         if (fstat(fileno(f), &st) < 0) {
 623                 log_error("Failed to stat open file: %m");
 624                 r = -errno;
 625                 goto clear;
 626         }
 627
 628         LIST_FOREACH(servers, s, m->dns_servers)
 629                 s->marked = true;
 630
 631         FOREACH_LINE(line, f, r = -errno; goto clear) {
 632                 union in_addr_union address;
 633                 int family;
 634                 char *l;
 635                 const char *a;
 636
 637                 truncate_nl(line);
 638
 639                 l = strstrip(line);
 640                 if (*l == '#' || *l == ';')
 641                         continue;
 642
 643                 a = first_word(l, "nameserver");
 644                 if (!a)
 645                         continue;
 646
 647                 r = in_addr_from_string_auto(a, &family, &address);
 648                 if (r < 0) {
 649                         log_warning("Failed to parse name server %s.", a);
 650                         continue;
 651                 }
 652
 653                 LIST_FOREACH(servers, s, m->dns_servers)
 654                         if (s->family == family && in_addr_equal(family, &s->address, &address) > 0)
 655                                 break;
 656
 657                 if (s)
 658                         s->marked = false;
 659                 else {
 660                         r = dns_server_new(m, NULL, DNS_SERVER_SYSTEM, NULL, family, &address);
 661                         if (r < 0)
 662                                 goto clear;
 663                 }
 664         }
 665
 666         LIST_FOREACH_SAFE(servers, s, nx, m->dns_servers)
 667                 if (s->marked)
 668                         dns_server_free(s);
 669
 670         return 0;
 671
 672 clear:
 673         while (m->dns_servers)
 674                 dns_server_free(m->dns_servers);
 675
 676         return r;
 677 }
 678
 679 static void write_resolve_conf_server(DnsServer *s, FILE *f, unsigned *count) {
 680         _cleanup_free_ char *t  = NULL;
 681         int r;
 682
 683         assert(s);
 684         assert(f);
 685         assert(count);
 686
 687         r = in_addr_to_string(s->family, &s->address, &t);
 688         if (r < 0) {
 689                 log_warning("Invalid DNS address. Ignoring: %s", strerror(-r));
 690                 return;
 691         }
 692
 693         if (*count == MAXNS)
 694                 fputs("# Too many DNS servers configured, the following entries may be ignored.\n", f);
 695
 696         fprintf(f, "nameserver %s\n", t);
 697         (*count) ++;
 698 }
 699
 700 int manager_write_resolv_conf(Manager *m) {
 701         static const char path[] = "/run/systemd/resolve/resolv.conf";
 702         _cleanup_free_ char *temp_path = NULL;
 703         _cleanup_fclose_ FILE *f = NULL;
 704         _cleanup_set_free_ Set *dns = NULL;
 705         unsigned count = 0;
 706         DnsServer *s;
 707         Iterator i;
 708         Link *l;
 709         int r;
 710
 711         assert(m);
 712
 713         /* Read the system /etc/resolv.conf first */
 714         manager_read_resolv_conf(m);
 715
 716         /* Add the full list to a set, to filter out duplicates */
 717         dns = set_new(dns_server_hash_func, dns_server_compare_func);
 718         if (!dns)
 719                 return -ENOMEM;
 720
 721         /* First add the system-wide servers */
 722         LIST_FOREACH(servers, s, m->dns_servers) {
 723                 r = set_put(dns, s);
 724                 if (r == -EEXIST)
 725                         continue;
 726                 if (r < 0)
 727                         return r;
 728         }
 729
 730         /* Then, add the per-link servers */
 731         HASHMAP_FOREACH(l, m->links, i)
 732                 LIST_FOREACH(servers, s, l->dns_servers) {
 733                         r = set_put(dns, s);
 734                         if (r == -EEXIST)
 735                                 continue;
 736                         if (r < 0)
 737                                 return r;
 738                 }
 739
 740         /* If we found nothing, add the fallback servers */
 741         if (set_isempty(dns)) {
 742                 LIST_FOREACH(servers, s, m->fallback_dns_servers) {
 743                         r = set_put(dns, s);
 744                         if (r == -EEXIST)
 745                                 continue;
 746                         if (r < 0)
 747                                 return r;
 748                 }
 749         }
 750
 751         r = fopen_temporary(path, &f, &temp_path);
 752         if (r < 0)
 753                 return r;
 754
 755         fchmod(fileno(f), 0644);
 756
 757         fputs("# This file is managed by systemd-resolved(8). Do not edit.\n#\n"
 758               "# Third party programs must not access this file directly, but\n"
 759               "# only through the symlink at /etc/resolv.conf. To manage\n"
 760               "# resolv.conf(5) in a different way, replace the symlink by a\n"
 761               "# static file or a different symlink.\n\n", f);
 762
 763         if (set_isempty(dns))
 764                 fputs("# No DNS servers known.\n", f);
 765         else {
 766                 SET_FOREACH(s, dns, i)
 767                         write_resolve_conf_server(s, f, &count);
 768         }
 769
 770         r = fflush_and_check(f);
 771         if (r < 0)
 772                 goto fail;
 773
 774         if (rename(temp_path, path) < 0) {
 775                 r = -errno;
 776                 goto fail;
 777         }
 778
 779         return 0;
 780
 781 fail:
 782         unlink(path);
 783         unlink(temp_path);
 784         return r;
 785 }
 786
 787 int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) {
 788         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 789         union {
 790                 struct cmsghdr header; /* For alignment */
 791                 uint8_t buffer[CMSG_SPACE(MAX(sizeof(struct in_pktinfo), sizeof(struct in6_pktinfo)))
 792                                + CMSG_SPACE(int) /* ttl/hoplimit */
 793                                + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */];
 794         } control;
 795         union sockaddr_union sa;
 796         struct msghdr mh = {};
 797         struct cmsghdr *cmsg;
 798         struct iovec iov;
 799         int ms = 0, r;
 800         ssize_t l;
 801
 802         assert(m);
 803         assert(fd >= 0);
 804         assert(ret);
 805
 806         r = ioctl(fd, FIONREAD, &ms);
 807         if (r < 0)
 808                 return -errno;
 809         if (ms < 0)
 810                 return -EIO;
 811
 812         r = dns_packet_new(&p, protocol, ms);
 813         if (r < 0)
 814                 return r;
 815
 816         iov.iov_base = DNS_PACKET_DATA(p);
 817         iov.iov_len = p->allocated;
 818
 819         mh.msg_name = &sa.sa;
 820         mh.msg_namelen = sizeof(sa);
 821         mh.msg_iov = &iov;
 822         mh.msg_iovlen = 1;
 823         mh.msg_control = &control;
 824         mh.msg_controllen = sizeof(control);
 825
 826         l = recvmsg(fd, &mh, 0);
 827         if (l < 0) {
 828                 if (errno == EAGAIN || errno == EINTR)
 829                         return 0;
 830
 831                 return -errno;
 832         }
 833
 834         if (l <= 0)
 835                 return -EIO;
 836
 837         assert(!(mh.msg_flags & MSG_CTRUNC));
 838         assert(!(mh.msg_flags & MSG_TRUNC));
 839
 840         p->size = (size_t) l;
 841
 842         p->family = sa.sa.sa_family;
 843         p->ipproto = IPPROTO_UDP;
 844         if (p->family == AF_INET) {
 845                 p->sender.in = sa.in.sin_addr;
 846                 p->sender_port = be16toh(sa.in.sin_port);
 847         } else if (p->family == AF_INET6) {
 848                 p->sender.in6 = sa.in6.sin6_addr;
 849                 p->sender_port = be16toh(sa.in6.sin6_port);
 850                 p->ifindex = sa.in6.sin6_scope_id;
 851         } else
 852                 return -EAFNOSUPPORT;
 853
 854         for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
 855
 856                 if (cmsg->cmsg_level == IPPROTO_IPV6) {
 857                         assert(p->family == AF_INET6);
 858
 859                         switch (cmsg->cmsg_type) {
 860
 861                         case IPV6_PKTINFO: {
 862                                 struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg);
 863
 864                                 if (p->ifindex <= 0)
 865                                         p->ifindex = i->ipi6_ifindex;
 866
 867                                 p->destination.in6 = i->ipi6_addr;
 868                                 break;
 869                         }
 870
 871                         case IPV6_HOPLIMIT:
 872                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 873                                 break;
 874
 875                         }
 876                 } else if (cmsg->cmsg_level == IPPROTO_IP) {
 877                         assert(p->family == AF_INET);
 878
 879                         switch (cmsg->cmsg_type) {
 880
 881                         case IP_PKTINFO: {
 882                                 struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg);
 883
 884                                 if (p->ifindex <= 0)
 885                                         p->ifindex = i->ipi_ifindex;
 886
 887                                 p->destination.in = i->ipi_addr;
 888                                 break;
 889                         }
 890
 891                         case IP_TTL:
 892                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 893                                 break;
 894                         }
 895                 }
 896         }
 897
 898         /* The Linux kernel sets the interface index to the loopback
 899          * device if the packet came from the local host since it
 900          * avoids the routing table in such a case. Let's unset the
 901          * interface index in such a case. */
 902         if (p->ifindex > 0 && manager_ifindex_is_loopback(m, p->ifindex) != 0)
 903                 p->ifindex = 0;
 904
 905         /* If we don't know the interface index still, we look for the
 906          * first local interface with a matching address. Yuck! */
 907         if (p->ifindex <= 0)
 908                 p->ifindex = manager_find_ifindex(m, p->family, &p->destination);
 909
 910         *ret = p;
 911         p = NULL;
 912
 913         return 1;
 914 }
 915
 916 static int on_dns_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 917         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 918         DnsTransaction *t = NULL;
 919         Manager *m = userdata;
 920         int r;
 921
 922         r = manager_recv(m, fd, DNS_PROTOCOL_DNS, &p);
 923         if (r <= 0)
 924                 return r;
 925
 926         if (dns_packet_validate_reply(p) > 0) {
 927                 t = hashmap_get(m->dns_transactions, UINT_TO_PTR(DNS_PACKET_ID(p)));
 928                 if (!t)
 929                         return 0;
 930
 931                 dns_transaction_process_reply(t, p);
 932
 933         } else
 934                 log_debug("Invalid DNS packet.");
 935
 936         return 0;
 937 }
 938
 939 int manager_dns_ipv4_fd(Manager *m) {
 940         const int one = 1;
 941         int r;
 942
 943         assert(m);
 944
 945         if (m->dns_ipv4_fd >= 0)
 946                 return m->dns_ipv4_fd;
 947
 948         m->dns_ipv4_fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 949         if (m->dns_ipv4_fd < 0)
 950                 return -errno;
 951
 952         r = setsockopt(m->dns_ipv4_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
 953         if (r < 0) {
 954                 r = -errno;
 955                 goto fail;
 956         }
 957
 958         r = sd_event_add_io(m->event, &m->dns_ipv4_event_source, m->dns_ipv4_fd, EPOLLIN, on_dns_packet, m);
 959         if (r < 0)
 960                 goto fail;
 961
 962         return m->dns_ipv4_fd;
 963
 964 fail:
 965         m->dns_ipv4_fd = safe_close(m->dns_ipv4_fd);
 966         return r;
 967 }
 968
 969 int manager_dns_ipv6_fd(Manager *m) {
 970         const int one = 1;
 971         int r;
 972
 973         assert(m);
 974
 975         if (m->dns_ipv6_fd >= 0)
 976                 return m->dns_ipv6_fd;
 977
 978         m->dns_ipv6_fd = socket(AF_INET6, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 979         if (m->dns_ipv6_fd < 0)
 980                 return -errno;
 981
 982         r = setsockopt(m->dns_ipv6_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
 983         if (r < 0) {
 984                 r = -errno;
 985                 goto fail;
 986         }
 987
 988         r = sd_event_add_io(m->event, &m->dns_ipv6_event_source, m->dns_ipv6_fd, EPOLLIN, on_dns_packet, m);
 989         if (r < 0)
 990                 goto fail;
 991
 992         return m->dns_ipv6_fd;
 993
 994 fail:
 995         m->dns_ipv6_fd = safe_close(m->dns_ipv6_fd);
 996         return r;
 997 }
 998
 999 static int sendmsg_loop(int fd, struct msghdr *mh, int flags) {
1000         int r;
1001
1002         assert(fd >= 0);
1003         assert(mh);
1004
1005         for (;;) {
1006                 if (sendmsg(fd, mh, flags) >= 0)
1007                         return 0;
1008
1009                 if (errno == EINTR)
1010                         continue;
1011
1012                 if (errno != EAGAIN)
1013                         return -errno;
1014
1015                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
1016                 if (r < 0)
1017                         return r;
1018                 if (r == 0)
1019                         return -ETIMEDOUT;
1020         }
1021 }
1022
1023 static int manager_ipv4_send(Manager *m, int fd, int ifindex, const struct in_addr *addr, uint16_t port, DnsPacket *p) {
1024         union sockaddr_union sa = {
1025                 .in.sin_family = AF_INET,
1026         };
1027         union {
1028                 struct cmsghdr header; /* For alignment */
1029                 uint8_t buffer[CMSG_SPACE(sizeof(struct in_pktinfo))];
1030         } control;
1031         struct msghdr mh = {};
1032         struct iovec iov;
1033
1034         assert(m);
1035         assert(fd >= 0);
1036         assert(addr);
1037         assert(port > 0);
1038         assert(p);
1039
1040         iov.iov_base = DNS_PACKET_DATA(p);
1041         iov.iov_len = p->size;
1042
1043         sa.in.sin_addr = *addr;
1044         sa.in.sin_port = htobe16(port),
1045
1046         mh.msg_iov = &iov;
1047         mh.msg_iovlen = 1;
1048         mh.msg_name = &sa.sa;
1049         mh.msg_namelen = sizeof(sa.in);
1050
1051         if (ifindex > 0) {
1052                 struct cmsghdr *cmsg;
1053                 struct in_pktinfo *pi;
1054
1055                 zero(control);
1056
1057                 mh.msg_control = &control;
1058                 mh.msg_controllen = CMSG_LEN(sizeof(struct in_pktinfo));
1059
1060                 cmsg = CMSG_FIRSTHDR(&mh);
1061                 cmsg->cmsg_len = mh.msg_controllen;
1062                 cmsg->cmsg_level = IPPROTO_IP;
1063                 cmsg->cmsg_type = IP_PKTINFO;
1064
1065                 pi = (struct in_pktinfo*) CMSG_DATA(cmsg);
1066                 pi->ipi_ifindex = ifindex;
1067         }
1068
1069         return sendmsg_loop(fd, &mh, 0);
1070 }
1071
1072 static int manager_ipv6_send(Manager *m, int fd, int ifindex, const struct in6_addr *addr, uint16_t port, DnsPacket *p) {
1073         union sockaddr_union sa = {
1074                 .in6.sin6_family = AF_INET6,
1075         };
1076         union {
1077                 struct cmsghdr header; /* For alignment */
1078                 uint8_t buffer[CMSG_SPACE(sizeof(struct in6_pktinfo))];
1079         } control;
1080         struct msghdr mh = {};
1081         struct iovec iov;
1082
1083         assert(m);
1084         assert(fd >= 0);
1085         assert(addr);
1086         assert(port > 0);
1087         assert(p);
1088
1089         iov.iov_base = DNS_PACKET_DATA(p);
1090         iov.iov_len = p->size;
1091
1092         sa.in6.sin6_addr = *addr;
1093         sa.in6.sin6_port = htobe16(port),
1094         sa.in6.sin6_scope_id = ifindex;
1095
1096         mh.msg_iov = &iov;
1097         mh.msg_iovlen = 1;
1098         mh.msg_name = &sa.sa;
1099         mh.msg_namelen = sizeof(sa.in6);
1100
1101         if (ifindex > 0) {
1102                 struct cmsghdr *cmsg;
1103                 struct in6_pktinfo *pi;
1104
1105                 zero(control);
1106
1107                 mh.msg_control = &control;
1108                 mh.msg_controllen = CMSG_LEN(sizeof(struct in6_pktinfo));
1109
1110                 cmsg = CMSG_FIRSTHDR(&mh);
1111                 cmsg->cmsg_len = mh.msg_controllen;
1112                 cmsg->cmsg_level = IPPROTO_IPV6;
1113                 cmsg->cmsg_type = IPV6_PKTINFO;
1114
1115                 pi = (struct in6_pktinfo*) CMSG_DATA(cmsg);
1116                 pi->ipi6_ifindex = ifindex;
1117         }
1118
1119         return sendmsg_loop(fd, &mh, 0);
1120 }
1121
1122 int manager_send(Manager *m, int fd, int ifindex, int family, const union in_addr_union *addr, uint16_t port, DnsPacket *p) {
1123         assert(m);
1124         assert(fd >= 0);
1125         assert(addr);
1126         assert(port > 0);
1127         assert(p);
1128
1129         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));
1130
1131         if (family == AF_INET)
1132                 return manager_ipv4_send(m, fd, ifindex, &addr->in, port, p);
1133         else if (family == AF_INET6)
1134                 return manager_ipv6_send(m, fd, ifindex, &addr->in6, port, p);
1135
1136         return -EAFNOSUPPORT;
1137 }
1138
1139 DnsServer* manager_find_dns_server(Manager *m, int family, const union in_addr_union *in_addr) {
1140         DnsServer *s;
1141
1142         assert(m);
1143         assert(in_addr);
1144
1145         LIST_FOREACH(servers, s, m->dns_servers)
1146                 if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0)
1147                         return s;
1148
1149         LIST_FOREACH(servers, s, m->fallback_dns_servers)
1150                 if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0)
1151                         return s;
1152
1153         return NULL;
1154 }
1155
1156 DnsServer *manager_set_dns_server(Manager *m, DnsServer *s) {
1157         assert(m);
1158
1159         if (m->current_dns_server == s)
1160                 return s;
1161
1162         if (s) {
1163                 _cleanup_free_ char *ip = NULL;
1164
1165                 in_addr_to_string(s->family, &s->address, &ip);
1166                 log_info("Switching to system DNS server %s.", strna(ip));
1167         }
1168
1169         m->current_dns_server = s;
1170
1171         if (m->unicast_scope)
1172                 dns_cache_flush(&m->unicast_scope->cache);
1173
1174         return s;
1175 }
1176
1177 DnsServer *manager_get_dns_server(Manager *m) {
1178         Link *l;
1179         assert(m);
1180
1181         /* Try to read updates resolv.conf */
1182         manager_read_resolv_conf(m);
1183
1184         if (!m->current_dns_server)
1185                 manager_set_dns_server(m, m->dns_servers);
1186
1187         if (!m->current_dns_server) {
1188                 bool found = false;
1189                 Iterator i;
1190
1191                 /* No DNS servers configured, let's see if there are
1192                  * any on any links. If not, we use the fallback
1193                  * servers */
1194
1195                 HASHMAP_FOREACH(l, m->links, i)
1196                         if (l->dns_servers) {
1197                                 found = true;
1198                                 break;
1199                         }
1200
1201                 if (!found)
1202                         manager_set_dns_server(m, m->fallback_dns_servers);
1203         }
1204
1205         return m->current_dns_server;
1206 }
1207
1208 void manager_next_dns_server(Manager *m) {
1209         assert(m);
1210
1211         /* If there's currently no DNS server set, then the next
1212          * manager_get_dns_server() will find one */
1213         if (!m->current_dns_server)
1214                 return;
1215
1216         /* Change to the next one */
1217         if (m->current_dns_server->servers_next) {
1218                 manager_set_dns_server(m, m->current_dns_server->servers_next);
1219                 return;
1220         }
1221
1222         /* If there was no next one, then start from the beginning of
1223          * the list */
1224         if (m->current_dns_server->type == DNS_SERVER_FALLBACK)
1225                 manager_set_dns_server(m, m->fallback_dns_servers);
1226         else
1227                 manager_set_dns_server(m, m->dns_servers);
1228 }
1229
1230 uint32_t manager_find_mtu(Manager *m) {
1231         uint32_t mtu = 0;
1232         Link *l;
1233         Iterator i;
1234
1235         /* If we don't know on which link a DNS packet would be
1236          * delivered, let's find the largest MTU that works on all
1237          * interfaces we know of */
1238
1239         HASHMAP_FOREACH(l, m->links, i) {
1240                 if (l->mtu <= 0)
1241                         continue;
1242
1243                 if (mtu <= 0 || l->mtu < mtu)
1244                         mtu = l->mtu;
1245         }
1246
1247         return mtu;
1248 }
1249
1250 static int on_llmnr_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1251         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
1252         DnsTransaction *t = NULL;
1253         Manager *m = userdata;
1254         DnsScope *scope;
1255         int r;
1256
1257         r = manager_recv(m, fd, DNS_PROTOCOL_LLMNR, &p);
1258         if (r <= 0)
1259                 return r;
1260
1261         scope = manager_find_scope(m, p);
1262         if (!scope) {
1263                 log_warning("Got LLMNR UDP packet on unknown scope. Ignoring.");
1264                 return 0;
1265         }
1266
1267         if (dns_packet_validate_reply(p) > 0) {
1268                 log_debug("Got reply packet for id %u", DNS_PACKET_ID(p));
1269
1270                 dns_scope_check_conflicts(scope, p);
1271
1272                 t = hashmap_get(m->dns_transactions, UINT_TO_PTR(DNS_PACKET_ID(p)));
1273                 if (t)
1274                         dns_transaction_process_reply(t, p);
1275
1276         } else if (dns_packet_validate_query(p) > 0)  {
1277                 log_debug("Got query packet for id %u", DNS_PACKET_ID(p));
1278
1279                 dns_scope_process_query(scope, NULL, p);
1280         } else
1281                 log_debug("Invalid LLMNR UDP packet.");
1282
1283         return 0;
1284 }
1285
1286 int manager_llmnr_ipv4_udp_fd(Manager *m) {
1287         union sockaddr_union sa = {
1288                 .in.sin_family = AF_INET,
1289                 .in.sin_port = htobe16(5355),
1290         };
1291         static const int one = 1, pmtu = IP_PMTUDISC_DONT, ttl = 255;
1292         int r;
1293
1294         assert(m);
1295
1296         if (m->llmnr_ipv4_udp_fd >= 0)
1297                 return m->llmnr_ipv4_udp_fd;
1298
1299         m->llmnr_ipv4_udp_fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1300         if (m->llmnr_ipv4_udp_fd < 0)
1301                 return -errno;
1302
1303         /* RFC 4795, section 2.5 recommends setting the TTL of UDP packets to 255. */
1304         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl));
1305         if (r < 0) {
1306                 r = -errno;
1307                 goto fail;
1308         }
1309
1310         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl));
1311         if (r < 0) {
1312                 r = -errno;
1313                 goto fail;
1314         }
1315
1316         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_LOOP, &one, sizeof(one));
1317         if (r < 0) {
1318                 r = -errno;
1319                 goto fail;
1320         }
1321
1322         r = setsockopt(m->llmnr_ipv4_udp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1323         if (r < 0) {
1324                 r = -errno;
1325                 goto fail;
1326         }
1327
1328         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
1329         if (r < 0) {
1330                 r = -errno;
1331                 goto fail;
1332         }
1333
1334         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_RECVTTL, &one, sizeof(one));
1335         if (r < 0) {
1336                 r = -errno;
1337                 goto fail;
1338         }
1339
1340         /* Disable Don't-Fragment bit in the IP header */
1341         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu));
1342         if (r < 0) {
1343                 r = -errno;
1344                 goto fail;
1345         }
1346
1347         r = bind(m->llmnr_ipv4_udp_fd, &sa.sa, sizeof(sa.in));
1348         if (r < 0) {
1349                 r = -errno;
1350                 goto fail;
1351         }
1352
1353         r = sd_event_add_io(m->event, &m->llmnr_ipv4_udp_event_source, m->llmnr_ipv4_udp_fd, EPOLLIN, on_llmnr_packet, m);
1354         if (r < 0)
1355                 goto fail;
1356
1357         return m->llmnr_ipv4_udp_fd;
1358
1359 fail:
1360         m->llmnr_ipv4_udp_fd = safe_close(m->llmnr_ipv4_udp_fd);
1361         return r;
1362 }
1363
1364 int manager_llmnr_ipv6_udp_fd(Manager *m) {
1365         union sockaddr_union sa = {
1366                 .in6.sin6_family = AF_INET6,
1367                 .in6.sin6_port = htobe16(5355),
1368         };
1369         static const int one = 1, ttl = 255;
1370         int r;
1371
1372         assert(m);
1373
1374         if (m->llmnr_ipv6_udp_fd >= 0)
1375                 return m->llmnr_ipv6_udp_fd;
1376
1377         m->llmnr_ipv6_udp_fd = socket(AF_INET6, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1378         if (m->llmnr_ipv6_udp_fd < 0)
1379                 return -errno;
1380
1381         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl));
1382         if (r < 0) {
1383                 r = -errno;
1384                 goto fail;
1385         }
1386
1387         /* RFC 4795, section 2.5 recommends setting the TTL of UDP packets to 255. */
1388         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl));
1389         if (r < 0) {
1390                 r = -errno;
1391                 goto fail;
1392         }
1393
1394         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &one, sizeof(one));
1395         if (r < 0) {
1396                 r = -errno;
1397                 goto fail;
1398         }
1399
1400         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
1401         if (r < 0) {
1402                 r = -errno;
1403                 goto fail;
1404         }
1405
1406         r = setsockopt(m->llmnr_ipv6_udp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1407         if (r < 0) {
1408                 r = -errno;
1409                 goto fail;
1410         }
1411
1412         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
1413         if (r < 0) {
1414                 r = -errno;
1415                 goto fail;
1416         }
1417
1418         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &one, sizeof(one));
1419         if (r < 0) {
1420                 r = -errno;
1421                 goto fail;
1422         }
1423
1424         r = bind(m->llmnr_ipv6_udp_fd, &sa.sa, sizeof(sa.in6));
1425         if (r < 0) {
1426                 r = -errno;
1427                 goto fail;
1428         }
1429
1430         r = sd_event_add_io(m->event, &m->llmnr_ipv6_udp_event_source, m->llmnr_ipv6_udp_fd, EPOLLIN, on_llmnr_packet, m);
1431         if (r < 0)  {
1432                 r = -errno;
1433                 goto fail;
1434         }
1435
1436         return m->llmnr_ipv6_udp_fd;
1437
1438 fail:
1439         m->llmnr_ipv6_udp_fd = safe_close(m->llmnr_ipv6_udp_fd);
1440         return r;
1441 }
1442
1443 static int on_llmnr_stream_packet(DnsStream *s) {
1444         DnsScope *scope;
1445
1446         assert(s);
1447
1448         scope = manager_find_scope(s->manager, s->read_packet);
1449         if (!scope) {
1450                 log_warning("Got LLMNR TCP packet on unknown scope. Ignroing.");
1451                 return 0;
1452         }
1453
1454         if (dns_packet_validate_query(s->read_packet) > 0) {
1455                 log_debug("Got query packet for id %u", DNS_PACKET_ID(s->read_packet));
1456
1457                 dns_scope_process_query(scope, s, s->read_packet);
1458
1459                 /* If no reply packet was set, we free the stream */
1460                 if (s->write_packet)
1461                         return 0;
1462         } else
1463                 log_debug("Invalid LLMNR TCP packet.");
1464
1465         dns_stream_free(s);
1466         return 0;
1467 }
1468
1469 static int on_llmnr_stream(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1470         DnsStream *stream;
1471         Manager *m = userdata;
1472         int cfd, r;
1473
1474         cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
1475         if (cfd < 0) {
1476                 if (errno == EAGAIN || errno == EINTR)
1477                         return 0;
1478
1479                 return -errno;
1480         }
1481
1482         r = dns_stream_new(m, &stream, DNS_PROTOCOL_LLMNR, cfd);
1483         if (r < 0) {
1484                 safe_close(cfd);
1485                 return r;
1486         }
1487
1488         stream->on_packet = on_llmnr_stream_packet;
1489         return 0;
1490 }
1491
1492 int manager_llmnr_ipv4_tcp_fd(Manager *m) {
1493         union sockaddr_union sa = {
1494                 .in.sin_family = AF_INET,
1495                 .in.sin_port = htobe16(5355),
1496         };
1497         static const int one = 1, pmtu = IP_PMTUDISC_DONT;
1498         int r;
1499
1500         assert(m);
1501
1502         if (m->llmnr_ipv4_tcp_fd >= 0)
1503                 return m->llmnr_ipv4_tcp_fd;
1504
1505         m->llmnr_ipv4_tcp_fd = socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1506         if (m->llmnr_ipv4_tcp_fd < 0)
1507                 return -errno;
1508
1509         /* RFC 4795, section 2.5. requires setting the TTL of TCP streams to 1 */
1510         r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_TTL, &one, sizeof(one));
1511         if (r < 0) {
1512                 r = -errno;
1513                 goto fail;
1514         }
1515
1516         r = setsockopt(m->llmnr_ipv4_tcp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1517         if (r < 0) {
1518                 r = -errno;
1519                 goto fail;
1520         }
1521
1522         r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
1523         if (r < 0) {
1524                 r = -errno;
1525                 goto fail;
1526         }
1527
1528         r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_RECVTTL, &one, sizeof(one));
1529         if (r < 0) {
1530                 r = -errno;
1531                 goto fail;
1532         }
1533
1534         /* Disable Don't-Fragment bit in the IP header */
1535         r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu));
1536         if (r < 0) {
1537                 r = -errno;
1538                 goto fail;
1539         }
1540
1541         r = bind(m->llmnr_ipv4_tcp_fd, &sa.sa, sizeof(sa.in));
1542         if (r < 0) {
1543                 r = -errno;
1544                 goto fail;
1545         }
1546
1547         r = listen(m->llmnr_ipv4_tcp_fd, SOMAXCONN);
1548         if (r < 0) {
1549                 r = -errno;
1550                 goto fail;
1551         }
1552
1553         r = sd_event_add_io(m->event, &m->llmnr_ipv4_tcp_event_source, m->llmnr_ipv4_tcp_fd, EPOLLIN, on_llmnr_stream, m);
1554         if (r < 0)
1555                 goto fail;
1556
1557         return m->llmnr_ipv4_tcp_fd;
1558
1559 fail:
1560         m->llmnr_ipv4_tcp_fd = safe_close(m->llmnr_ipv4_tcp_fd);
1561         return r;
1562 }
1563
1564 int manager_llmnr_ipv6_tcp_fd(Manager *m) {
1565         union sockaddr_union sa = {
1566                 .in6.sin6_family = AF_INET6,
1567                 .in6.sin6_port = htobe16(5355),
1568         };
1569         static const int one = 1;
1570         int r;
1571
1572         assert(m);
1573
1574         if (m->llmnr_ipv6_tcp_fd >= 0)
1575                 return m->llmnr_ipv6_tcp_fd;
1576
1577         m->llmnr_ipv6_tcp_fd = socket(AF_INET6, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1578         if (m->llmnr_ipv6_tcp_fd < 0)
1579                 return -errno;
1580
1581         /* RFC 4795, section 2.5. requires setting the TTL of TCP streams to 1 */
1582         r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &one, sizeof(one));
1583         if (r < 0) {
1584                 r = -errno;
1585                 goto fail;
1586         }
1587
1588         r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
1589         if (r < 0) {
1590                 r = -errno;
1591                 goto fail;
1592         }
1593
1594         r = setsockopt(m->llmnr_ipv6_tcp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1595         if (r < 0) {
1596                 r = -errno;
1597                 goto fail;
1598         }
1599
1600         r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
1601         if (r < 0) {
1602                 r = -errno;
1603                 goto fail;
1604         }
1605
1606         r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &one, sizeof(one));
1607         if (r < 0) {
1608                 r = -errno;
1609                 goto fail;
1610         }
1611
1612         r = bind(m->llmnr_ipv6_tcp_fd, &sa.sa, sizeof(sa.in6));
1613         if (r < 0) {
1614                 r = -errno;
1615                 goto fail;
1616         }
1617
1618         r = listen(m->llmnr_ipv6_tcp_fd, SOMAXCONN);
1619         if (r < 0) {
1620                 r = -errno;
1621                 goto fail;
1622         }
1623
1624         r = sd_event_add_io(m->event, &m->llmnr_ipv6_tcp_event_source, m->llmnr_ipv6_tcp_fd, EPOLLIN, on_llmnr_stream, m);
1625         if (r < 0)  {
1626                 r = -errno;
1627                 goto fail;
1628         }
1629
1630         return m->llmnr_ipv6_tcp_fd;
1631
1632 fail:
1633         m->llmnr_ipv6_tcp_fd = safe_close(m->llmnr_ipv6_tcp_fd);
1634         return r;
1635 }
1636
1637 int manager_ifindex_is_loopback(Manager *m, int ifindex) {
1638         Link *l;
1639         assert(m);
1640
1641         if (ifindex <= 0)
1642                 return -EINVAL;
1643
1644         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
1645         if (l->flags & IFF_LOOPBACK)
1646                 return 1;
1647
1648         return 0;
1649 }
1650
1651 int manager_find_ifindex(Manager *m, int family, const union in_addr_union *in_addr) {
1652         LinkAddress *a;
1653
1654         assert(m);
1655
1656         a = manager_find_link_address(m, family, in_addr);
1657         if (a)
1658                 return a->link->ifindex;
1659
1660         return 0;
1661 }
1662
1663 void manager_refresh_rrs(Manager *m) {
1664         Iterator i;
1665         Link *l;
1666
1667         assert(m);
1668
1669         m->host_ipv4_key = dns_resource_key_unref(m->host_ipv4_key);
1670         m->host_ipv6_key = dns_resource_key_unref(m->host_ipv6_key);
1671
1672         HASHMAP_FOREACH(l, m->links, i) {
1673                 link_add_rrs(l, true);
1674                 link_add_rrs(l, false);
1675         }
1676 }
1677
1678 int manager_next_hostname(Manager *m) {
1679         const char *p;
1680         uint64_t u, a;
1681         char *h;
1682
1683         assert(m);
1684
1685         p = strchr(m->hostname, 0);
1686         assert(p);
1687
1688         while (p > m->hostname) {
1689                 if (!strchr("0123456789", p[-1]))
1690                         break;
1691
1692                 p--;
1693         }
1694
1695         if (*p == 0 || safe_atou64(p, &u) < 0 || u <= 0)
1696                 u = 1;
1697
1698         /* Add a random number to the old value. This way we can avoid
1699          * that two hosts pick the same hostname, win on IPv4 and lose
1700          * on IPv6 (or vice versa), and pick the same hostname
1701          * replacement hostname, ad infinitum. We still want the
1702          * numbers to go up monotonically, hence we just add a random
1703          * value 1..10 */
1704
1705         random_bytes(&a, sizeof(a));
1706         u += 1 + a % 10;
1707
1708         if (asprintf(&h, "%.*s%" PRIu64, (int) (p - m->hostname), m->hostname, u) < 0)
1709                 return -ENOMEM;
1710
1711         log_info("Hostname conflict, changing published hostname from '%s' to '%s'.", m->hostname, h);
1712
1713         free(m->hostname);
1714         m->hostname = h;
1715
1716         manager_refresh_rrs(m);
1717
1718         return 0;
1719 }
1720
1721 LinkAddress* manager_find_link_address(Manager *m, int family, const union in_addr_union *in_addr) {
1722         Iterator i;
1723         Link *l;
1724
1725         assert(m);
1726
1727         HASHMAP_FOREACH(l, m->links, i) {
1728                 LinkAddress *a;
1729
1730                 a = link_find_address(l, family, in_addr);
1731                 if (a)
1732                         return a;
1733         }
1734
1735         return NULL;
1736 }
1737
1738 bool manager_our_packet(Manager *m, DnsPacket *p) {
1739         assert(m);
1740         assert(p);
1741
1742         return !!manager_find_link_address(m, p->family, &p->sender);
1743 }
1744
1745 DnsScope* manager_find_scope(Manager *m, DnsPacket *p) {
1746         Link *l;
1747
1748         assert(m);
1749         assert(p);
1750
1751         l = hashmap_get(m->links, INT_TO_PTR(p->ifindex));
1752         if (!l)
1753                 return NULL;
1754
1755         if (p->protocol == DNS_PROTOCOL_LLMNR) {
1756                 if (p->family == AF_INET)
1757                         return l->llmnr_ipv4_scope;
1758                 else if (p->family == AF_INET6)
1759                         return l->llmnr_ipv6_scope;
1760         }
1761
1762         return NULL;
1763 }
1764
1765 void manager_verify_all(Manager *m) {
1766         DnsScope *s;
1767
1768         assert(m);
1769
1770         LIST_FOREACH(scopes, s, m->dns_scopes)
1771                 dns_zone_verify_all(&s->zone);
1772 }
1773
1774 static const char* const support_table[_SUPPORT_MAX] = {
1775         [SUPPORT_NO] = "no",
1776         [SUPPORT_YES] = "yes",
1777         [SUPPORT_RESOLVE] = "resolve",
1778 };
1779 DEFINE_STRING_TABLE_LOOKUP(support, Support);