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_event_source_unref(m->bus_retry_event_source);
 558         sd_bus_unref(m->bus);
 559
 560         sd_event_unref(m->event);
 561
 562         dns_resource_key_unref(m->host_ipv4_key);
 563         dns_resource_key_unref(m->host_ipv6_key);
 564
 565         safe_close(m->hostname_fd);
 566         sd_event_source_unref(m->hostname_event_source);
 567         free(m->hostname);
 568
 569         free(m);
 570
 571         return NULL;
 572 }
 573
 574 int manager_read_resolv_conf(Manager *m) {
 575         _cleanup_fclose_ FILE *f = NULL;
 576         struct stat st, own;
 577         char line[LINE_MAX];
 578         DnsServer *s, *nx;
 579         usec_t t;
 580         int r;
 581
 582         assert(m);
 583
 584         /* Reads the system /etc/resolv.conf, if it exists and is not
 585          * symlinked to our own resolv.conf instance */
 586
 587         if (!m->read_resolv_conf)
 588                 return 0;
 589
 590         r = stat("/etc/resolv.conf", &st);
 591         if (r < 0) {
 592                 if (errno != ENOENT)
 593                         log_warning("Failed to open /etc/resolv.conf: %m");
 594                 r = -errno;
 595                 goto clear;
 596         }
 597
 598         /* Have we already seen the file? */
 599         t = timespec_load(&st.st_mtim);
 600         if (t == m->resolv_conf_mtime)
 601                 return 0;
 602
 603         m->resolv_conf_mtime = t;
 604
 605         /* Is it symlinked to our own file? */
 606         if (stat("/run/systemd/resolve/resolv.conf", &own) >= 0 &&
 607             st.st_dev == own.st_dev &&
 608             st.st_ino == own.st_ino) {
 609                 r = 0;
 610                 goto clear;
 611         }
 612
 613         f = fopen("/etc/resolv.conf", "re");
 614         if (!f) {
 615                 if (errno != ENOENT)
 616                         log_warning("Failed to open /etc/resolv.conf: %m");
 617                 r = -errno;
 618                 goto clear;
 619         }
 620
 621         if (fstat(fileno(f), &st) < 0) {
 622                 log_error("Failed to stat open file: %m");
 623                 r = -errno;
 624                 goto clear;
 625         }
 626
 627         LIST_FOREACH(servers, s, m->dns_servers)
 628                 s->marked = true;
 629
 630         FOREACH_LINE(line, f, r = -errno; goto clear) {
 631                 union in_addr_union address;
 632                 int family;
 633                 char *l;
 634                 const char *a;
 635
 636                 truncate_nl(line);
 637
 638                 l = strstrip(line);
 639                 if (*l == '#' || *l == ';')
 640                         continue;
 641
 642                 a = first_word(l, "nameserver");
 643                 if (!a)
 644                         continue;
 645
 646                 r = in_addr_from_string_auto(a, &family, &address);
 647                 if (r < 0) {
 648                         log_warning("Failed to parse name server %s.", a);
 649                         continue;
 650                 }
 651
 652                 LIST_FOREACH(servers, s, m->dns_servers)
 653                         if (s->family == family && in_addr_equal(family, &s->address, &address) > 0)
 654                                 break;
 655
 656                 if (s)
 657                         s->marked = false;
 658                 else {
 659                         r = dns_server_new(m, NULL, DNS_SERVER_SYSTEM, NULL, family, &address);
 660                         if (r < 0)
 661                                 goto clear;
 662                 }
 663         }
 664
 665         LIST_FOREACH_SAFE(servers, s, nx, m->dns_servers)
 666                 if (s->marked)
 667                         dns_server_free(s);
 668
 669         return 0;
 670
 671 clear:
 672         while (m->dns_servers)
 673                 dns_server_free(m->dns_servers);
 674
 675         return r;
 676 }
 677
 678 static void write_resolve_conf_server(DnsServer *s, FILE *f, unsigned *count) {
 679         _cleanup_free_ char *t  = NULL;
 680         int r;
 681
 682         assert(s);
 683         assert(f);
 684         assert(count);
 685
 686         r = in_addr_to_string(s->family, &s->address, &t);
 687         if (r < 0) {
 688                 log_warning("Invalid DNS address. Ignoring: %s", strerror(-r));
 689                 return;
 690         }
 691
 692         if (*count == MAXNS)
 693                 fputs("# Too many DNS servers configured, the following entries may be ignored\n", f);
 694
 695         fprintf(f, "nameserver %s\n", t);
 696         (*count) ++;
 697 }
 698
 699 int manager_write_resolv_conf(Manager *m) {
 700         static const char path[] = "/run/systemd/resolve/resolv.conf";
 701         _cleanup_free_ char *temp_path = NULL;
 702         _cleanup_fclose_ FILE *f = NULL;
 703         unsigned count = 0;
 704         DnsServer *s;
 705         Iterator i;
 706         Link *l;
 707         int r;
 708
 709         assert(m);
 710
 711         /* Read the system /etc/resolv.conf first */
 712         manager_read_resolv_conf(m);
 713
 714         r = fopen_temporary(path, &f, &temp_path);
 715         if (r < 0)
 716                 return r;
 717
 718         fchmod(fileno(f), 0644);
 719
 720         fputs("# This file is managed by systemd-resolved(8). Do not edit.\n#\n"
 721               "# Third party programs must not access this file directly, but\n"
 722               "# only through the symlink at /etc/resolv.conf. To manage\n"
 723               "# resolv.conf(5) in a different way, replace the symlink by a\n"
 724               "# static file or a different symlink.\n\n", f);
 725
 726         LIST_FOREACH(servers, s, m->dns_servers)
 727                 write_resolve_conf_server(s, f, &count);
 728
 729         HASHMAP_FOREACH(l, m->links, i)
 730                 LIST_FOREACH(servers, s, l->dns_servers)
 731                         write_resolve_conf_server(s, f, &count);
 732
 733         if (count == 0) {
 734                 LIST_FOREACH(servers, s, m->fallback_dns_servers)
 735                         write_resolve_conf_server(s, f, &count);
 736         }
 737
 738         r = fflush_and_check(f);
 739         if (r < 0)
 740                 goto fail;
 741
 742         if (rename(temp_path, path) < 0) {
 743                 r = -errno;
 744                 goto fail;
 745         }
 746
 747         return 0;
 748
 749 fail:
 750         unlink(path);
 751         unlink(temp_path);
 752         return r;
 753 }
 754
 755 int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) {
 756         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 757         union {
 758                 struct cmsghdr header; /* For alignment */
 759                 uint8_t buffer[CMSG_SPACE(MAX(sizeof(struct in_pktinfo), sizeof(struct in6_pktinfo)))
 760                                + CMSG_SPACE(int) /* ttl/hoplimit */
 761                                + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */];
 762         } control;
 763         union sockaddr_union sa;
 764         struct msghdr mh = {};
 765         struct cmsghdr *cmsg;
 766         struct iovec iov;
 767         int ms = 0, r;
 768         ssize_t l;
 769
 770         assert(m);
 771         assert(fd >= 0);
 772         assert(ret);
 773
 774         r = ioctl(fd, FIONREAD, &ms);
 775         if (r < 0)
 776                 return -errno;
 777         if (ms < 0)
 778                 return -EIO;
 779
 780         r = dns_packet_new(&p, protocol, ms);
 781         if (r < 0)
 782                 return r;
 783
 784         iov.iov_base = DNS_PACKET_DATA(p);
 785         iov.iov_len = p->allocated;
 786
 787         mh.msg_name = &sa.sa;
 788         mh.msg_namelen = sizeof(sa);
 789         mh.msg_iov = &iov;
 790         mh.msg_iovlen = 1;
 791         mh.msg_control = &control;
 792         mh.msg_controllen = sizeof(control);
 793
 794         l = recvmsg(fd, &mh, 0);
 795         if (l < 0) {
 796                 if (errno == EAGAIN || errno == EINTR)
 797                         return 0;
 798
 799                 return -errno;
 800         }
 801
 802         if (l <= 0)
 803                 return -EIO;
 804
 805         assert(!(mh.msg_flags & MSG_CTRUNC));
 806         assert(!(mh.msg_flags & MSG_TRUNC));
 807
 808         p->size = (size_t) l;
 809
 810         p->family = sa.sa.sa_family;
 811         p->ipproto = IPPROTO_UDP;
 812         if (p->family == AF_INET) {
 813                 p->sender.in = sa.in.sin_addr;
 814                 p->sender_port = be16toh(sa.in.sin_port);
 815         } else if (p->family == AF_INET6) {
 816                 p->sender.in6 = sa.in6.sin6_addr;
 817                 p->sender_port = be16toh(sa.in6.sin6_port);
 818                 p->ifindex = sa.in6.sin6_scope_id;
 819         } else
 820                 return -EAFNOSUPPORT;
 821
 822         for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
 823
 824                 if (cmsg->cmsg_level == IPPROTO_IPV6) {
 825                         assert(p->family == AF_INET6);
 826
 827                         switch (cmsg->cmsg_type) {
 828
 829                         case IPV6_PKTINFO: {
 830                                 struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg);
 831
 832                                 if (p->ifindex <= 0)
 833                                         p->ifindex = i->ipi6_ifindex;
 834
 835                                 p->destination.in6 = i->ipi6_addr;
 836                                 break;
 837                         }
 838
 839                         case IPV6_HOPLIMIT:
 840                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 841                                 break;
 842
 843                         }
 844                 } else if (cmsg->cmsg_level == IPPROTO_IP) {
 845                         assert(p->family == AF_INET);
 846
 847                         switch (cmsg->cmsg_type) {
 848
 849                         case IP_PKTINFO: {
 850                                 struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg);
 851
 852                                 if (p->ifindex <= 0)
 853                                         p->ifindex = i->ipi_ifindex;
 854
 855                                 p->destination.in = i->ipi_addr;
 856                                 break;
 857                         }
 858
 859                         case IP_TTL:
 860                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 861                                 break;
 862                         }
 863                 }
 864         }
 865
 866         /* The Linux kernel sets the interface index to the loopback
 867          * device if the packet came from the local host since it
 868          * avoids the routing table in such a case. Let's unset the
 869          * interface index in such a case. */
 870         if (p->ifindex > 0 && manager_ifindex_is_loopback(m, p->ifindex) != 0)
 871                 p->ifindex = 0;
 872
 873         /* If we don't know the interface index still, we look for the
 874          * first local interface with a matching address. Yuck! */
 875         if (p->ifindex <= 0)
 876                 p->ifindex = manager_find_ifindex(m, p->family, &p->destination);
 877
 878         *ret = p;
 879         p = NULL;
 880
 881         return 1;
 882 }
 883
 884 static int on_dns_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 885         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 886         DnsTransaction *t = NULL;
 887         Manager *m = userdata;
 888         int r;
 889
 890         r = manager_recv(m, fd, DNS_PROTOCOL_DNS, &p);
 891         if (r <= 0)
 892                 return r;
 893
 894         if (dns_packet_validate_reply(p) > 0) {
 895                 t = hashmap_get(m->dns_transactions, UINT_TO_PTR(DNS_PACKET_ID(p)));
 896                 if (!t)
 897                         return 0;
 898
 899                 dns_transaction_process_reply(t, p);
 900
 901         } else
 902                 log_debug("Invalid DNS packet.");
 903
 904         return 0;
 905 }
 906
 907 int manager_dns_ipv4_fd(Manager *m) {
 908         const int one = 1;
 909         int r;
 910
 911         assert(m);
 912
 913         if (m->dns_ipv4_fd >= 0)
 914                 return m->dns_ipv4_fd;
 915
 916         m->dns_ipv4_fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 917         if (m->dns_ipv4_fd < 0)
 918                 return -errno;
 919
 920         r = setsockopt(m->dns_ipv4_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
 921         if (r < 0) {
 922                 r = -errno;
 923                 goto fail;
 924         }
 925
 926         r = sd_event_add_io(m->event, &m->dns_ipv4_event_source, m->dns_ipv4_fd, EPOLLIN, on_dns_packet, m);
 927         if (r < 0)
 928                 goto fail;
 929
 930         return m->dns_ipv4_fd;
 931
 932 fail:
 933         m->dns_ipv4_fd = safe_close(m->dns_ipv4_fd);
 934         return r;
 935 }
 936
 937 int manager_dns_ipv6_fd(Manager *m) {
 938         const int one = 1;
 939         int r;
 940
 941         assert(m);
 942
 943         if (m->dns_ipv6_fd >= 0)
 944                 return m->dns_ipv6_fd;
 945
 946         m->dns_ipv6_fd = socket(AF_INET6, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 947         if (m->dns_ipv6_fd < 0)
 948                 return -errno;
 949
 950         r = setsockopt(m->dns_ipv6_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
 951         if (r < 0) {
 952                 r = -errno;
 953                 goto fail;
 954         }
 955
 956         r = sd_event_add_io(m->event, &m->dns_ipv6_event_source, m->dns_ipv6_fd, EPOLLIN, on_dns_packet, m);
 957         if (r < 0)
 958                 goto fail;
 959
 960         return m->dns_ipv6_fd;
 961
 962 fail:
 963         m->dns_ipv6_fd = safe_close(m->dns_ipv6_fd);
 964         return r;
 965 }
 966
 967 static int sendmsg_loop(int fd, struct msghdr *mh, int flags) {
 968         int r;
 969
 970         assert(fd >= 0);
 971         assert(mh);
 972
 973         for (;;) {
 974                 if (sendmsg(fd, mh, flags) >= 0)
 975                         return 0;
 976
 977                 if (errno == EINTR)
 978                         continue;
 979
 980                 if (errno != EAGAIN)
 981                         return -errno;
 982
 983                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
 984                 if (r < 0)
 985                         return r;
 986                 if (r == 0)
 987                         return -ETIMEDOUT;
 988         }
 989 }
 990
 991 static int manager_ipv4_send(Manager *m, int fd, int ifindex, const struct in_addr *addr, uint16_t port, DnsPacket *p) {
 992         union sockaddr_union sa = {
 993                 .in.sin_family = AF_INET,
 994         };
 995         union {
 996                 struct cmsghdr header; /* For alignment */
 997                 uint8_t buffer[CMSG_SPACE(sizeof(struct in_pktinfo))];
 998         } control;
 999         struct msghdr mh = {};
1000         struct iovec iov;
1001
1002         assert(m);
1003         assert(fd >= 0);
1004         assert(addr);
1005         assert(port > 0);
1006         assert(p);
1007
1008         iov.iov_base = DNS_PACKET_DATA(p);
1009         iov.iov_len = p->size;
1010
1011         sa.in.sin_addr = *addr;
1012         sa.in.sin_port = htobe16(port),
1013
1014         mh.msg_iov = &iov;
1015         mh.msg_iovlen = 1;
1016         mh.msg_name = &sa.sa;
1017         mh.msg_namelen = sizeof(sa.in);
1018
1019         if (ifindex > 0) {
1020                 struct cmsghdr *cmsg;
1021                 struct in_pktinfo *pi;
1022
1023                 zero(control);
1024
1025                 mh.msg_control = &control;
1026                 mh.msg_controllen = CMSG_LEN(sizeof(struct in_pktinfo));
1027
1028                 cmsg = CMSG_FIRSTHDR(&mh);
1029                 cmsg->cmsg_len = mh.msg_controllen;
1030                 cmsg->cmsg_level = IPPROTO_IP;
1031                 cmsg->cmsg_type = IP_PKTINFO;
1032
1033                 pi = (struct in_pktinfo*) CMSG_DATA(cmsg);
1034                 pi->ipi_ifindex = ifindex;
1035         }
1036
1037         return sendmsg_loop(fd, &mh, 0);
1038 }
1039
1040 static int manager_ipv6_send(Manager *m, int fd, int ifindex, const struct in6_addr *addr, uint16_t port, DnsPacket *p) {
1041         union sockaddr_union sa = {
1042                 .in6.sin6_family = AF_INET6,
1043         };
1044         union {
1045                 struct cmsghdr header; /* For alignment */
1046                 uint8_t buffer[CMSG_SPACE(sizeof(struct in6_pktinfo))];
1047         } control;
1048         struct msghdr mh = {};
1049         struct iovec iov;
1050
1051         assert(m);
1052         assert(fd >= 0);
1053         assert(addr);
1054         assert(port > 0);
1055         assert(p);
1056
1057         iov.iov_base = DNS_PACKET_DATA(p);
1058         iov.iov_len = p->size;
1059
1060         sa.in6.sin6_addr = *addr;
1061         sa.in6.sin6_port = htobe16(port),
1062         sa.in6.sin6_scope_id = ifindex;
1063
1064         mh.msg_iov = &iov;
1065         mh.msg_iovlen = 1;
1066         mh.msg_name = &sa.sa;
1067         mh.msg_namelen = sizeof(sa.in6);
1068
1069         if (ifindex > 0) {
1070                 struct cmsghdr *cmsg;
1071                 struct in6_pktinfo *pi;
1072
1073                 zero(control);
1074
1075                 mh.msg_control = &control;
1076                 mh.msg_controllen = CMSG_LEN(sizeof(struct in6_pktinfo));
1077
1078                 cmsg = CMSG_FIRSTHDR(&mh);
1079                 cmsg->cmsg_len = mh.msg_controllen;
1080                 cmsg->cmsg_level = IPPROTO_IPV6;
1081                 cmsg->cmsg_type = IPV6_PKTINFO;
1082
1083                 pi = (struct in6_pktinfo*) CMSG_DATA(cmsg);
1084                 pi->ipi6_ifindex = ifindex;
1085         }
1086
1087         return sendmsg_loop(fd, &mh, 0);
1088 }
1089
1090 int manager_send(Manager *m, int fd, int ifindex, int family, const union in_addr_union *addr, uint16_t port, DnsPacket *p) {
1091         assert(m);
1092         assert(fd >= 0);
1093         assert(addr);
1094         assert(port > 0);
1095         assert(p);
1096
1097         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));
1098
1099         if (family == AF_INET)
1100                 return manager_ipv4_send(m, fd, ifindex, &addr->in, port, p);
1101         else if (family == AF_INET6)
1102                 return manager_ipv6_send(m, fd, ifindex, &addr->in6, port, p);
1103
1104         return -EAFNOSUPPORT;
1105 }
1106
1107 DnsServer* manager_find_dns_server(Manager *m, int family, const union in_addr_union *in_addr) {
1108         DnsServer *s;
1109
1110         assert(m);
1111         assert(in_addr);
1112
1113         LIST_FOREACH(servers, s, m->dns_servers)
1114                 if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0)
1115                         return s;
1116
1117         LIST_FOREACH(servers, s, m->fallback_dns_servers)
1118                 if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0)
1119                         return s;
1120
1121         return NULL;
1122 }
1123
1124 DnsServer *manager_set_dns_server(Manager *m, DnsServer *s) {
1125         assert(m);
1126
1127         if (m->current_dns_server == s)
1128                 return s;
1129
1130         if (s) {
1131                 _cleanup_free_ char *ip = NULL;
1132
1133                 in_addr_to_string(s->family, &s->address, &ip);
1134                 log_info("Switching to system DNS server %s.", strna(ip));
1135         }
1136
1137         m->current_dns_server = s;
1138
1139         if (m->unicast_scope)
1140                 dns_cache_flush(&m->unicast_scope->cache);
1141
1142         return s;
1143 }
1144
1145 DnsServer *manager_get_dns_server(Manager *m) {
1146         Link *l;
1147         assert(m);
1148
1149         /* Try to read updates resolv.conf */
1150         manager_read_resolv_conf(m);
1151
1152         if (!m->current_dns_server)
1153                 manager_set_dns_server(m, m->dns_servers);
1154
1155         if (!m->current_dns_server) {
1156                 bool found = false;
1157                 Iterator i;
1158
1159                 /* No DNS servers configured, let's see if there are
1160                  * any on any links. If not, we use the fallback
1161                  * servers */
1162
1163                 HASHMAP_FOREACH(l, m->links, i)
1164                         if (l->dns_servers) {
1165                                 found = true;
1166                                 break;
1167                         }
1168
1169                 if (!found)
1170                         manager_set_dns_server(m, m->fallback_dns_servers);
1171         }
1172
1173         return m->current_dns_server;
1174 }
1175
1176 void manager_next_dns_server(Manager *m) {
1177         assert(m);
1178
1179         /* If there's currently no DNS server set, then the next
1180          * manager_get_dns_server() will find one */
1181         if (!m->current_dns_server)
1182                 return;
1183
1184         /* Change to the next one */
1185         if (m->current_dns_server->servers_next) {
1186                 manager_set_dns_server(m, m->current_dns_server->servers_next);
1187                 return;
1188         }
1189
1190         /* If there was no next one, then start from the beginning of
1191          * the list */
1192         if (m->current_dns_server->type == DNS_SERVER_FALLBACK)
1193                 manager_set_dns_server(m, m->fallback_dns_servers);
1194         else
1195                 manager_set_dns_server(m, m->dns_servers);
1196 }
1197
1198 uint32_t manager_find_mtu(Manager *m) {
1199         uint32_t mtu = 0;
1200         Link *l;
1201         Iterator i;
1202
1203         /* If we don't know on which link a DNS packet would be
1204          * delivered, let's find the largest MTU that works on all
1205          * interfaces we know of */
1206
1207         HASHMAP_FOREACH(l, m->links, i) {
1208                 if (l->mtu <= 0)
1209                         continue;
1210
1211                 if (mtu <= 0 || l->mtu < mtu)
1212                         mtu = l->mtu;
1213         }
1214
1215         return mtu;
1216 }
1217
1218 static int on_llmnr_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1219         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
1220         DnsTransaction *t = NULL;
1221         Manager *m = userdata;
1222         DnsScope *scope;
1223         int r;
1224
1225         r = manager_recv(m, fd, DNS_PROTOCOL_LLMNR, &p);
1226         if (r <= 0)
1227                 return r;
1228
1229         scope = manager_find_scope(m, p);
1230         if (!scope) {
1231                 log_warning("Got LLMNR UDP packet on unknown scope. Ignoring.");
1232                 return 0;
1233         }
1234
1235         if (dns_packet_validate_reply(p) > 0) {
1236                 log_debug("Got reply packet for id %u", DNS_PACKET_ID(p));
1237
1238                 dns_scope_check_conflicts(scope, p);
1239
1240                 t = hashmap_get(m->dns_transactions, UINT_TO_PTR(DNS_PACKET_ID(p)));
1241                 if (t)
1242                         dns_transaction_process_reply(t, p);
1243
1244         } else if (dns_packet_validate_query(p) > 0)  {
1245                 log_debug("Got query packet for id %u", DNS_PACKET_ID(p));
1246
1247                 dns_scope_process_query(scope, NULL, p);
1248         } else
1249                 log_debug("Invalid LLMNR UDP packet.");
1250
1251         return 0;
1252 }
1253
1254 int manager_llmnr_ipv4_udp_fd(Manager *m) {
1255         union sockaddr_union sa = {
1256                 .in.sin_family = AF_INET,
1257                 .in.sin_port = htobe16(5355),
1258         };
1259         static const int one = 1, pmtu = IP_PMTUDISC_DONT, ttl = 255;
1260         int r;
1261
1262         assert(m);
1263
1264         if (m->llmnr_ipv4_udp_fd >= 0)
1265                 return m->llmnr_ipv4_udp_fd;
1266
1267         m->llmnr_ipv4_udp_fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1268         if (m->llmnr_ipv4_udp_fd < 0)
1269                 return -errno;
1270
1271         /* RFC 4795, section 2.5 recommends setting the TTL of UDP packets to 255. */
1272         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl));
1273         if (r < 0) {
1274                 r = -errno;
1275                 goto fail;
1276         }
1277
1278         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl));
1279         if (r < 0) {
1280                 r = -errno;
1281                 goto fail;
1282         }
1283
1284         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_LOOP, &one, sizeof(one));
1285         if (r < 0) {
1286                 r = -errno;
1287                 goto fail;
1288         }
1289
1290         r = setsockopt(m->llmnr_ipv4_udp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1291         if (r < 0) {
1292                 r = -errno;
1293                 goto fail;
1294         }
1295
1296         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
1297         if (r < 0) {
1298                 r = -errno;
1299                 goto fail;
1300         }
1301
1302         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_RECVTTL, &one, sizeof(one));
1303         if (r < 0) {
1304                 r = -errno;
1305                 goto fail;
1306         }
1307
1308         /* Disable Don't-Fragment bit in the IP header */
1309         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu));
1310         if (r < 0) {
1311                 r = -errno;
1312                 goto fail;
1313         }
1314
1315         r = bind(m->llmnr_ipv4_udp_fd, &sa.sa, sizeof(sa.in));
1316         if (r < 0) {
1317                 r = -errno;
1318                 goto fail;
1319         }
1320
1321         r = sd_event_add_io(m->event, &m->llmnr_ipv4_udp_event_source, m->llmnr_ipv4_udp_fd, EPOLLIN, on_llmnr_packet, m);
1322         if (r < 0)
1323                 goto fail;
1324
1325         return m->llmnr_ipv4_udp_fd;
1326
1327 fail:
1328         m->llmnr_ipv4_udp_fd = safe_close(m->llmnr_ipv4_udp_fd);
1329         return r;
1330 }
1331
1332 int manager_llmnr_ipv6_udp_fd(Manager *m) {
1333         union sockaddr_union sa = {
1334                 .in6.sin6_family = AF_INET6,
1335                 .in6.sin6_port = htobe16(5355),
1336         };
1337         static const int one = 1, ttl = 255;
1338         int r;
1339
1340         assert(m);
1341
1342         if (m->llmnr_ipv6_udp_fd >= 0)
1343                 return m->llmnr_ipv6_udp_fd;
1344
1345         m->llmnr_ipv6_udp_fd = socket(AF_INET6, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1346         if (m->llmnr_ipv6_udp_fd < 0)
1347                 return -errno;
1348
1349         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl));
1350         if (r < 0) {
1351                 r = -errno;
1352                 goto fail;
1353         }
1354
1355         /* RFC 4795, section 2.5 recommends setting the TTL of UDP packets to 255. */
1356         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl));
1357         if (r < 0) {
1358                 r = -errno;
1359                 goto fail;
1360         }
1361
1362         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &one, sizeof(one));
1363         if (r < 0) {
1364                 r = -errno;
1365                 goto fail;
1366         }
1367
1368         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
1369         if (r < 0) {
1370                 r = -errno;
1371                 goto fail;
1372         }
1373
1374         r = setsockopt(m->llmnr_ipv6_udp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1375         if (r < 0) {
1376                 r = -errno;
1377                 goto fail;
1378         }
1379
1380         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
1381         if (r < 0) {
1382                 r = -errno;
1383                 goto fail;
1384         }
1385
1386         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &one, sizeof(one));
1387         if (r < 0) {
1388                 r = -errno;
1389                 goto fail;
1390         }
1391
1392         r = bind(m->llmnr_ipv6_udp_fd, &sa.sa, sizeof(sa.in6));
1393         if (r < 0) {
1394                 r = -errno;
1395                 goto fail;
1396         }
1397
1398         r = sd_event_add_io(m->event, &m->llmnr_ipv6_udp_event_source, m->llmnr_ipv6_udp_fd, EPOLLIN, on_llmnr_packet, m);
1399         if (r < 0)  {
1400                 r = -errno;
1401                 goto fail;
1402         }
1403
1404         return m->llmnr_ipv6_udp_fd;
1405
1406 fail:
1407         m->llmnr_ipv6_udp_fd = safe_close(m->llmnr_ipv6_udp_fd);
1408         return r;
1409 }
1410
1411 static int on_llmnr_stream_packet(DnsStream *s) {
1412         DnsScope *scope;
1413
1414         assert(s);
1415
1416         scope = manager_find_scope(s->manager, s->read_packet);
1417         if (!scope) {
1418                 log_warning("Got LLMNR TCP packet on unknown scope. Ignroing.");
1419                 return 0;
1420         }
1421
1422         if (dns_packet_validate_query(s->read_packet) > 0) {
1423                 log_debug("Got query packet for id %u", DNS_PACKET_ID(s->read_packet));
1424
1425                 dns_scope_process_query(scope, s, s->read_packet);
1426
1427                 /* If no reply packet was set, we free the stream */
1428                 if (s->write_packet)
1429                         return 0;
1430         } else
1431                 log_debug("Invalid LLMNR TCP packet.");
1432
1433         dns_stream_free(s);
1434         return 0;
1435 }
1436
1437 static int on_llmnr_stream(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1438         DnsStream *stream;
1439         Manager *m = userdata;
1440         int cfd, r;
1441
1442         cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
1443         if (cfd < 0) {
1444                 if (errno == EAGAIN || errno == EINTR)
1445                         return 0;
1446
1447                 return -errno;
1448         }
1449
1450         r = dns_stream_new(m, &stream, DNS_PROTOCOL_LLMNR, cfd);
1451         if (r < 0) {
1452                 safe_close(cfd);
1453                 return r;
1454         }
1455
1456         stream->on_packet = on_llmnr_stream_packet;
1457         return 0;
1458 }
1459
1460 int manager_llmnr_ipv4_tcp_fd(Manager *m) {
1461         union sockaddr_union sa = {
1462                 .in.sin_family = AF_INET,
1463                 .in.sin_port = htobe16(5355),
1464         };
1465         static const int one = 1, pmtu = IP_PMTUDISC_DONT;
1466         int r;
1467
1468         assert(m);
1469
1470         if (m->llmnr_ipv4_tcp_fd >= 0)
1471                 return m->llmnr_ipv4_tcp_fd;
1472
1473         m->llmnr_ipv4_tcp_fd = socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1474         if (m->llmnr_ipv4_tcp_fd < 0)
1475                 return -errno;
1476
1477         /* RFC 4795, section 2.5. requires setting the TTL of TCP streams to 1 */
1478         r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_TTL, &one, sizeof(one));
1479         if (r < 0) {
1480                 r = -errno;
1481                 goto fail;
1482         }
1483
1484         r = setsockopt(m->llmnr_ipv4_tcp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1485         if (r < 0) {
1486                 r = -errno;
1487                 goto fail;
1488         }
1489
1490         r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
1491         if (r < 0) {
1492                 r = -errno;
1493                 goto fail;
1494         }
1495
1496         r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_RECVTTL, &one, sizeof(one));
1497         if (r < 0) {
1498                 r = -errno;
1499                 goto fail;
1500         }
1501
1502         /* Disable Don't-Fragment bit in the IP header */
1503         r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu));
1504         if (r < 0) {
1505                 r = -errno;
1506                 goto fail;
1507         }
1508
1509         r = bind(m->llmnr_ipv4_tcp_fd, &sa.sa, sizeof(sa.in));
1510         if (r < 0) {
1511                 r = -errno;
1512                 goto fail;
1513         }
1514
1515         r = listen(m->llmnr_ipv4_tcp_fd, SOMAXCONN);
1516         if (r < 0) {
1517                 r = -errno;
1518                 goto fail;
1519         }
1520
1521         r = sd_event_add_io(m->event, &m->llmnr_ipv4_tcp_event_source, m->llmnr_ipv4_tcp_fd, EPOLLIN, on_llmnr_stream, m);
1522         if (r < 0)
1523                 goto fail;
1524
1525         return m->llmnr_ipv4_tcp_fd;
1526
1527 fail:
1528         m->llmnr_ipv4_tcp_fd = safe_close(m->llmnr_ipv4_tcp_fd);
1529         return r;
1530 }
1531
1532 int manager_llmnr_ipv6_tcp_fd(Manager *m) {
1533         union sockaddr_union sa = {
1534                 .in6.sin6_family = AF_INET6,
1535                 .in6.sin6_port = htobe16(5355),
1536         };
1537         static const int one = 1;
1538         int r;
1539
1540         assert(m);
1541
1542         if (m->llmnr_ipv6_tcp_fd >= 0)
1543                 return m->llmnr_ipv6_tcp_fd;
1544
1545         m->llmnr_ipv6_tcp_fd = socket(AF_INET6, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1546         if (m->llmnr_ipv6_tcp_fd < 0)
1547                 return -errno;
1548
1549         /* RFC 4795, section 2.5. requires setting the TTL of TCP streams to 1 */
1550         r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &one, sizeof(one));
1551         if (r < 0) {
1552                 r = -errno;
1553                 goto fail;
1554         }
1555
1556         r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
1557         if (r < 0) {
1558                 r = -errno;
1559                 goto fail;
1560         }
1561
1562         r = setsockopt(m->llmnr_ipv6_tcp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1563         if (r < 0) {
1564                 r = -errno;
1565                 goto fail;
1566         }
1567
1568         r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
1569         if (r < 0) {
1570                 r = -errno;
1571                 goto fail;
1572         }
1573
1574         r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &one, sizeof(one));
1575         if (r < 0) {
1576                 r = -errno;
1577                 goto fail;
1578         }
1579
1580         r = bind(m->llmnr_ipv6_tcp_fd, &sa.sa, sizeof(sa.in6));
1581         if (r < 0) {
1582                 r = -errno;
1583                 goto fail;
1584         }
1585
1586         r = listen(m->llmnr_ipv6_tcp_fd, SOMAXCONN);
1587         if (r < 0) {
1588                 r = -errno;
1589                 goto fail;
1590         }
1591
1592         r = sd_event_add_io(m->event, &m->llmnr_ipv6_tcp_event_source, m->llmnr_ipv6_tcp_fd, EPOLLIN, on_llmnr_stream, m);
1593         if (r < 0)  {
1594                 r = -errno;
1595                 goto fail;
1596         }
1597
1598         return m->llmnr_ipv6_tcp_fd;
1599
1600 fail:
1601         m->llmnr_ipv6_tcp_fd = safe_close(m->llmnr_ipv6_tcp_fd);
1602         return r;
1603 }
1604
1605 int manager_ifindex_is_loopback(Manager *m, int ifindex) {
1606         Link *l;
1607         assert(m);
1608
1609         if (ifindex <= 0)
1610                 return -EINVAL;
1611
1612         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
1613         if (l->flags & IFF_LOOPBACK)
1614                 return 1;
1615
1616         return 0;
1617 }
1618
1619 int manager_find_ifindex(Manager *m, int family, const union in_addr_union *in_addr) {
1620         LinkAddress *a;
1621
1622         assert(m);
1623
1624         a = manager_find_link_address(m, family, in_addr);
1625         if (a)
1626                 return a->link->ifindex;
1627
1628         return 0;
1629 }
1630
1631 void manager_refresh_rrs(Manager *m) {
1632         Iterator i;
1633         Link *l;
1634
1635         assert(m);
1636
1637         m->host_ipv4_key = dns_resource_key_unref(m->host_ipv4_key);
1638         m->host_ipv6_key = dns_resource_key_unref(m->host_ipv6_key);
1639
1640         HASHMAP_FOREACH(l, m->links, i) {
1641                 link_add_rrs(l, true);
1642                 link_add_rrs(l, false);
1643         }
1644 }
1645
1646 int manager_next_hostname(Manager *m) {
1647         const char *p;
1648         uint64_t u;
1649         char *h;
1650
1651         assert(m);
1652
1653         p = strchr(m->hostname, 0);
1654         assert(p);
1655
1656         while (p > m->hostname) {
1657                 if (!strchr("0123456789", p[-1]))
1658                         break;
1659
1660                 p--;
1661         }
1662
1663         if (*p == 0 || safe_atou64(p, &u) < 0 || u <= 0)
1664                 u = 1;
1665
1666         u++;
1667
1668         if (asprintf(&h, "%.*s%" PRIu64, (int) (p - m->hostname), m->hostname, u) < 0)
1669                 return -ENOMEM;
1670
1671         log_info("Hostname conflict, changing published hostname from '%s' to '%s'.", m->hostname, h);
1672
1673         free(m->hostname);
1674         m->hostname = h;
1675
1676         manager_refresh_rrs(m);
1677
1678         return 0;
1679 }
1680
1681 LinkAddress* manager_find_link_address(Manager *m, int family, const union in_addr_union *in_addr) {
1682         Iterator i;
1683         Link *l;
1684
1685         assert(m);
1686
1687         HASHMAP_FOREACH(l, m->links, i) {
1688                 LinkAddress *a;
1689
1690                 a = link_find_address(l, family, in_addr);
1691                 if (a)
1692                         return a;
1693         }
1694
1695         return NULL;
1696 }
1697
1698 bool manager_our_packet(Manager *m, DnsPacket *p) {
1699         assert(m);
1700         assert(p);
1701
1702         return !!manager_find_link_address(m, p->family, &p->sender);
1703 }
1704
1705 DnsScope* manager_find_scope(Manager *m, DnsPacket *p) {
1706         Link *l;
1707
1708         assert(m);
1709         assert(p);
1710
1711         l = hashmap_get(m->links, INT_TO_PTR(p->ifindex));
1712         if (!l)
1713                 return NULL;
1714
1715         if (p->protocol == DNS_PROTOCOL_LLMNR) {
1716                 if (p->family == AF_INET)
1717                         return l->llmnr_ipv4_scope;
1718                 else if (p->family == AF_INET6)
1719                         return l->llmnr_ipv6_scope;
1720         }
1721
1722         return NULL;
1723 }
1724
1725 static const char* const support_table[_SUPPORT_MAX] = {
1726         [SUPPORT_NO] = "no",
1727         [SUPPORT_YES] = "yes",
1728         [SUPPORT_RESOLVE] = "resolve",
1729 };
1730 DEFINE_STRING_TABLE_LOOKUP(support, Support);