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