src/resolve/resolved-manager.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2014 Tom Gundersen <teg@jklm.no>
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20  ***/
  21
  22 #include <netinet/in.h>
  23 #include <poll.h>
  24 #include <sys/ioctl.h>
  25
  26 #include "af-list.h"
  27 #include "alloc-util.h"
  28 #include "dns-domain.h"
  29 #include "fd-util.h"
  30 #include "fileio-label.h"
  31 #include "hostname-util.h"
  32 #include "io-util.h"
  33 #include "netlink-util.h"
  34 #include "network-internal.h"
  35 #include "ordered-set.h"
  36 #include "parse-util.h"
  37 #include "random-util.h"
  38 #include "resolved-bus.h"
  39 #include "resolved-conf.h"
  40 #include "resolved-llmnr.h"
  41 #include "resolved-manager.h"
  42 #include "resolved-resolv-conf.h"
  43 #include "socket-util.h"
  44 #include "string-table.h"
  45 #include "string-util.h"
  46 #include "utf8.h"
  47
  48 #define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC)
  49
  50 static int manager_process_link(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
  51         Manager *m = userdata;
  52         uint16_t type;
  53         Link *l;
  54         int ifindex, r;
  55
  56         assert(rtnl);
  57         assert(m);
  58         assert(mm);
  59
  60         r = sd_netlink_message_get_type(mm, &type);
  61         if (r < 0)
  62                 goto fail;
  63
  64         r = sd_rtnl_message_link_get_ifindex(mm, &ifindex);
  65         if (r < 0)
  66                 goto fail;
  67
  68         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
  69
  70         switch (type) {
  71
  72         case RTM_NEWLINK:{
  73                 bool is_new = !l;
  74
  75                 if (!l) {
  76                         r = link_new(m, &l, ifindex);
  77                         if (r < 0)
  78                                 goto fail;
  79                 }
  80
  81                 r = link_update_rtnl(l, mm);
  82                 if (r < 0)
  83                         goto fail;
  84
  85                 r = link_update_monitor(l);
  86                 if (r < 0)
  87                         goto fail;
  88
  89                 if (is_new)
  90                         log_debug("Found new link %i/%s", ifindex, l->name);
  91
  92                 break;
  93         }
  94
  95         case RTM_DELLINK:
  96                 if (l) {
  97                         log_debug("Removing link %i/%s", l->ifindex, l->name);
  98                         link_free(l);
  99                 }
 100
 101                 break;
 102         }
 103
 104         return 0;
 105
 106 fail:
 107         log_warning_errno(r, "Failed to process RTNL link message: %m");
 108         return 0;
 109 }
 110
 111 static int manager_process_address(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
 112         Manager *m = userdata;
 113         union in_addr_union address;
 114         uint16_t type;
 115         int r, ifindex, family;
 116         LinkAddress *a;
 117         Link *l;
 118
 119         assert(rtnl);
 120         assert(mm);
 121         assert(m);
 122
 123         r = sd_netlink_message_get_type(mm, &type);
 124         if (r < 0)
 125                 goto fail;
 126
 127         r = sd_rtnl_message_addr_get_ifindex(mm, &ifindex);
 128         if (r < 0)
 129                 goto fail;
 130
 131         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
 132         if (!l)
 133                 return 0;
 134
 135         r = sd_rtnl_message_addr_get_family(mm, &family);
 136         if (r < 0)
 137                 goto fail;
 138
 139         switch (family) {
 140
 141         case AF_INET:
 142                 r = sd_netlink_message_read_in_addr(mm, IFA_LOCAL, &address.in);
 143                 if (r < 0) {
 144                         r = sd_netlink_message_read_in_addr(mm, IFA_ADDRESS, &address.in);
 145                         if (r < 0)
 146                                 goto fail;
 147                 }
 148
 149                 break;
 150
 151         case AF_INET6:
 152                 r = sd_netlink_message_read_in6_addr(mm, IFA_LOCAL, &address.in6);
 153                 if (r < 0) {
 154                         r = sd_netlink_message_read_in6_addr(mm, IFA_ADDRESS, &address.in6);
 155                         if (r < 0)
 156                                 goto fail;
 157                 }
 158
 159                 break;
 160
 161         default:
 162                 return 0;
 163         }
 164
 165         a = link_find_address(l, family, &address);
 166
 167         switch (type) {
 168
 169         case RTM_NEWADDR:
 170
 171                 if (!a) {
 172                         r = link_address_new(l, &a, family, &address);
 173                         if (r < 0)
 174                                 return r;
 175                 }
 176
 177                 r = link_address_update_rtnl(a, mm);
 178                 if (r < 0)
 179                         return r;
 180
 181                 break;
 182
 183         case RTM_DELADDR:
 184                 link_address_free(a);
 185                 break;
 186         }
 187
 188         return 0;
 189
 190 fail:
 191         log_warning_errno(r, "Failed to process RTNL address message: %m");
 192         return 0;
 193 }
 194
 195 static int manager_rtnl_listen(Manager *m) {
 196         _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
 197         sd_netlink_message *i;
 198         int r;
 199
 200         assert(m);
 201
 202         /* First, subscribe to interfaces coming and going */
 203         r = sd_netlink_open(&m->rtnl);
 204         if (r < 0)
 205                 return r;
 206
 207         r = sd_netlink_attach_event(m->rtnl, m->event, 0);
 208         if (r < 0)
 209                 return r;
 210
 211         r = sd_netlink_add_match(m->rtnl, RTM_NEWLINK, manager_process_link, m);
 212         if (r < 0)
 213                 return r;
 214
 215         r = sd_netlink_add_match(m->rtnl, RTM_DELLINK, manager_process_link, m);
 216         if (r < 0)
 217                 return r;
 218
 219         r = sd_netlink_add_match(m->rtnl, RTM_NEWADDR, manager_process_address, m);
 220         if (r < 0)
 221                 return r;
 222
 223         r = sd_netlink_add_match(m->rtnl, RTM_DELADDR, manager_process_address, m);
 224         if (r < 0)
 225                 return r;
 226
 227         /* Then, enumerate all links */
 228         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
 229         if (r < 0)
 230                 return r;
 231
 232         r = sd_netlink_message_request_dump(req, true);
 233         if (r < 0)
 234                 return r;
 235
 236         r = sd_netlink_call(m->rtnl, req, 0, &reply);
 237         if (r < 0)
 238                 return r;
 239
 240         for (i = reply; i; i = sd_netlink_message_next(i)) {
 241                 r = manager_process_link(m->rtnl, i, m);
 242                 if (r < 0)
 243                         return r;
 244         }
 245
 246         req = sd_netlink_message_unref(req);
 247         reply = sd_netlink_message_unref(reply);
 248
 249         /* Finally, enumerate all addresses, too */
 250         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, AF_UNSPEC);
 251         if (r < 0)
 252                 return r;
 253
 254         r = sd_netlink_message_request_dump(req, true);
 255         if (r < 0)
 256                 return r;
 257
 258         r = sd_netlink_call(m->rtnl, req, 0, &reply);
 259         if (r < 0)
 260                 return r;
 261
 262         for (i = reply; i; i = sd_netlink_message_next(i)) {
 263                 r = manager_process_address(m->rtnl, i, m);
 264                 if (r < 0)
 265                         return r;
 266         }
 267
 268         return r;
 269 }
 270
 271 static int on_network_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 272         Manager *m = userdata;
 273         Iterator i;
 274         Link *l;
 275         int r;
 276
 277         assert(m);
 278
 279         sd_network_monitor_flush(m->network_monitor);
 280
 281         HASHMAP_FOREACH(l, m->links, i) {
 282                 r = link_update_monitor(l);
 283                 if (r < 0)
 284                         log_warning_errno(r, "Failed to update monitor information for %i: %m", l->ifindex);
 285         }
 286
 287         r = manager_write_resolv_conf(m);
 288         if (r < 0)
 289                 log_warning_errno(r, "Could not update resolv.conf: %m");
 290
 291         return 0;
 292 }
 293
 294 static int manager_network_monitor_listen(Manager *m) {
 295         int r, fd, events;
 296
 297         assert(m);
 298
 299         r = sd_network_monitor_new(&m->network_monitor, NULL);
 300         if (r < 0)
 301                 return r;
 302
 303         fd = sd_network_monitor_get_fd(m->network_monitor);
 304         if (fd < 0)
 305                 return fd;
 306
 307         events = sd_network_monitor_get_events(m->network_monitor);
 308         if (events < 0)
 309                 return events;
 310
 311         r = sd_event_add_io(m->event, &m->network_event_source, fd, events, &on_network_event, m);
 312         if (r < 0)
 313                 return r;
 314
 315         return 0;
 316 }
 317
 318 static int determine_hostname(char **llmnr_hostname, char **mdns_hostname) {
 319         _cleanup_free_ char *h = NULL, *n = NULL;
 320         char label[DNS_LABEL_MAX];
 321         const char *p;
 322         int r, k;
 323
 324         assert(llmnr_hostname);
 325         assert(mdns_hostname);
 326
 327         /* Extract and normalize the first label of the locally
 328          * configured hostname, and check it's not "localhost". */
 329
 330         h = gethostname_malloc();
 331         if (!h)
 332                 return log_oom();
 333
 334         p = h;
 335         r = dns_label_unescape(&p, label, sizeof(label));
 336         if (r < 0)
 337                 return log_error_errno(r, "Failed to unescape host name: %m");
 338         if (r == 0) {
 339                 log_error("Couldn't find a single label in hosntame.");
 340                 return -EINVAL;
 341         }
 342
 343         k = dns_label_undo_idna(label, r, label, sizeof(label));
 344         if (k < 0)
 345                 return log_error_errno(k, "Failed to undo IDNA: %m");
 346         if (k > 0)
 347                 r = k;
 348
 349         if (!utf8_is_valid(label)) {
 350                 log_error("System hostname is not UTF-8 clean.");
 351                 return -EINVAL;
 352         }
 353
 354         r = dns_label_escape(label, r, &n);
 355         if (r < 0)
 356                 return log_error_errno(r, "Failed to escape host name: %m");
 357
 358         if (is_localhost(n)) {
 359                 log_debug("System hostname is 'localhost', ignoring.");
 360                 return -EINVAL;
 361         }
 362
 363         r = dns_name_concat(n, "local", mdns_hostname);
 364         if (r < 0)
 365                 return log_error_errno(r, "Failed to determine mDNS hostname: %m");
 366
 367         *llmnr_hostname = n;
 368         n = NULL;
 369
 370         return 0;
 371 }
 372
 373 static int on_hostname_change(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
 374         _cleanup_free_ char *llmnr_hostname = NULL, *mdns_hostname = NULL;
 375         Manager *m = userdata;
 376         int r;
 377
 378         assert(m);
 379
 380         r = determine_hostname(&llmnr_hostname, &mdns_hostname);
 381         if (r < 0)
 382                 return 0; /* ignore invalid hostnames */
 383
 384         if (streq(llmnr_hostname, m->llmnr_hostname) && streq(mdns_hostname, m->mdns_hostname))
 385                 return 0;
 386
 387         log_info("System hostname changed to '%s'.", llmnr_hostname);
 388
 389         free(m->llmnr_hostname);
 390         free(m->mdns_hostname);
 391
 392         m->llmnr_hostname = llmnr_hostname;
 393         m->mdns_hostname = mdns_hostname;
 394
 395         llmnr_hostname = mdns_hostname = NULL;
 396
 397         manager_refresh_rrs(m);
 398
 399         return 0;
 400 }
 401
 402 static int manager_watch_hostname(Manager *m) {
 403         int r;
 404
 405         assert(m);
 406
 407         m->hostname_fd = open("/proc/sys/kernel/hostname", O_RDONLY|O_CLOEXEC|O_NDELAY|O_NOCTTY);
 408         if (m->hostname_fd < 0) {
 409                 log_warning_errno(errno, "Failed to watch hostname: %m");
 410                 return 0;
 411         }
 412
 413         r = sd_event_add_io(m->event, &m->hostname_event_source, m->hostname_fd, 0, on_hostname_change, m);
 414         if (r < 0) {
 415                 if (r == -EPERM)
 416                         /* kernels prior to 3.2 don't support polling this file. Ignore the failure. */
 417                         m->hostname_fd = safe_close(m->hostname_fd);
 418                 else
 419                         return log_error_errno(r, "Failed to add hostname event source: %m");
 420         }
 421
 422         r = determine_hostname(&m->llmnr_hostname, &m->mdns_hostname);
 423         if (r < 0) {
 424                 log_info("Defaulting to hostname 'linux'.");
 425                 m->llmnr_hostname = strdup("linux");
 426                 if (!m->llmnr_hostname)
 427                         return log_oom();
 428
 429                 m->mdns_hostname = strdup("linux.local");
 430                 if (!m->mdns_hostname)
 431                         return log_oom();
 432         } else
 433                 log_info("Using system hostname '%s'.", m->llmnr_hostname);
 434
 435         return 0;
 436 }
 437
 438 static int manager_sigusr1(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
 439         _cleanup_free_ char *buffer = NULL;
 440         _cleanup_fclose_ FILE *f = NULL;
 441         Manager *m = userdata;
 442         size_t size = 0;
 443         DnsScope *scope;
 444
 445         assert(s);
 446         assert(si);
 447         assert(m);
 448
 449         f = open_memstream(&buffer, &size);
 450         if (!f)
 451                 return log_oom();
 452
 453         LIST_FOREACH(scopes, scope, m->dns_scopes)
 454                 dns_scope_dump(scope, f);
 455
 456         if (fflush_and_check(f) < 0)
 457                 return log_oom();
 458
 459         log_dump(LOG_INFO, buffer);
 460         return 0;
 461 }
 462
 463 int manager_new(Manager **ret) {
 464         _cleanup_(manager_freep) Manager *m = NULL;
 465         int r;
 466
 467         assert(ret);
 468
 469         m = new0(Manager, 1);
 470         if (!m)
 471                 return -ENOMEM;
 472
 473         m->llmnr_ipv4_udp_fd = m->llmnr_ipv6_udp_fd = -1;
 474         m->llmnr_ipv4_tcp_fd = m->llmnr_ipv6_tcp_fd = -1;
 475         m->hostname_fd = -1;
 476
 477         m->llmnr_support = SUPPORT_YES;
 478         m->read_resolv_conf = true;
 479
 480         r = manager_parse_dns_server_string_and_warn(m, DNS_SERVER_FALLBACK, DNS_SERVERS);
 481         if (r < 0)
 482                 return r;
 483
 484         r = sd_event_default(&m->event);
 485         if (r < 0)
 486                 return r;
 487
 488         sd_event_add_signal(m->event, NULL, SIGTERM, NULL,  NULL);
 489         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
 490
 491         sd_event_set_watchdog(m->event, true);
 492
 493         r = manager_watch_hostname(m);
 494         if (r < 0)
 495                 return r;
 496
 497         r = dns_scope_new(m, &m->unicast_scope, NULL, DNS_PROTOCOL_DNS, AF_UNSPEC);
 498         if (r < 0)
 499                 return r;
 500
 501         r = manager_network_monitor_listen(m);
 502         if (r < 0)
 503                 return r;
 504
 505         r = manager_rtnl_listen(m);
 506         if (r < 0)
 507                 return r;
 508
 509         r = manager_connect_bus(m);
 510         if (r < 0)
 511                 return r;
 512
 513         (void) sd_event_add_signal(m->event, &m->sigusr1_event_source, SIGUSR1, manager_sigusr1, m);
 514
 515         *ret = m;
 516         m = NULL;
 517
 518         return 0;
 519 }
 520
 521 int manager_start(Manager *m) {
 522         int r;
 523
 524         assert(m);
 525
 526         r = manager_llmnr_start(m);
 527         if (r < 0)
 528                 return r;
 529
 530         return 0;
 531 }
 532
 533 Manager *manager_free(Manager *m) {
 534         Link *l;
 535
 536         if (!m)
 537                 return NULL;
 538
 539         while ((l = hashmap_first(m->links)))
 540                link_free(l);
 541
 542         while (m->dns_queries)
 543                 dns_query_free(m->dns_queries);
 544
 545         manager_flush_dns_servers(m, DNS_SERVER_SYSTEM);
 546         manager_flush_dns_servers(m, DNS_SERVER_FALLBACK);
 547
 548         dns_scope_free(m->unicast_scope);
 549
 550         hashmap_free(m->links);
 551         hashmap_free(m->dns_transactions);
 552
 553         sd_event_source_unref(m->network_event_source);
 554         sd_network_monitor_unref(m->network_monitor);
 555
 556         sd_netlink_unref(m->rtnl);
 557         sd_event_source_unref(m->rtnl_event_source);
 558
 559         manager_llmnr_stop(m);
 560
 561         sd_bus_slot_unref(m->prepare_for_sleep_slot);
 562         sd_event_source_unref(m->bus_retry_event_source);
 563         sd_bus_unref(m->bus);
 564
 565         sd_event_source_unref(m->sigusr1_event_source);
 566
 567         sd_event_unref(m->event);
 568
 569         dns_resource_key_unref(m->llmnr_host_ipv4_key);
 570         dns_resource_key_unref(m->llmnr_host_ipv6_key);
 571
 572         sd_event_source_unref(m->hostname_event_source);
 573         safe_close(m->hostname_fd);
 574         free(m->llmnr_hostname);
 575         free(m->mdns_hostname);
 576
 577         free(m);
 578
 579         return NULL;
 580 }
 581
 582 int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) {
 583         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 584         union {
 585                 struct cmsghdr header; /* For alignment */
 586                 uint8_t buffer[CMSG_SPACE(MAXSIZE(struct in_pktinfo, struct in6_pktinfo))
 587                                + CMSG_SPACE(int) /* ttl/hoplimit */
 588                                + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */];
 589         } control;
 590         union sockaddr_union sa;
 591         struct msghdr mh = {};
 592         struct cmsghdr *cmsg;
 593         struct iovec iov;
 594         int ms = 0, r;
 595         ssize_t l;
 596
 597         assert(m);
 598         assert(fd >= 0);
 599         assert(ret);
 600
 601         r = ioctl(fd, FIONREAD, &ms);
 602         if (r < 0)
 603                 return -errno;
 604         if (ms < 0)
 605                 return -EIO;
 606
 607         r = dns_packet_new(&p, protocol, ms);
 608         if (r < 0)
 609                 return r;
 610
 611         iov.iov_base = DNS_PACKET_DATA(p);
 612         iov.iov_len = p->allocated;
 613
 614         mh.msg_name = &sa.sa;
 615         mh.msg_namelen = sizeof(sa);
 616         mh.msg_iov = &iov;
 617         mh.msg_iovlen = 1;
 618         mh.msg_control = &control;
 619         mh.msg_controllen = sizeof(control);
 620
 621         l = recvmsg(fd, &mh, 0);
 622         if (l < 0) {
 623                 if (errno == EAGAIN || errno == EINTR)
 624                         return 0;
 625
 626                 return -errno;
 627         }
 628
 629         if (l <= 0)
 630                 return -EIO;
 631
 632         assert(!(mh.msg_flags & MSG_CTRUNC));
 633         assert(!(mh.msg_flags & MSG_TRUNC));
 634
 635         p->size = (size_t) l;
 636
 637         p->family = sa.sa.sa_family;
 638         p->ipproto = IPPROTO_UDP;
 639         if (p->family == AF_INET) {
 640                 p->sender.in = sa.in.sin_addr;
 641                 p->sender_port = be16toh(sa.in.sin_port);
 642         } else if (p->family == AF_INET6) {
 643                 p->sender.in6 = sa.in6.sin6_addr;
 644                 p->sender_port = be16toh(sa.in6.sin6_port);
 645                 p->ifindex = sa.in6.sin6_scope_id;
 646         } else
 647                 return -EAFNOSUPPORT;
 648
 649         CMSG_FOREACH(cmsg, &mh) {
 650
 651                 if (cmsg->cmsg_level == IPPROTO_IPV6) {
 652                         assert(p->family == AF_INET6);
 653
 654                         switch (cmsg->cmsg_type) {
 655
 656                         case IPV6_PKTINFO: {
 657                                 struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg);
 658
 659                                 if (p->ifindex <= 0)
 660                                         p->ifindex = i->ipi6_ifindex;
 661
 662                                 p->destination.in6 = i->ipi6_addr;
 663                                 break;
 664                         }
 665
 666                         case IPV6_HOPLIMIT:
 667                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 668                                 break;
 669
 670                         }
 671                 } else if (cmsg->cmsg_level == IPPROTO_IP) {
 672                         assert(p->family == AF_INET);
 673
 674                         switch (cmsg->cmsg_type) {
 675
 676                         case IP_PKTINFO: {
 677                                 struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg);
 678
 679                                 if (p->ifindex <= 0)
 680                                         p->ifindex = i->ipi_ifindex;
 681
 682                                 p->destination.in = i->ipi_addr;
 683                                 break;
 684                         }
 685
 686                         case IP_TTL:
 687                                 p->ttl = *(int *) CMSG_DATA(cmsg);
 688                                 break;
 689                         }
 690                 }
 691         }
 692
 693         /* The Linux kernel sets the interface index to the loopback
 694          * device if the packet came from the local host since it
 695          * avoids the routing table in such a case. Let's unset the
 696          * interface index in such a case. */
 697         if (p->ifindex == LOOPBACK_IFINDEX)
 698                 p->ifindex = 0;
 699
 700         if (protocol != DNS_PROTOCOL_DNS) {
 701                 /* If we don't know the interface index still, we look for the
 702                  * first local interface with a matching address. Yuck! */
 703                 if (p->ifindex <= 0)
 704                         p->ifindex = manager_find_ifindex(m, p->family, &p->destination);
 705         }
 706
 707         *ret = p;
 708         p = NULL;
 709
 710         return 1;
 711 }
 712
 713 static int sendmsg_loop(int fd, struct msghdr *mh, int flags) {
 714         int r;
 715
 716         assert(fd >= 0);
 717         assert(mh);
 718
 719         for (;;) {
 720                 if (sendmsg(fd, mh, flags) >= 0)
 721                         return 0;
 722
 723                 if (errno == EINTR)
 724                         continue;
 725
 726                 if (errno != EAGAIN)
 727                         return -errno;
 728
 729                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
 730                 if (r < 0)
 731                         return r;
 732                 if (r == 0)
 733                         return -ETIMEDOUT;
 734         }
 735 }
 736
 737 static int write_loop(int fd, void *message, size_t length) {
 738         int r;
 739
 740         assert(fd >= 0);
 741         assert(message);
 742
 743         for (;;) {
 744                 if (write(fd, message, length) >= 0)
 745                         return 0;
 746
 747                 if (errno == EINTR)
 748                         continue;
 749
 750                 if (errno != EAGAIN)
 751                         return -errno;
 752
 753                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
 754                 if (r < 0)
 755                         return r;
 756                 if (r == 0)
 757                         return -ETIMEDOUT;
 758         }
 759 }
 760
 761 int manager_write(Manager *m, int fd, DnsPacket *p) {
 762         int r;
 763
 764         log_debug("Sending %s packet with id %u", DNS_PACKET_QR(p) ? "response" : "query", DNS_PACKET_ID(p));
 765
 766         r = write_loop(fd, DNS_PACKET_DATA(p), p->size);
 767         if (r < 0)
 768                 return r;
 769
 770         return 0;
 771 }
 772
 773 static int manager_ipv4_send(Manager *m, int fd, int ifindex, const struct in_addr *addr, uint16_t port, DnsPacket *p) {
 774         union sockaddr_union sa = {
 775                 .in.sin_family = AF_INET,
 776         };
 777         union {
 778                 struct cmsghdr header; /* For alignment */
 779                 uint8_t buffer[CMSG_SPACE(sizeof(struct in_pktinfo))];
 780         } control;
 781         struct msghdr mh = {};
 782         struct iovec iov;
 783
 784         assert(m);
 785         assert(fd >= 0);
 786         assert(addr);
 787         assert(port > 0);
 788         assert(p);
 789
 790         iov.iov_base = DNS_PACKET_DATA(p);
 791         iov.iov_len = p->size;
 792
 793         sa.in.sin_addr = *addr;
 794         sa.in.sin_port = htobe16(port),
 795
 796         mh.msg_iov = &iov;
 797         mh.msg_iovlen = 1;
 798         mh.msg_name = &sa.sa;
 799         mh.msg_namelen = sizeof(sa.in);
 800
 801         if (ifindex > 0) {
 802                 struct cmsghdr *cmsg;
 803                 struct in_pktinfo *pi;
 804
 805                 zero(control);
 806
 807                 mh.msg_control = &control;
 808                 mh.msg_controllen = CMSG_LEN(sizeof(struct in_pktinfo));
 809
 810                 cmsg = CMSG_FIRSTHDR(&mh);
 811                 cmsg->cmsg_len = mh.msg_controllen;
 812                 cmsg->cmsg_level = IPPROTO_IP;
 813                 cmsg->cmsg_type = IP_PKTINFO;
 814
 815                 pi = (struct in_pktinfo*) CMSG_DATA(cmsg);
 816                 pi->ipi_ifindex = ifindex;
 817         }
 818
 819         return sendmsg_loop(fd, &mh, 0);
 820 }
 821
 822 static int manager_ipv6_send(Manager *m, int fd, int ifindex, const struct in6_addr *addr, uint16_t port, DnsPacket *p) {
 823         union sockaddr_union sa = {
 824                 .in6.sin6_family = AF_INET6,
 825         };
 826         union {
 827                 struct cmsghdr header; /* For alignment */
 828                 uint8_t buffer[CMSG_SPACE(sizeof(struct in6_pktinfo))];
 829         } control;
 830         struct msghdr mh = {};
 831         struct iovec iov;
 832
 833         assert(m);
 834         assert(fd >= 0);
 835         assert(addr);
 836         assert(port > 0);
 837         assert(p);
 838
 839         iov.iov_base = DNS_PACKET_DATA(p);
 840         iov.iov_len = p->size;
 841
 842         sa.in6.sin6_addr = *addr;
 843         sa.in6.sin6_port = htobe16(port),
 844         sa.in6.sin6_scope_id = ifindex;
 845
 846         mh.msg_iov = &iov;
 847         mh.msg_iovlen = 1;
 848         mh.msg_name = &sa.sa;
 849         mh.msg_namelen = sizeof(sa.in6);
 850
 851         if (ifindex > 0) {
 852                 struct cmsghdr *cmsg;
 853                 struct in6_pktinfo *pi;
 854
 855                 zero(control);
 856
 857                 mh.msg_control = &control;
 858                 mh.msg_controllen = CMSG_LEN(sizeof(struct in6_pktinfo));
 859
 860                 cmsg = CMSG_FIRSTHDR(&mh);
 861                 cmsg->cmsg_len = mh.msg_controllen;
 862                 cmsg->cmsg_level = IPPROTO_IPV6;
 863                 cmsg->cmsg_type = IPV6_PKTINFO;
 864
 865                 pi = (struct in6_pktinfo*) CMSG_DATA(cmsg);
 866                 pi->ipi6_ifindex = ifindex;
 867         }
 868
 869         return sendmsg_loop(fd, &mh, 0);
 870 }
 871
 872 int manager_send(Manager *m, int fd, int ifindex, int family, const union in_addr_union *addr, uint16_t port, DnsPacket *p) {
 873         assert(m);
 874         assert(fd >= 0);
 875         assert(addr);
 876         assert(port > 0);
 877         assert(p);
 878
 879         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));
 880
 881         if (family == AF_INET)
 882                 return manager_ipv4_send(m, fd, ifindex, &addr->in, port, p);
 883         else if (family == AF_INET6)
 884                 return manager_ipv6_send(m, fd, ifindex, &addr->in6, port, p);
 885
 886         return -EAFNOSUPPORT;
 887 }
 888
 889 DnsServer* manager_find_dns_server(Manager *m, int family, const union in_addr_union *in_addr) {
 890         DnsServer *s;
 891
 892         assert(m);
 893         assert(in_addr);
 894
 895         LIST_FOREACH(servers, s, m->dns_servers)
 896                 if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0)
 897                         return s;
 898
 899         LIST_FOREACH(servers, s, m->fallback_dns_servers)
 900                 if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0)
 901                         return s;
 902
 903         return NULL;
 904 }
 905
 906 DnsServer *manager_set_dns_server(Manager *m, DnsServer *s) {
 907         assert(m);
 908
 909         if (m->current_dns_server == s)
 910                 return s;
 911
 912         if (s) {
 913                 _cleanup_free_ char *ip = NULL;
 914
 915                 in_addr_to_string(s->family, &s->address, &ip);
 916                 log_info("Switching to system DNS server %s.", strna(ip));
 917         }
 918
 919         m->current_dns_server = s;
 920
 921         if (m->unicast_scope)
 922                 dns_cache_flush(&m->unicast_scope->cache);
 923
 924         return s;
 925 }
 926
 927 DnsServer *manager_get_dns_server(Manager *m) {
 928         Link *l;
 929         assert(m);
 930
 931         /* Try to read updates resolv.conf */
 932         manager_read_resolv_conf(m);
 933
 934         if (!m->current_dns_server)
 935                 manager_set_dns_server(m, m->dns_servers);
 936
 937         if (!m->current_dns_server) {
 938                 bool found = false;
 939                 Iterator i;
 940
 941                 /* No DNS servers configured, let's see if there are
 942                  * any on any links. If not, we use the fallback
 943                  * servers */
 944
 945                 HASHMAP_FOREACH(l, m->links, i)
 946                         if (l->dns_servers) {
 947                                 found = true;
 948                                 break;
 949                         }
 950
 951                 if (!found)
 952                         manager_set_dns_server(m, m->fallback_dns_servers);
 953         }
 954
 955         return m->current_dns_server;
 956 }
 957
 958 void manager_next_dns_server(Manager *m) {
 959         assert(m);
 960
 961         /* If there's currently no DNS server set, then the next
 962          * manager_get_dns_server() will find one */
 963         if (!m->current_dns_server)
 964                 return;
 965
 966         /* Change to the next one */
 967         if (m->current_dns_server->servers_next) {
 968                 manager_set_dns_server(m, m->current_dns_server->servers_next);
 969                 return;
 970         }
 971
 972         /* If there was no next one, then start from the beginning of
 973          * the list */
 974         if (m->current_dns_server->type == DNS_SERVER_FALLBACK)
 975                 manager_set_dns_server(m, m->fallback_dns_servers);
 976         else
 977                 manager_set_dns_server(m, m->dns_servers);
 978 }
 979
 980 uint32_t manager_find_mtu(Manager *m) {
 981         uint32_t mtu = 0;
 982         Link *l;
 983         Iterator i;
 984
 985         /* If we don't know on which link a DNS packet would be
 986          * delivered, let's find the largest MTU that works on all
 987          * interfaces we know of */
 988
 989         HASHMAP_FOREACH(l, m->links, i) {
 990                 if (l->mtu <= 0)
 991                         continue;
 992
 993                 if (mtu <= 0 || l->mtu < mtu)
 994                         mtu = l->mtu;
 995         }
 996
 997         return mtu;
 998 }
 999
1000 int manager_find_ifindex(Manager *m, int family, const union in_addr_union *in_addr) {
1001         LinkAddress *a;
1002
1003         assert(m);
1004
1005         a = manager_find_link_address(m, family, in_addr);
1006         if (a)
1007                 return a->link->ifindex;
1008
1009         return 0;
1010 }
1011
1012 void manager_refresh_rrs(Manager *m) {
1013         Iterator i;
1014         Link *l;
1015
1016         assert(m);
1017
1018         m->llmnr_host_ipv4_key = dns_resource_key_unref(m->llmnr_host_ipv4_key);
1019         m->llmnr_host_ipv6_key = dns_resource_key_unref(m->llmnr_host_ipv6_key);
1020
1021         HASHMAP_FOREACH(l, m->links, i) {
1022                 link_add_rrs(l, true);
1023                 link_add_rrs(l, false);
1024         }
1025 }
1026
1027 int manager_next_hostname(Manager *m) {
1028         const char *p;
1029         uint64_t u, a;
1030         char *h, *k;
1031         int r;
1032
1033         assert(m);
1034
1035         p = strchr(m->llmnr_hostname, 0);
1036         assert(p);
1037
1038         while (p > m->llmnr_hostname) {
1039                 if (!strchr("0123456789", p[-1]))
1040                         break;
1041
1042                 p--;
1043         }
1044
1045         if (*p == 0 || safe_atou64(p, &u) < 0 || u <= 0)
1046                 u = 1;
1047
1048         /* Add a random number to the old value. This way we can avoid
1049          * that two hosts pick the same hostname, win on IPv4 and lose
1050          * on IPv6 (or vice versa), and pick the same hostname
1051          * replacement hostname, ad infinitum. We still want the
1052          * numbers to go up monotonically, hence we just add a random
1053          * value 1..10 */
1054
1055         random_bytes(&a, sizeof(a));
1056         u += 1 + a % 10;
1057
1058         if (asprintf(&h, "%.*s%" PRIu64, (int) (p - m->llmnr_hostname), m->llmnr_hostname, u) < 0)
1059                 return -ENOMEM;
1060
1061         r = dns_name_concat(h, "local", &k);
1062         if (r < 0) {
1063                 free(h);
1064                 return r;
1065         }
1066
1067         log_info("Hostname conflict, changing published hostname from '%s' to '%s'.", m->llmnr_hostname, h);
1068
1069         free(m->llmnr_hostname);
1070         m->llmnr_hostname = h;
1071
1072         free(m->mdns_hostname);
1073         m->mdns_hostname = k;
1074
1075         manager_refresh_rrs(m);
1076
1077         return 0;
1078 }
1079
1080 LinkAddress* manager_find_link_address(Manager *m, int family, const union in_addr_union *in_addr) {
1081         Iterator i;
1082         Link *l;
1083
1084         assert(m);
1085
1086         HASHMAP_FOREACH(l, m->links, i) {
1087                 LinkAddress *a;
1088
1089                 a = link_find_address(l, family, in_addr);
1090                 if (a)
1091                         return a;
1092         }
1093
1094         return NULL;
1095 }
1096
1097 bool manager_our_packet(Manager *m, DnsPacket *p) {
1098         assert(m);
1099         assert(p);
1100
1101         return !!manager_find_link_address(m, p->family, &p->sender);
1102 }
1103
1104 DnsScope* manager_find_scope(Manager *m, DnsPacket *p) {
1105         Link *l;
1106
1107         assert(m);
1108         assert(p);
1109
1110         l = hashmap_get(m->links, INT_TO_PTR(p->ifindex));
1111         if (!l)
1112                 return NULL;
1113
1114         if (p->protocol == DNS_PROTOCOL_LLMNR) {
1115                 if (p->family == AF_INET)
1116                         return l->llmnr_ipv4_scope;
1117                 else if (p->family == AF_INET6)
1118                         return l->llmnr_ipv6_scope;
1119         }
1120
1121         return NULL;
1122 }
1123
1124 void manager_verify_all(Manager *m) {
1125         DnsScope *s;
1126
1127         assert(m);
1128
1129         LIST_FOREACH(scopes, s, m->dns_scopes)
1130                 dns_zone_verify_all(&s->zone);
1131 }
1132
1133 int manager_is_own_hostname(Manager *m, const char *name) {
1134         int r;
1135
1136         assert(m);
1137         assert(name);
1138
1139         if (m->llmnr_hostname) {
1140                 r = dns_name_equal(name, m->llmnr_hostname);
1141                 if (r != 0)
1142                         return r;
1143         }
1144
1145         if (m->mdns_hostname)
1146                 return dns_name_equal(name, m->mdns_hostname);
1147
1148         return 0;
1149 }
1150
1151 static const char* const support_table[_SUPPORT_MAX] = {
1152         [SUPPORT_NO] = "no",
1153         [SUPPORT_YES] = "yes",
1154         [SUPPORT_RESOLVE] = "resolve",
1155 };
1156 DEFINE_STRING_TABLE_LOOKUP(support, Support);