src/resolve/resolved-dns-scope.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2014 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <netinet/tcp.h>
  21
  22 #include "af-list.h"
  23 #include "alloc-util.h"
  24 #include "dns-domain.h"
  25 #include "fd-util.h"
  26 #include "hostname-util.h"
  27 #include "missing.h"
  28 #include "random-util.h"
  29 #include "resolved-dns-scope.h"
  30 #include "resolved-llmnr.h"
  31 #include "resolved-mdns.h"
  32 #include "socket-util.h"
  33 #include "strv.h"
  34
  35 #define MULTICAST_RATELIMIT_INTERVAL_USEC (1*USEC_PER_SEC)
  36 #define MULTICAST_RATELIMIT_BURST 1000
  37
  38 /* After how much time to repeat LLMNR requests, see RFC 4795 Section 7 */
  39 #define MULTICAST_RESEND_TIMEOUT_MIN_USEC (100 * USEC_PER_MSEC)
  40 #define MULTICAST_RESEND_TIMEOUT_MAX_USEC (1 * USEC_PER_SEC)
  41
  42 int dns_scope_new(Manager *m, DnsScope **ret, Link *l, DnsProtocol protocol, int family) {
  43         DnsScope *s;
  44
  45         assert(m);
  46         assert(ret);
  47
  48         s = new0(DnsScope, 1);
  49         if (!s)
  50                 return -ENOMEM;
  51
  52         s->manager = m;
  53         s->link = l;
  54         s->protocol = protocol;
  55         s->family = family;
  56         s->resend_timeout = MULTICAST_RESEND_TIMEOUT_MIN_USEC;
  57
  58         if (protocol == DNS_PROTOCOL_DNS) {
  59                 /* Copy DNSSEC mode from the link if it is set there,
  60                  * otherwise take the manager's DNSSEC mode. Note that
  61                  * we copy this only at scope creation time, and do
  62                  * not update it from the on, even if the setting
  63                  * changes. */
  64
  65                 if (l)
  66                         s->dnssec_mode = link_get_dnssec_mode(l);
  67                 else
  68                         s->dnssec_mode = manager_get_dnssec_mode(m);
  69         } else
  70                 s->dnssec_mode = DNSSEC_NO;
  71
  72         LIST_PREPEND(scopes, m->dns_scopes, s);
  73
  74         dns_scope_llmnr_membership(s, true);
  75         dns_scope_mdns_membership(s, true);
  76
  77         log_debug("New scope on link %s, protocol %s, family %s", l ? l->name : "*", dns_protocol_to_string(protocol), family == AF_UNSPEC ? "*" : af_to_name(family));
  78
  79         /* Enforce ratelimiting for the multicast protocols */
  80         RATELIMIT_INIT(s->ratelimit, MULTICAST_RATELIMIT_INTERVAL_USEC, MULTICAST_RATELIMIT_BURST);
  81
  82         *ret = s;
  83         return 0;
  84 }
  85
  86 static void dns_scope_abort_transactions(DnsScope *s) {
  87         assert(s);
  88
  89         while (s->transactions) {
  90                 DnsTransaction *t = s->transactions;
  91
  92                 /* Abort the transaction, but make sure it is not
  93                  * freed while we still look at it */
  94
  95                 t->block_gc++;
  96                 if (DNS_TRANSACTION_IS_LIVE(t->state))
  97                         dns_transaction_complete(t, DNS_TRANSACTION_ABORTED);
  98                 t->block_gc--;
  99
 100                 dns_transaction_free(t);
 101         }
 102 }
 103
 104 DnsScope* dns_scope_free(DnsScope *s) {
 105         DnsResourceRecord *rr;
 106
 107         if (!s)
 108                 return NULL;
 109
 110         log_debug("Removing scope on link %s, protocol %s, family %s", s->link ? s->link->name : "*", dns_protocol_to_string(s->protocol), s->family == AF_UNSPEC ? "*" : af_to_name(s->family));
 111
 112         dns_scope_llmnr_membership(s, false);
 113         dns_scope_mdns_membership(s, false);
 114         dns_scope_abort_transactions(s);
 115
 116         while (s->query_candidates)
 117                 dns_query_candidate_free(s->query_candidates);
 118
 119         hashmap_free(s->transactions_by_key);
 120
 121         while ((rr = ordered_hashmap_steal_first(s->conflict_queue)))
 122                 dns_resource_record_unref(rr);
 123
 124         ordered_hashmap_free(s->conflict_queue);
 125         sd_event_source_unref(s->conflict_event_source);
 126
 127         sd_event_source_unref(s->announce_event_source);
 128
 129         dns_cache_flush(&s->cache);
 130         dns_zone_flush(&s->zone);
 131
 132         LIST_REMOVE(scopes, s->manager->dns_scopes, s);
 133         return mfree(s);
 134 }
 135
 136 DnsServer *dns_scope_get_dns_server(DnsScope *s) {
 137         assert(s);
 138
 139         if (s->protocol != DNS_PROTOCOL_DNS)
 140                 return NULL;
 141
 142         if (s->link)
 143                 return link_get_dns_server(s->link);
 144         else
 145                 return manager_get_dns_server(s->manager);
 146 }
 147
 148 void dns_scope_next_dns_server(DnsScope *s) {
 149         assert(s);
 150
 151         if (s->protocol != DNS_PROTOCOL_DNS)
 152                 return;
 153
 154         if (s->link)
 155                 link_next_dns_server(s->link);
 156         else
 157                 manager_next_dns_server(s->manager);
 158 }
 159
 160 void dns_scope_packet_received(DnsScope *s, usec_t rtt) {
 161         assert(s);
 162
 163         if (rtt <= s->max_rtt)
 164                 return;
 165
 166         s->max_rtt = rtt;
 167         s->resend_timeout = MIN(MAX(MULTICAST_RESEND_TIMEOUT_MIN_USEC, s->max_rtt * 2), MULTICAST_RESEND_TIMEOUT_MAX_USEC);
 168 }
 169
 170 void dns_scope_packet_lost(DnsScope *s, usec_t usec) {
 171         assert(s);
 172
 173         if (s->resend_timeout <= usec)
 174                 s->resend_timeout = MIN(s->resend_timeout * 2, MULTICAST_RESEND_TIMEOUT_MAX_USEC);
 175 }
 176
 177 static int dns_scope_emit_one(DnsScope *s, int fd, DnsPacket *p) {
 178         union in_addr_union addr;
 179         int ifindex = 0, r;
 180         int family;
 181         uint32_t mtu;
 182
 183         assert(s);
 184         assert(p);
 185         assert(p->protocol == s->protocol);
 186
 187         if (s->link) {
 188                 mtu = s->link->mtu;
 189                 ifindex = s->link->ifindex;
 190         } else
 191                 mtu = manager_find_mtu(s->manager);
 192
 193         switch (s->protocol) {
 194
 195         case DNS_PROTOCOL_DNS:
 196                 assert(fd >= 0);
 197
 198                 if (DNS_PACKET_QDCOUNT(p) > 1)
 199                         return -EOPNOTSUPP;
 200
 201                 if (p->size > DNS_PACKET_UNICAST_SIZE_MAX)
 202                         return -EMSGSIZE;
 203
 204                 if (p->size + UDP_PACKET_HEADER_SIZE > mtu)
 205                         return -EMSGSIZE;
 206
 207                 r = manager_write(s->manager, fd, p);
 208                 if (r < 0)
 209                         return r;
 210
 211                 break;
 212
 213         case DNS_PROTOCOL_LLMNR:
 214                 assert(fd < 0);
 215
 216                 if (DNS_PACKET_QDCOUNT(p) > 1)
 217                         return -EOPNOTSUPP;
 218
 219                 if (!ratelimit_test(&s->ratelimit))
 220                         return -EBUSY;
 221
 222                 family = s->family;
 223
 224                 if (family == AF_INET) {
 225                         addr.in = LLMNR_MULTICAST_IPV4_ADDRESS;
 226                         fd = manager_llmnr_ipv4_udp_fd(s->manager);
 227                 } else if (family == AF_INET6) {
 228                         addr.in6 = LLMNR_MULTICAST_IPV6_ADDRESS;
 229                         fd = manager_llmnr_ipv6_udp_fd(s->manager);
 230                 } else
 231                         return -EAFNOSUPPORT;
 232                 if (fd < 0)
 233                         return fd;
 234
 235                 r = manager_send(s->manager, fd, ifindex, family, &addr, LLMNR_PORT, NULL, p);
 236                 if (r < 0)
 237                         return r;
 238
 239                 break;
 240
 241         case DNS_PROTOCOL_MDNS:
 242                 assert(fd < 0);
 243
 244                 if (!ratelimit_test(&s->ratelimit))
 245                         return -EBUSY;
 246
 247                 family = s->family;
 248
 249                 if (family == AF_INET) {
 250                         addr.in = MDNS_MULTICAST_IPV4_ADDRESS;
 251                         fd = manager_mdns_ipv4_fd(s->manager);
 252                 } else if (family == AF_INET6) {
 253                         addr.in6 = MDNS_MULTICAST_IPV6_ADDRESS;
 254                         fd = manager_mdns_ipv6_fd(s->manager);
 255                 } else
 256                         return -EAFNOSUPPORT;
 257                 if (fd < 0)
 258                         return fd;
 259
 260                 r = manager_send(s->manager, fd, ifindex, family, &addr, MDNS_PORT, NULL, p);
 261                 if (r < 0)
 262                         return r;
 263
 264                 break;
 265
 266         default:
 267                 return -EAFNOSUPPORT;
 268         }
 269
 270         return 1;
 271 }
 272
 273 int dns_scope_emit_udp(DnsScope *s, int fd, DnsPacket *p) {
 274         int r;
 275
 276         assert(s);
 277         assert(p);
 278         assert(p->protocol == s->protocol);
 279         assert((s->protocol == DNS_PROTOCOL_DNS) == (fd >= 0));
 280
 281         do {
 282                 /* If there are multiple linked packets, set the TC bit in all but the last of them */
 283                 if (p->more) {
 284                         assert(p->protocol == DNS_PROTOCOL_MDNS);
 285                         dns_packet_set_flags(p, true, true);
 286                 }
 287
 288                 r = dns_scope_emit_one(s, fd, p);
 289                 if (r < 0)
 290                         return r;
 291
 292                 p = p->more;
 293         } while (p);
 294
 295         return 0;
 296 }
 297
 298 static int dns_scope_socket(
 299                 DnsScope *s,
 300                 int type,
 301                 int family,
 302                 const union in_addr_union *address,
 303                 DnsServer *server,
 304                 uint16_t port) {
 305
 306         _cleanup_close_ int fd = -1;
 307         union sockaddr_union sa = {};
 308         socklen_t salen;
 309         static const int one = 1;
 310         int ret, r, ifindex;
 311
 312         assert(s);
 313
 314         if (server) {
 315                 assert(family == AF_UNSPEC);
 316                 assert(!address);
 317
 318                 ifindex = dns_server_ifindex(server);
 319
 320                 sa.sa.sa_family = server->family;
 321                 if (server->family == AF_INET) {
 322                         sa.in.sin_port = htobe16(port);
 323                         sa.in.sin_addr = server->address.in;
 324                         salen = sizeof(sa.in);
 325                 } else if (server->family == AF_INET6) {
 326                         sa.in6.sin6_port = htobe16(port);
 327                         sa.in6.sin6_addr = server->address.in6;
 328                         sa.in6.sin6_scope_id = ifindex;
 329                         salen = sizeof(sa.in6);
 330                 } else
 331                         return -EAFNOSUPPORT;
 332         } else {
 333                 assert(family != AF_UNSPEC);
 334                 assert(address);
 335
 336                 sa.sa.sa_family = family;
 337                 ifindex = s->link ? s->link->ifindex : 0;
 338
 339                 if (family == AF_INET) {
 340                         sa.in.sin_port = htobe16(port);
 341                         sa.in.sin_addr = address->in;
 342                         salen = sizeof(sa.in);
 343                 } else if (family == AF_INET6) {
 344                         sa.in6.sin6_port = htobe16(port);
 345                         sa.in6.sin6_addr = address->in6;
 346                         sa.in6.sin6_scope_id = ifindex;
 347                         salen = sizeof(sa.in6);
 348                 } else
 349                         return -EAFNOSUPPORT;
 350         }
 351
 352         fd = socket(sa.sa.sa_family, type|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 353         if (fd < 0)
 354                 return -errno;
 355
 356         if (type == SOCK_STREAM) {
 357                 r = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
 358                 if (r < 0)
 359                         return -errno;
 360         }
 361
 362         if (s->link) {
 363                 be32_t ifindex_be = htobe32(ifindex);
 364
 365                 if (sa.sa.sa_family == AF_INET) {
 366                         r = setsockopt(fd, IPPROTO_IP, IP_UNICAST_IF, &ifindex_be, sizeof(ifindex_be));
 367                         if (r < 0)
 368                                 return -errno;
 369                 } else if (sa.sa.sa_family == AF_INET6) {
 370                         r = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_IF, &ifindex_be, sizeof(ifindex_be));
 371                         if (r < 0)
 372                                 return -errno;
 373                 }
 374         }
 375
 376         if (s->protocol == DNS_PROTOCOL_LLMNR) {
 377                 /* RFC 4795, section 2.5 requires the TTL to be set to 1 */
 378
 379                 if (sa.sa.sa_family == AF_INET) {
 380                         r = setsockopt(fd, IPPROTO_IP, IP_TTL, &one, sizeof(one));
 381                         if (r < 0)
 382                                 return -errno;
 383                 } else if (sa.sa.sa_family == AF_INET6) {
 384                         r = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &one, sizeof(one));
 385                         if (r < 0)
 386                                 return -errno;
 387                 }
 388         }
 389
 390         r = connect(fd, &sa.sa, salen);
 391         if (r < 0 && errno != EINPROGRESS)
 392                 return -errno;
 393
 394         ret = fd;
 395         fd = -1;
 396
 397         return ret;
 398 }
 399
 400 int dns_scope_socket_udp(DnsScope *s, DnsServer *server, uint16_t port) {
 401         return dns_scope_socket(s, SOCK_DGRAM, AF_UNSPEC, NULL, server, port);
 402 }
 403
 404 int dns_scope_socket_tcp(DnsScope *s, int family, const union in_addr_union *address, DnsServer *server, uint16_t port) {
 405         return dns_scope_socket(s, SOCK_STREAM, family, address, server, port);
 406 }
 407
 408 DnsScopeMatch dns_scope_good_domain(DnsScope *s, int ifindex, uint64_t flags, const char *domain) {
 409         DnsSearchDomain *d;
 410         DnsServer *dns_server;
 411
 412         assert(s);
 413         assert(domain);
 414
 415         /* Checks if the specified domain is something to look up on
 416          * this scope. Note that this accepts non-qualified hostnames,
 417          * i.e. those without any search path prefixed yet. */
 418
 419         if (ifindex != 0 && (!s->link || s->link->ifindex != ifindex))
 420                 return DNS_SCOPE_NO;
 421
 422         if ((SD_RESOLVED_FLAGS_MAKE(s->protocol, s->family, 0) & flags) == 0)
 423                 return DNS_SCOPE_NO;
 424
 425         /* Never resolve any loopback hostname or IP address via DNS,
 426          * LLMNR or mDNS. Instead, always rely on synthesized RRs for
 427          * these. */
 428         if (is_localhost(domain) ||
 429             dns_name_endswith(domain, "127.in-addr.arpa") > 0 ||
 430             dns_name_equal(domain, "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa") > 0)
 431                 return DNS_SCOPE_NO;
 432
 433         /* Never respond to some of the domains listed in RFC6303 */
 434         if (dns_name_endswith(domain, "0.in-addr.arpa") > 0 ||
 435             dns_name_equal(domain, "255.255.255.255.in-addr.arpa") > 0 ||
 436             dns_name_equal(domain, "0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa") > 0)
 437                 return DNS_SCOPE_NO;
 438
 439         /* Never respond to some of the domains listed in RFC6761 */
 440         if (dns_name_endswith(domain, "invalid") > 0)
 441                 return DNS_SCOPE_NO;
 442
 443         /* Always honour search domains for routing queries. Note that
 444          * we return DNS_SCOPE_YES here, rather than just
 445          * DNS_SCOPE_MAYBE, which means wildcard scopes won't be
 446          * considered anymore. */
 447         LIST_FOREACH(domains, d, dns_scope_get_search_domains(s))
 448                 if (dns_name_endswith(domain, d->name) > 0)
 449                         return DNS_SCOPE_YES;
 450
 451         /* If the DNS server has route-only domains, don't send other requests
 452          * to it. This would be a privacy violation, will most probably fail
 453          * anyway, and adds unnecessary load. */
 454         dns_server = dns_scope_get_dns_server(s);
 455         if (dns_server && dns_server_limited_domains(dns_server))
 456                 return DNS_SCOPE_NO;
 457
 458         switch (s->protocol) {
 459
 460         case DNS_PROTOCOL_DNS:
 461
 462                 /* Exclude link-local IP ranges */
 463                 if (dns_name_endswith(domain, "254.169.in-addr.arpa") == 0 &&
 464                     dns_name_endswith(domain, "8.e.f.ip6.arpa") == 0 &&
 465                     dns_name_endswith(domain, "9.e.f.ip6.arpa") == 0 &&
 466                     dns_name_endswith(domain, "a.e.f.ip6.arpa") == 0 &&
 467                     dns_name_endswith(domain, "b.e.f.ip6.arpa") == 0 &&
 468                     /* If networks use .local in their private setups, they are supposed to also add .local to their search
 469                      * domains, which we already checked above. Otherwise, we consider .local specific to mDNS and won't
 470                      * send such queries ordinary DNS servers. */
 471                     dns_name_endswith(domain, "local") == 0)
 472                         return DNS_SCOPE_MAYBE;
 473
 474                 return DNS_SCOPE_NO;
 475
 476         case DNS_PROTOCOL_MDNS:
 477                 if ((s->family == AF_INET && dns_name_endswith(domain, "in-addr.arpa") > 0) ||
 478                     (s->family == AF_INET6 && dns_name_endswith(domain, "ip6.arpa") > 0) ||
 479                     (dns_name_endswith(domain, "local") > 0 && /* only resolve names ending in .local via mDNS */
 480                      dns_name_equal(domain, "local") == 0 &&   /* but not the single-label "local" name itself */
 481                      manager_is_own_hostname(s->manager, domain) <= 0)) /* never resolve the local hostname via mDNS */
 482                         return DNS_SCOPE_MAYBE;
 483
 484                 return DNS_SCOPE_NO;
 485
 486         case DNS_PROTOCOL_LLMNR:
 487                 if ((s->family == AF_INET && dns_name_endswith(domain, "in-addr.arpa") > 0) ||
 488                     (s->family == AF_INET6 && dns_name_endswith(domain, "ip6.arpa") > 0) ||
 489                     (dns_name_is_single_label(domain) && /* only resolve single label names via LLMNR */
 490                      !is_gateway_hostname(domain) && /* don't resolve "gateway" with LLMNR, let nss-myhostname handle this */
 491                      manager_is_own_hostname(s->manager, domain) <= 0))  /* never resolve the local hostname via LLMNR */
 492                         return DNS_SCOPE_MAYBE;
 493
 494                 return DNS_SCOPE_NO;
 495
 496         default:
 497                 assert_not_reached("Unknown scope protocol");
 498         }
 499 }
 500
 501 bool dns_scope_good_key(DnsScope *s, const DnsResourceKey *key) {
 502         int key_family;
 503
 504         assert(s);
 505         assert(key);
 506
 507         /* Check if it makes sense to resolve the specified key on
 508          * this scope. Note that this call assumes as fully qualified
 509          * name, i.e. the search suffixes already appended. */
 510
 511         if (key->class != DNS_CLASS_IN)
 512                 return false;
 513
 514         if (s->protocol == DNS_PROTOCOL_DNS) {
 515
 516                 /* On classic DNS, looking up non-address RRs is always
 517                  * fine. (Specifically, we want to permit looking up
 518                  * DNSKEY and DS records on the root and top-level
 519                  * domains.) */
 520                 if (!dns_resource_key_is_address(key))
 521                         return true;
 522
 523                 /* However, we refuse to look up A and AAAA RRs on the
 524                  * root and single-label domains, under the assumption
 525                  * that those should be resolved via LLMNR or search
 526                  * path only, and should not be leaked onto the
 527                  * internet. */
 528                 return !(dns_name_is_single_label(dns_resource_key_name(key)) ||
 529                          dns_name_is_root(dns_resource_key_name(key)));
 530         }
 531
 532         /* On mDNS and LLMNR, send A and AAAA queries only on the
 533          * respective scopes */
 534
 535         key_family = dns_type_to_af(key->type);
 536         if (key_family < 0)
 537                 return true;
 538
 539         return key_family == s->family;
 540 }
 541
 542 static int dns_scope_multicast_membership(DnsScope *s, bool b, struct in_addr in, struct in6_addr in6) {
 543         int fd;
 544
 545         assert(s);
 546         assert(s->link);
 547
 548         if (s->family == AF_INET) {
 549                 struct ip_mreqn mreqn = {
 550                         .imr_multiaddr = in,
 551                         .imr_ifindex = s->link->ifindex,
 552                 };
 553
 554                 if (s->protocol == DNS_PROTOCOL_LLMNR)
 555                         fd = manager_llmnr_ipv4_udp_fd(s->manager);
 556                 else
 557                         fd = manager_mdns_ipv4_fd(s->manager);
 558
 559                 if (fd < 0)
 560                         return fd;
 561
 562                 /* Always first try to drop membership before we add
 563                  * one. This is necessary on some devices, such as
 564                  * veth. */
 565                 if (b)
 566                         (void) setsockopt(fd, IPPROTO_IP, IP_DROP_MEMBERSHIP, &mreqn, sizeof(mreqn));
 567
 568                 if (setsockopt(fd, IPPROTO_IP, b ? IP_ADD_MEMBERSHIP : IP_DROP_MEMBERSHIP, &mreqn, sizeof(mreqn)) < 0)
 569                         return -errno;
 570
 571         } else if (s->family == AF_INET6) {
 572                 struct ipv6_mreq mreq = {
 573                         .ipv6mr_multiaddr = in6,
 574                         .ipv6mr_interface = s->link->ifindex,
 575                 };
 576
 577                 if (s->protocol == DNS_PROTOCOL_LLMNR)
 578                         fd = manager_llmnr_ipv6_udp_fd(s->manager);
 579                 else
 580                         fd = manager_mdns_ipv6_fd(s->manager);
 581
 582                 if (fd < 0)
 583                         return fd;
 584
 585                 if (b)
 586                         (void) setsockopt(fd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mreq, sizeof(mreq));
 587
 588                 if (setsockopt(fd, IPPROTO_IPV6, b ? IPV6_ADD_MEMBERSHIP : IPV6_DROP_MEMBERSHIP, &mreq, sizeof(mreq)) < 0)
 589                         return -errno;
 590         } else
 591                 return -EAFNOSUPPORT;
 592
 593         return 0;
 594 }
 595
 596 int dns_scope_llmnr_membership(DnsScope *s, bool b) {
 597         assert(s);
 598
 599         if (s->protocol != DNS_PROTOCOL_LLMNR)
 600                 return 0;
 601
 602         return dns_scope_multicast_membership(s, b, LLMNR_MULTICAST_IPV4_ADDRESS, LLMNR_MULTICAST_IPV6_ADDRESS);
 603 }
 604
 605 int dns_scope_mdns_membership(DnsScope *s, bool b) {
 606         assert(s);
 607
 608         if (s->protocol != DNS_PROTOCOL_MDNS)
 609                 return 0;
 610
 611         return dns_scope_multicast_membership(s, b, MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_IPV6_ADDRESS);
 612 }
 613
 614 int dns_scope_make_reply_packet(
 615                 DnsScope *s,
 616                 uint16_t id,
 617                 int rcode,
 618                 DnsQuestion *q,
 619                 DnsAnswer *answer,
 620                 DnsAnswer *soa,
 621                 bool tentative,
 622                 DnsPacket **ret) {
 623
 624         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 625         int r;
 626
 627         assert(s);
 628         assert(ret);
 629
 630         if (dns_question_isempty(q) &&
 631             dns_answer_isempty(answer) &&
 632             dns_answer_isempty(soa))
 633                 return -EINVAL;
 634
 635         r = dns_packet_new(&p, s->protocol, 0);
 636         if (r < 0)
 637                 return r;
 638
 639         DNS_PACKET_HEADER(p)->id = id;
 640         DNS_PACKET_HEADER(p)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(
 641                                                               1 /* qr */,
 642                                                               0 /* opcode */,
 643                                                               0 /* c */,
 644                                                               0 /* tc */,
 645                                                               tentative,
 646                                                               0 /* (ra) */,
 647                                                               0 /* (ad) */,
 648                                                               0 /* (cd) */,
 649                                                               rcode));
 650
 651         r = dns_packet_append_question(p, q);
 652         if (r < 0)
 653                 return r;
 654         DNS_PACKET_HEADER(p)->qdcount = htobe16(dns_question_size(q));
 655
 656         r = dns_packet_append_answer(p, answer);
 657         if (r < 0)
 658                 return r;
 659         DNS_PACKET_HEADER(p)->ancount = htobe16(dns_answer_size(answer));
 660
 661         r = dns_packet_append_answer(p, soa);
 662         if (r < 0)
 663                 return r;
 664         DNS_PACKET_HEADER(p)->arcount = htobe16(dns_answer_size(soa));
 665
 666         *ret = p;
 667         p = NULL;
 668
 669         return 0;
 670 }
 671
 672 static void dns_scope_verify_conflicts(DnsScope *s, DnsPacket *p) {
 673         DnsResourceRecord *rr;
 674         DnsResourceKey *key;
 675
 676         assert(s);
 677         assert(p);
 678
 679         DNS_QUESTION_FOREACH(key, p->question)
 680                 dns_zone_verify_conflicts(&s->zone, key);
 681
 682         DNS_ANSWER_FOREACH(rr, p->answer)
 683                 dns_zone_verify_conflicts(&s->zone, rr->key);
 684 }
 685
 686 void dns_scope_process_query(DnsScope *s, DnsStream *stream, DnsPacket *p) {
 687         _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL, *soa = NULL;
 688         _cleanup_(dns_packet_unrefp) DnsPacket *reply = NULL;
 689         DnsResourceKey *key = NULL;
 690         bool tentative = false;
 691         int r;
 692
 693         assert(s);
 694         assert(p);
 695
 696         if (p->protocol != DNS_PROTOCOL_LLMNR)
 697                 return;
 698
 699         if (p->ipproto == IPPROTO_UDP) {
 700                 /* Don't accept UDP queries directed to anything but
 701                  * the LLMNR multicast addresses. See RFC 4795,
 702                  * section 2.5. */
 703
 704                 if (p->family == AF_INET && !in_addr_equal(AF_INET, &p->destination, (union in_addr_union*) &LLMNR_MULTICAST_IPV4_ADDRESS))
 705                         return;
 706
 707                 if (p->family == AF_INET6 && !in_addr_equal(AF_INET6, &p->destination, (union in_addr_union*) &LLMNR_MULTICAST_IPV6_ADDRESS))
 708                         return;
 709         }
 710
 711         r = dns_packet_extract(p);
 712         if (r < 0) {
 713                 log_debug_errno(r, "Failed to extract resource records from incoming packet: %m");
 714                 return;
 715         }
 716
 717         if (DNS_PACKET_LLMNR_C(p)) {
 718                 /* Somebody notified us about a possible conflict */
 719                 dns_scope_verify_conflicts(s, p);
 720                 return;
 721         }
 722
 723         assert(dns_question_size(p->question) == 1);
 724         key = p->question->keys[0];
 725
 726         r = dns_zone_lookup(&s->zone, key, 0, &answer, &soa, &tentative);
 727         if (r < 0) {
 728                 log_debug_errno(r, "Failed to lookup key: %m");
 729                 return;
 730         }
 731         if (r == 0)
 732                 return;
 733
 734         if (answer)
 735                 dns_answer_order_by_scope(answer, in_addr_is_link_local(p->family, &p->sender) > 0);
 736
 737         r = dns_scope_make_reply_packet(s, DNS_PACKET_ID(p), DNS_RCODE_SUCCESS, p->question, answer, soa, tentative, &reply);
 738         if (r < 0) {
 739                 log_debug_errno(r, "Failed to build reply packet: %m");
 740                 return;
 741         }
 742
 743         if (stream) {
 744                 r = dns_stream_write_packet(stream, reply);
 745                 if (r < 0) {
 746                         log_debug_errno(r, "Failed to enqueue reply packet: %m");
 747                         return;
 748                 }
 749
 750                 /* Let's take an extra reference on this stream, so that it stays around after returning. The reference
 751                  * will be dangling until the stream is disconnected, and the default completion handler of the stream
 752                  * will then unref the stream and destroy it */
 753                 if (DNS_STREAM_QUEUED(stream))
 754                         dns_stream_ref(stream);
 755         } else {
 756                 int fd;
 757
 758                 if (!ratelimit_test(&s->ratelimit))
 759                         return;
 760
 761                 if (p->family == AF_INET)
 762                         fd = manager_llmnr_ipv4_udp_fd(s->manager);
 763                 else if (p->family == AF_INET6)
 764                         fd = manager_llmnr_ipv6_udp_fd(s->manager);
 765                 else {
 766                         log_debug("Unknown protocol");
 767                         return;
 768                 }
 769                 if (fd < 0) {
 770                         log_debug_errno(fd, "Failed to get reply socket: %m");
 771                         return;
 772                 }
 773
 774                 /* Note that we always immediately reply to all LLMNR
 775                  * requests, and do not wait any time, since we
 776                  * verified uniqueness for all records. Also see RFC
 777                  * 4795, Section 2.7 */
 778
 779                 r = manager_send(s->manager, fd, p->ifindex, p->family, &p->sender, p->sender_port, NULL, reply);
 780                 if (r < 0) {
 781                         log_debug_errno(r, "Failed to send reply packet: %m");
 782                         return;
 783                 }
 784         }
 785 }
 786
 787 DnsTransaction *dns_scope_find_transaction(DnsScope *scope, DnsResourceKey *key, bool cache_ok) {
 788         DnsTransaction *t;
 789
 790         assert(scope);
 791         assert(key);
 792
 793         /* Try to find an ongoing transaction that is a equal to the
 794          * specified question */
 795         t = hashmap_get(scope->transactions_by_key, key);
 796         if (!t)
 797                 return NULL;
 798
 799         /* Refuse reusing transactions that completed based on cached
 800          * data instead of a real packet, if that's requested. */
 801         if (!cache_ok &&
 802             IN_SET(t->state, DNS_TRANSACTION_SUCCESS, DNS_TRANSACTION_RCODE_FAILURE) &&
 803             t->answer_source != DNS_TRANSACTION_NETWORK)
 804                 return NULL;
 805
 806         return t;
 807 }
 808
 809 static int dns_scope_make_conflict_packet(
 810                 DnsScope *s,
 811                 DnsResourceRecord *rr,
 812                 DnsPacket **ret) {
 813
 814         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 815         int r;
 816
 817         assert(s);
 818         assert(rr);
 819         assert(ret);
 820
 821         r = dns_packet_new(&p, s->protocol, 0);
 822         if (r < 0)
 823                 return r;
 824
 825         DNS_PACKET_HEADER(p)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(
 826                                                               0 /* qr */,
 827                                                               0 /* opcode */,
 828                                                               1 /* conflict */,
 829                                                               0 /* tc */,
 830                                                               0 /* t */,
 831                                                               0 /* (ra) */,
 832                                                               0 /* (ad) */,
 833                                                               0 /* (cd) */,
 834                                                               0));
 835
 836         /* For mDNS, the transaction ID should always be 0 */
 837         if (s->protocol != DNS_PROTOCOL_MDNS)
 838                 random_bytes(&DNS_PACKET_HEADER(p)->id, sizeof(uint16_t));
 839
 840         DNS_PACKET_HEADER(p)->qdcount = htobe16(1);
 841         DNS_PACKET_HEADER(p)->arcount = htobe16(1);
 842
 843         r = dns_packet_append_key(p, rr->key, 0, NULL);
 844         if (r < 0)
 845                 return r;
 846
 847         r = dns_packet_append_rr(p, rr, 0, NULL, NULL);
 848         if (r < 0)
 849                 return r;
 850
 851         *ret = p;
 852         p = NULL;
 853
 854         return 0;
 855 }
 856
 857 static int on_conflict_dispatch(sd_event_source *es, usec_t usec, void *userdata) {
 858         DnsScope *scope = userdata;
 859         int r;
 860
 861         assert(es);
 862         assert(scope);
 863
 864         scope->conflict_event_source = sd_event_source_unref(scope->conflict_event_source);
 865
 866         for (;;) {
 867                 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
 868                 _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 869
 870                 rr = ordered_hashmap_steal_first(scope->conflict_queue);
 871                 if (!rr)
 872                         break;
 873
 874                 r = dns_scope_make_conflict_packet(scope, rr, &p);
 875                 if (r < 0) {
 876                         log_error_errno(r, "Failed to make conflict packet: %m");
 877                         return 0;
 878                 }
 879
 880                 r = dns_scope_emit_udp(scope, -1, p);
 881                 if (r < 0)
 882                         log_debug_errno(r, "Failed to send conflict packet: %m");
 883         }
 884
 885         return 0;
 886 }
 887
 888 int dns_scope_notify_conflict(DnsScope *scope, DnsResourceRecord *rr) {
 889         usec_t jitter;
 890         int r;
 891
 892         assert(scope);
 893         assert(rr);
 894
 895         /* We don't send these queries immediately. Instead, we queue
 896          * them, and send them after some jitter delay. */
 897         r = ordered_hashmap_ensure_allocated(&scope->conflict_queue, &dns_resource_key_hash_ops);
 898         if (r < 0) {
 899                 log_oom();
 900                 return r;
 901         }
 902
 903         /* We only place one RR per key in the conflict
 904          * messages, not all of them. That should be enough to
 905          * indicate where there might be a conflict */
 906         r = ordered_hashmap_put(scope->conflict_queue, rr->key, rr);
 907         if (r == -EEXIST || r == 0)
 908                 return 0;
 909         if (r < 0)
 910                 return log_debug_errno(r, "Failed to queue conflicting RR: %m");
 911
 912         dns_resource_record_ref(rr);
 913
 914         if (scope->conflict_event_source)
 915                 return 0;
 916
 917         random_bytes(&jitter, sizeof(jitter));
 918         jitter %= LLMNR_JITTER_INTERVAL_USEC;
 919
 920         r = sd_event_add_time(scope->manager->event,
 921                               &scope->conflict_event_source,
 922                               clock_boottime_or_monotonic(),
 923                               now(clock_boottime_or_monotonic()) + jitter,
 924                               LLMNR_JITTER_INTERVAL_USEC,
 925                               on_conflict_dispatch, scope);
 926         if (r < 0)
 927                 return log_debug_errno(r, "Failed to add conflict dispatch event: %m");
 928
 929         (void) sd_event_source_set_description(scope->conflict_event_source, "scope-conflict");
 930
 931         return 0;
 932 }
 933
 934 void dns_scope_check_conflicts(DnsScope *scope, DnsPacket *p) {
 935         unsigned i;
 936         int r;
 937
 938         assert(scope);
 939         assert(p);
 940
 941         if (!IN_SET(p->protocol, DNS_PROTOCOL_LLMNR, DNS_PROTOCOL_MDNS))
 942                 return;
 943
 944         if (DNS_PACKET_RRCOUNT(p) <= 0)
 945                 return;
 946
 947         if (p->protocol == DNS_PROTOCOL_LLMNR) {
 948                 if (DNS_PACKET_LLMNR_C(p) != 0)
 949                         return;
 950
 951                 if (DNS_PACKET_LLMNR_T(p) != 0)
 952                         return;
 953         }
 954
 955         if (manager_our_packet(scope->manager, p))
 956                 return;
 957
 958         r = dns_packet_extract(p);
 959         if (r < 0) {
 960                 log_debug_errno(r, "Failed to extract packet: %m");
 961                 return;
 962         }
 963
 964         log_debug("Checking for conflicts...");
 965
 966         for (i = 0; i < p->answer->n_rrs; i++) {
 967
 968                 /* Check for conflicts against the local zone. If we
 969                  * found one, we won't check any further */
 970                 r = dns_zone_check_conflicts(&scope->zone, p->answer->items[i].rr);
 971                 if (r != 0)
 972                         continue;
 973
 974                 /* Check for conflicts against the local cache. If so,
 975                  * send out an advisory query, to inform everybody */
 976                 r = dns_cache_check_conflicts(&scope->cache, p->answer->items[i].rr, p->family, &p->sender);
 977                 if (r <= 0)
 978                         continue;
 979
 980                 dns_scope_notify_conflict(scope, p->answer->items[i].rr);
 981         }
 982 }
 983
 984 void dns_scope_dump(DnsScope *s, FILE *f) {
 985         assert(s);
 986
 987         if (!f)
 988                 f = stdout;
 989
 990         fputs("[Scope protocol=", f);
 991         fputs(dns_protocol_to_string(s->protocol), f);
 992
 993         if (s->link) {
 994                 fputs(" interface=", f);
 995                 fputs(s->link->name, f);
 996         }
 997
 998         if (s->family != AF_UNSPEC) {
 999                 fputs(" family=", f);
1000                 fputs(af_to_name(s->family), f);
1001         }
1002
1003         fputs("]\n", f);
1004
1005         if (!dns_zone_is_empty(&s->zone)) {
1006                 fputs("ZONE:\n", f);
1007                 dns_zone_dump(&s->zone, f);
1008         }
1009
1010         if (!dns_cache_is_empty(&s->cache)) {
1011                 fputs("CACHE:\n", f);
1012                 dns_cache_dump(&s->cache, f);
1013         }
1014 }
1015
1016 DnsSearchDomain *dns_scope_get_search_domains(DnsScope *s) {
1017         assert(s);
1018
1019         if (s->protocol != DNS_PROTOCOL_DNS)
1020                 return NULL;
1021
1022         if (s->link)
1023                 return s->link->search_domains;
1024
1025         return s->manager->search_domains;
1026 }
1027
1028 bool dns_scope_name_needs_search_domain(DnsScope *s, const char *name) {
1029         assert(s);
1030
1031         if (s->protocol != DNS_PROTOCOL_DNS)
1032                 return false;
1033
1034         return dns_name_is_single_label(name);
1035 }
1036
1037 bool dns_scope_network_good(DnsScope *s) {
1038         /* Checks whether the network is in good state for lookups on this scope. For mDNS/LLMNR/Classic DNS scopes
1039          * bound to links this is easy, as they don't even exist if the link isn't in a suitable state. For the global
1040          * DNS scope we check whether there are any links that are up and have an address. */
1041
1042         if (s->link)
1043                 return true;
1044
1045         return manager_routable(s->manager, AF_UNSPEC);
1046 }
1047
1048 int dns_scope_ifindex(DnsScope *s) {
1049         assert(s);
1050
1051         if (s->link)
1052                 return s->link->ifindex;
1053
1054         return 0;
1055 }
1056
1057 static int on_announcement_timeout(sd_event_source *s, usec_t usec, void *userdata) {
1058         DnsScope *scope = userdata;
1059
1060         assert(s);
1061
1062         scope->announce_event_source = sd_event_source_unref(scope->announce_event_source);
1063
1064         (void) dns_scope_announce(scope, false);
1065         return 0;
1066 }
1067
1068 int dns_scope_announce(DnsScope *scope, bool goodbye) {
1069         _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
1070         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
1071         LinkAddress *a;
1072         int r;
1073
1074         if (!scope)
1075                 return 0;
1076
1077         if (scope->protocol != DNS_PROTOCOL_MDNS)
1078                 return 0;
1079
1080         answer = dns_answer_new(scope->link->n_addresses * 2);
1081         if (!answer)
1082                 return log_oom();
1083
1084         LIST_FOREACH(addresses, a, scope->link->addresses) {
1085                 r = dns_answer_add(answer, a->mdns_address_rr, 0, goodbye ? DNS_ANSWER_GOODBYE : DNS_ANSWER_CACHE_FLUSH);
1086                 if (r < 0)
1087                         return log_debug_errno(r, "Failed to add address RR to answer: %m");
1088
1089                 r = dns_answer_add(answer, a->mdns_ptr_rr, 0, goodbye ? DNS_ANSWER_GOODBYE : DNS_ANSWER_CACHE_FLUSH);
1090                 if (r < 0)
1091                         return log_debug_errno(r, "Failed to add PTR RR to answer: %m");
1092         }
1093
1094         if (dns_answer_isempty(answer))
1095                 return 0;
1096
1097         r = dns_scope_make_reply_packet(scope, 0, DNS_RCODE_SUCCESS, NULL, answer, NULL, false, &p);
1098         if (r < 0)
1099                 return log_debug_errno(r, "Failed to build reply packet: %m");
1100
1101         r = dns_scope_emit_udp(scope, -1, p);
1102         if (r < 0)
1103                 return log_debug_errno(r, "Failed to send reply packet: %m");
1104
1105         /* In section 8.3 of RFC6762: "The Multicast DNS responder MUST send at least two unsolicited
1106          * responses, one second apart." */
1107         if (!scope->announced) {
1108                 usec_t ts;
1109
1110                 scope->announced = true;
1111
1112                 assert_se(sd_event_now(scope->manager->event, clock_boottime_or_monotonic(), &ts) >= 0);
1113                 ts += MDNS_ANNOUNCE_DELAY;
1114
1115                 r = sd_event_add_time(
1116                                 scope->manager->event,
1117                                 &scope->announce_event_source,
1118                                 clock_boottime_or_monotonic(),
1119                                 ts,
1120                                 MDNS_JITTER_RANGE_USEC,
1121                                 on_announcement_timeout, scope);
1122                 if (r < 0)
1123                         return log_debug_errno(r, "Failed to schedule second announcement: %m");
1124
1125                 (void) sd_event_source_set_description(scope->announce_event_source, "mdns-announce");
1126         }
1127
1128         return 0;
1129 }