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