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