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         dns_cache_flush(&s->cache);
 128         dns_zone_flush(&s->zone);
 129
 130         LIST_REMOVE(scopes, s->manager->dns_scopes, s);
 131         free(s);
 132
 133         return NULL;
 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
 411         assert(s);
 412         assert(domain);
 413
 414         /* Checks if the specified domain is something to look up on
 415          * this scope. Note that this accepts non-qualified hostnames,
 416          * i.e. those without any search path prefixed yet. */
 417
 418         if (ifindex != 0 && (!s->link || s->link->ifindex != ifindex))
 419                 return DNS_SCOPE_NO;
 420
 421         if ((SD_RESOLVED_FLAGS_MAKE(s->protocol, s->family, 0) & flags) == 0)
 422                 return DNS_SCOPE_NO;
 423
 424         /* Never resolve any loopback hostname or IP address via DNS,
 425          * LLMNR or mDNS. Instead, always rely on synthesized RRs for
 426          * these. */
 427         if (is_localhost(domain) ||
 428             dns_name_endswith(domain, "127.in-addr.arpa") > 0 ||
 429             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)
 430                 return DNS_SCOPE_NO;
 431
 432         /* Never respond to some of the domains listed in RFC6303 */
 433         if (dns_name_endswith(domain, "0.in-addr.arpa") > 0 ||
 434             dns_name_equal(domain, "255.255.255.255.in-addr.arpa") > 0 ||
 435             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)
 436                 return DNS_SCOPE_NO;
 437
 438         /* Never respond to some of the domains listed in RFC6761 */
 439         if (dns_name_endswith(domain, "invalid") > 0)
 440                 return DNS_SCOPE_NO;
 441
 442         /* Always honour search domains for routing queries. Note that
 443          * we return DNS_SCOPE_YES here, rather than just
 444          * DNS_SCOPE_MAYBE, which means wildcard scopes won't be
 445          * considered anymore. */
 446         LIST_FOREACH(domains, d, dns_scope_get_search_domains(s))
 447                 if (dns_name_endswith(domain, d->name) > 0)
 448                         return DNS_SCOPE_YES;
 449
 450         switch (s->protocol) {
 451
 452         case DNS_PROTOCOL_DNS:
 453
 454                 /* Exclude link-local IP ranges */
 455                 if (dns_name_endswith(domain, "254.169.in-addr.arpa") == 0 &&
 456                     dns_name_endswith(domain, "8.e.f.ip6.arpa") == 0 &&
 457                     dns_name_endswith(domain, "9.e.f.ip6.arpa") == 0 &&
 458                     dns_name_endswith(domain, "a.e.f.ip6.arpa") == 0 &&
 459                     dns_name_endswith(domain, "b.e.f.ip6.arpa") == 0 &&
 460                     /* If networks use .local in their private setups, they are supposed to also add .local to their search
 461                      * domains, which we already checked above. Otherwise, we consider .local specific to mDNS and won't
 462                      * send such queries ordinary DNS servers. */
 463                     dns_name_endswith(domain, "local") == 0)
 464                         return DNS_SCOPE_MAYBE;
 465
 466                 return DNS_SCOPE_NO;
 467
 468         case DNS_PROTOCOL_MDNS:
 469                 if ((s->family == AF_INET && dns_name_endswith(domain, "in-addr.arpa") > 0) ||
 470                     (s->family == AF_INET6 && dns_name_endswith(domain, "ip6.arpa") > 0) ||
 471                     (dns_name_endswith(domain, "local") > 0 && /* only resolve names ending in .local via mDNS */
 472                      dns_name_equal(domain, "local") == 0 &&   /* but not the single-label "local" name itself */
 473                      manager_is_own_hostname(s->manager, domain) <= 0)) /* never resolve the local hostname via mDNS */
 474                         return DNS_SCOPE_MAYBE;
 475
 476                 return DNS_SCOPE_NO;
 477
 478         case DNS_PROTOCOL_LLMNR:
 479                 if ((s->family == AF_INET && dns_name_endswith(domain, "in-addr.arpa") > 0) ||
 480                     (s->family == AF_INET6 && dns_name_endswith(domain, "ip6.arpa") > 0) ||
 481                     (dns_name_is_single_label(domain) && /* only resolve single label names via LLMNR */
 482                      !is_gateway_hostname(domain) && /* don't resolve "gateway" with LLMNR, let nss-myhostname handle this */
 483                      manager_is_own_hostname(s->manager, domain) <= 0))  /* never resolve the local hostname via LLMNR */
 484                         return DNS_SCOPE_MAYBE;
 485
 486                 return DNS_SCOPE_NO;
 487
 488         default:
 489                 assert_not_reached("Unknown scope protocol");
 490         }
 491 }
 492
 493 bool dns_scope_good_key(DnsScope *s, const DnsResourceKey *key) {
 494         int key_family;
 495
 496         assert(s);
 497         assert(key);
 498
 499         /* Check if it makes sense to resolve the specified key on
 500          * this scope. Note that this call assumes as fully qualified
 501          * name, i.e. the search suffixes already appended. */
 502
 503         if (key->class != DNS_CLASS_IN)
 504                 return false;
 505
 506         if (s->protocol == DNS_PROTOCOL_DNS) {
 507
 508                 /* On classic DNS, looking up non-address RRs is always
 509                  * fine. (Specifically, we want to permit looking up
 510                  * DNSKEY and DS records on the root and top-level
 511                  * domains.) */
 512                 if (!dns_resource_key_is_address(key))
 513                         return true;
 514
 515                 /* However, we refuse to look up A and AAAA RRs on the
 516                  * root and single-label domains, under the assumption
 517                  * that those should be resolved via LLMNR or search
 518                  * path only, and should not be leaked onto the
 519                  * internet. */
 520                 return !(dns_name_is_single_label(dns_resource_key_name(key)) ||
 521                          dns_name_is_root(dns_resource_key_name(key)));
 522         }
 523
 524         /* On mDNS and LLMNR, send A and AAAA queries only on the
 525          * respective scopes */
 526
 527         key_family = dns_type_to_af(key->type);
 528         if (key_family < 0)
 529                 return true;
 530
 531         return key_family == s->family;
 532 }
 533
 534 static int dns_scope_multicast_membership(DnsScope *s, bool b, struct in_addr in, struct in6_addr in6) {
 535         int fd;
 536
 537         assert(s);
 538         assert(s->link);
 539
 540         if (s->family == AF_INET) {
 541                 struct ip_mreqn mreqn = {
 542                         .imr_multiaddr = in,
 543                         .imr_ifindex = s->link->ifindex,
 544                 };
 545
 546                 fd = manager_llmnr_ipv4_udp_fd(s->manager);
 547                 if (fd < 0)
 548                         return fd;
 549
 550                 /* Always first try to drop membership before we add
 551                  * one. This is necessary on some devices, such as
 552                  * veth. */
 553                 if (b)
 554                         (void) setsockopt(fd, IPPROTO_IP, IP_DROP_MEMBERSHIP, &mreqn, sizeof(mreqn));
 555
 556                 if (setsockopt(fd, IPPROTO_IP, b ? IP_ADD_MEMBERSHIP : IP_DROP_MEMBERSHIP, &mreqn, sizeof(mreqn)) < 0)
 557                         return -errno;
 558
 559         } else if (s->family == AF_INET6) {
 560                 struct ipv6_mreq mreq = {
 561                         .ipv6mr_multiaddr = in6,
 562                         .ipv6mr_interface = s->link->ifindex,
 563                 };
 564
 565                 fd = manager_llmnr_ipv6_udp_fd(s->manager);
 566                 if (fd < 0)
 567                         return fd;
 568
 569                 if (b)
 570                         (void) setsockopt(fd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mreq, sizeof(mreq));
 571
 572                 if (setsockopt(fd, IPPROTO_IPV6, b ? IPV6_ADD_MEMBERSHIP : IPV6_DROP_MEMBERSHIP, &mreq, sizeof(mreq)) < 0)
 573                         return -errno;
 574         } else
 575                 return -EAFNOSUPPORT;
 576
 577         return 0;
 578 }
 579
 580 int dns_scope_llmnr_membership(DnsScope *s, bool b) {
 581         assert(s);
 582
 583         if (s->protocol != DNS_PROTOCOL_LLMNR)
 584                 return 0;
 585
 586         return dns_scope_multicast_membership(s, b, LLMNR_MULTICAST_IPV4_ADDRESS, LLMNR_MULTICAST_IPV6_ADDRESS);
 587 }
 588
 589 int dns_scope_mdns_membership(DnsScope *s, bool b) {
 590         assert(s);
 591
 592         if (s->protocol != DNS_PROTOCOL_MDNS)
 593                 return 0;
 594
 595         return dns_scope_multicast_membership(s, b, MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_IPV6_ADDRESS);
 596 }
 597
 598 static int dns_scope_make_reply_packet(
 599                 DnsScope *s,
 600                 uint16_t id,
 601                 int rcode,
 602                 DnsQuestion *q,
 603                 DnsAnswer *answer,
 604                 DnsAnswer *soa,
 605                 bool tentative,
 606                 DnsPacket **ret) {
 607
 608         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 609         int r;
 610
 611         assert(s);
 612         assert(ret);
 613
 614         if (dns_question_isempty(q) &&
 615             dns_answer_isempty(answer) &&
 616             dns_answer_isempty(soa))
 617                 return -EINVAL;
 618
 619         r = dns_packet_new(&p, s->protocol, 0);
 620         if (r < 0)
 621                 return r;
 622
 623         DNS_PACKET_HEADER(p)->id = id;
 624         DNS_PACKET_HEADER(p)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(
 625                                                               1 /* qr */,
 626                                                               0 /* opcode */,
 627                                                               0 /* c */,
 628                                                               0 /* tc */,
 629                                                               tentative,
 630                                                               0 /* (ra) */,
 631                                                               0 /* (ad) */,
 632                                                               0 /* (cd) */,
 633                                                               rcode));
 634
 635         r = dns_packet_append_question(p, q);
 636         if (r < 0)
 637                 return r;
 638         DNS_PACKET_HEADER(p)->qdcount = htobe16(dns_question_size(q));
 639
 640         r = dns_packet_append_answer(p, answer);
 641         if (r < 0)
 642                 return r;
 643         DNS_PACKET_HEADER(p)->ancount = htobe16(dns_answer_size(answer));
 644
 645         r = dns_packet_append_answer(p, soa);
 646         if (r < 0)
 647                 return r;
 648         DNS_PACKET_HEADER(p)->arcount = htobe16(dns_answer_size(soa));
 649
 650         *ret = p;
 651         p = NULL;
 652
 653         return 0;
 654 }
 655
 656 static void dns_scope_verify_conflicts(DnsScope *s, DnsPacket *p) {
 657         DnsResourceRecord *rr;
 658         DnsResourceKey *key;
 659
 660         assert(s);
 661         assert(p);
 662
 663         DNS_QUESTION_FOREACH(key, p->question)
 664                 dns_zone_verify_conflicts(&s->zone, key);
 665
 666         DNS_ANSWER_FOREACH(rr, p->answer)
 667                 dns_zone_verify_conflicts(&s->zone, rr->key);
 668 }
 669
 670 void dns_scope_process_query(DnsScope *s, DnsStream *stream, DnsPacket *p) {
 671         _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL, *soa = NULL;
 672         _cleanup_(dns_packet_unrefp) DnsPacket *reply = NULL;
 673         DnsResourceKey *key = NULL;
 674         bool tentative = false;
 675         int r;
 676
 677         assert(s);
 678         assert(p);
 679
 680         if (p->protocol != DNS_PROTOCOL_LLMNR)
 681                 return;
 682
 683         if (p->ipproto == IPPROTO_UDP) {
 684                 /* Don't accept UDP queries directed to anything but
 685                  * the LLMNR multicast addresses. See RFC 4795,
 686                  * section 2.5. */
 687
 688                 if (p->family == AF_INET && !in_addr_equal(AF_INET, &p->destination, (union in_addr_union*) &LLMNR_MULTICAST_IPV4_ADDRESS))
 689                         return;
 690
 691                 if (p->family == AF_INET6 && !in_addr_equal(AF_INET6, &p->destination, (union in_addr_union*) &LLMNR_MULTICAST_IPV6_ADDRESS))
 692                         return;
 693         }
 694
 695         r = dns_packet_extract(p);
 696         if (r < 0) {
 697                 log_debug_errno(r, "Failed to extract resource records from incoming packet: %m");
 698                 return;
 699         }
 700
 701         if (DNS_PACKET_LLMNR_C(p)) {
 702                 /* Somebody notified us about a possible conflict */
 703                 dns_scope_verify_conflicts(s, p);
 704                 return;
 705         }
 706
 707         assert(dns_question_size(p->question) == 1);
 708         key = p->question->keys[0];
 709
 710         r = dns_zone_lookup(&s->zone, key, 0, &answer, &soa, &tentative);
 711         if (r < 0) {
 712                 log_debug_errno(r, "Failed to lookup key: %m");
 713                 return;
 714         }
 715         if (r == 0)
 716                 return;
 717
 718         if (answer)
 719                 dns_answer_order_by_scope(answer, in_addr_is_link_local(p->family, &p->sender) > 0);
 720
 721         r = dns_scope_make_reply_packet(s, DNS_PACKET_ID(p), DNS_RCODE_SUCCESS, p->question, answer, soa, tentative, &reply);
 722         if (r < 0) {
 723                 log_debug_errno(r, "Failed to build reply packet: %m");
 724                 return;
 725         }
 726
 727         if (stream) {
 728                 r = dns_stream_write_packet(stream, reply);
 729                 if (r < 0) {
 730                         log_debug_errno(r, "Failed to enqueue reply packet: %m");
 731                         return;
 732                 }
 733
 734                 /* Let's take an extra reference on this stream, so that it stays around after returning. The reference
 735                  * will be dangling until the stream is disconnected, and the default completion handler of the stream
 736                  * will then unref the stream and destroy it */
 737                 if (DNS_STREAM_QUEUED(stream))
 738                         dns_stream_ref(stream);
 739         } else {
 740                 int fd;
 741
 742                 if (!ratelimit_test(&s->ratelimit))
 743                         return;
 744
 745                 if (p->family == AF_INET)
 746                         fd = manager_llmnr_ipv4_udp_fd(s->manager);
 747                 else if (p->family == AF_INET6)
 748                         fd = manager_llmnr_ipv6_udp_fd(s->manager);
 749                 else {
 750                         log_debug("Unknown protocol");
 751                         return;
 752                 }
 753                 if (fd < 0) {
 754                         log_debug_errno(fd, "Failed to get reply socket: %m");
 755                         return;
 756                 }
 757
 758                 /* Note that we always immediately reply to all LLMNR
 759                  * requests, and do not wait any time, since we
 760                  * verified uniqueness for all records. Also see RFC
 761                  * 4795, Section 2.7 */
 762
 763                 r = manager_send(s->manager, fd, p->ifindex, p->family, &p->sender, p->sender_port, NULL, reply);
 764                 if (r < 0) {
 765                         log_debug_errno(r, "Failed to send reply packet: %m");
 766                         return;
 767                 }
 768         }
 769 }
 770
 771 DnsTransaction *dns_scope_find_transaction(DnsScope *scope, DnsResourceKey *key, bool cache_ok) {
 772         DnsTransaction *t;
 773
 774         assert(scope);
 775         assert(key);
 776
 777         /* Try to find an ongoing transaction that is a equal to the
 778          * specified question */
 779         t = hashmap_get(scope->transactions_by_key, key);
 780         if (!t)
 781                 return NULL;
 782
 783         /* Refuse reusing transactions that completed based on cached
 784          * data instead of a real packet, if that's requested. */
 785         if (!cache_ok &&
 786             IN_SET(t->state, DNS_TRANSACTION_SUCCESS, DNS_TRANSACTION_RCODE_FAILURE) &&
 787             t->answer_source != DNS_TRANSACTION_NETWORK)
 788                 return NULL;
 789
 790         return t;
 791 }
 792
 793 static int dns_scope_make_conflict_packet(
 794                 DnsScope *s,
 795                 DnsResourceRecord *rr,
 796                 DnsPacket **ret) {
 797
 798         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 799         int r;
 800
 801         assert(s);
 802         assert(rr);
 803         assert(ret);
 804
 805         r = dns_packet_new(&p, s->protocol, 0);
 806         if (r < 0)
 807                 return r;
 808
 809         DNS_PACKET_HEADER(p)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(
 810                                                               0 /* qr */,
 811                                                               0 /* opcode */,
 812                                                               1 /* conflict */,
 813                                                               0 /* tc */,
 814                                                               0 /* t */,
 815                                                               0 /* (ra) */,
 816                                                               0 /* (ad) */,
 817                                                               0 /* (cd) */,
 818                                                               0));
 819
 820         /* For mDNS, the transaction ID should always be 0 */
 821         if (s->protocol != DNS_PROTOCOL_MDNS)
 822                 random_bytes(&DNS_PACKET_HEADER(p)->id, sizeof(uint16_t));
 823
 824         DNS_PACKET_HEADER(p)->qdcount = htobe16(1);
 825         DNS_PACKET_HEADER(p)->arcount = htobe16(1);
 826
 827         r = dns_packet_append_key(p, rr->key, NULL);
 828         if (r < 0)
 829                 return r;
 830
 831         r = dns_packet_append_rr(p, rr, NULL, NULL);
 832         if (r < 0)
 833                 return r;
 834
 835         *ret = p;
 836         p = NULL;
 837
 838         return 0;
 839 }
 840
 841 static int on_conflict_dispatch(sd_event_source *es, usec_t usec, void *userdata) {
 842         DnsScope *scope = userdata;
 843         int r;
 844
 845         assert(es);
 846         assert(scope);
 847
 848         scope->conflict_event_source = sd_event_source_unref(scope->conflict_event_source);
 849
 850         for (;;) {
 851                 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
 852                 _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 853
 854                 rr = ordered_hashmap_steal_first(scope->conflict_queue);
 855                 if (!rr)
 856                         break;
 857
 858                 r = dns_scope_make_conflict_packet(scope, rr, &p);
 859                 if (r < 0) {
 860                         log_error_errno(r, "Failed to make conflict packet: %m");
 861                         return 0;
 862                 }
 863
 864                 r = dns_scope_emit_udp(scope, -1, p);
 865                 if (r < 0)
 866                         log_debug_errno(r, "Failed to send conflict packet: %m");
 867         }
 868
 869         return 0;
 870 }
 871
 872 int dns_scope_notify_conflict(DnsScope *scope, DnsResourceRecord *rr) {
 873         usec_t jitter;
 874         int r;
 875
 876         assert(scope);
 877         assert(rr);
 878
 879         /* We don't send these queries immediately. Instead, we queue
 880          * them, and send them after some jitter delay. */
 881         r = ordered_hashmap_ensure_allocated(&scope->conflict_queue, &dns_resource_key_hash_ops);
 882         if (r < 0) {
 883                 log_oom();
 884                 return r;
 885         }
 886
 887         /* We only place one RR per key in the conflict
 888          * messages, not all of them. That should be enough to
 889          * indicate where there might be a conflict */
 890         r = ordered_hashmap_put(scope->conflict_queue, rr->key, rr);
 891         if (r == -EEXIST || r == 0)
 892                 return 0;
 893         if (r < 0)
 894                 return log_debug_errno(r, "Failed to queue conflicting RR: %m");
 895
 896         dns_resource_record_ref(rr);
 897
 898         if (scope->conflict_event_source)
 899                 return 0;
 900
 901         random_bytes(&jitter, sizeof(jitter));
 902         jitter %= LLMNR_JITTER_INTERVAL_USEC;
 903
 904         r = sd_event_add_time(scope->manager->event,
 905                               &scope->conflict_event_source,
 906                               clock_boottime_or_monotonic(),
 907                               now(clock_boottime_or_monotonic()) + jitter,
 908                               LLMNR_JITTER_INTERVAL_USEC,
 909                               on_conflict_dispatch, scope);
 910         if (r < 0)
 911                 return log_debug_errno(r, "Failed to add conflict dispatch event: %m");
 912
 913         (void) sd_event_source_set_description(scope->conflict_event_source, "scope-conflict");
 914
 915         return 0;
 916 }
 917
 918 void dns_scope_check_conflicts(DnsScope *scope, DnsPacket *p) {
 919         unsigned i;
 920         int r;
 921
 922         assert(scope);
 923         assert(p);
 924
 925         if (p->protocol != DNS_PROTOCOL_LLMNR)
 926                 return;
 927
 928         if (DNS_PACKET_RRCOUNT(p) <= 0)
 929                 return;
 930
 931         if (DNS_PACKET_LLMNR_C(p) != 0)
 932                 return;
 933
 934         if (DNS_PACKET_LLMNR_T(p) != 0)
 935                 return;
 936
 937         if (manager_our_packet(scope->manager, p))
 938                 return;
 939
 940         r = dns_packet_extract(p);
 941         if (r < 0) {
 942                 log_debug_errno(r, "Failed to extract packet: %m");
 943                 return;
 944         }
 945
 946         log_debug("Checking for conflicts...");
 947
 948         for (i = 0; i < p->answer->n_rrs; i++) {
 949
 950                 /* Check for conflicts against the local zone. If we
 951                  * found one, we won't check any further */
 952                 r = dns_zone_check_conflicts(&scope->zone, p->answer->items[i].rr);
 953                 if (r != 0)
 954                         continue;
 955
 956                 /* Check for conflicts against the local cache. If so,
 957                  * send out an advisory query, to inform everybody */
 958                 r = dns_cache_check_conflicts(&scope->cache, p->answer->items[i].rr, p->family, &p->sender);
 959                 if (r <= 0)
 960                         continue;
 961
 962                 dns_scope_notify_conflict(scope, p->answer->items[i].rr);
 963         }
 964 }
 965
 966 void dns_scope_dump(DnsScope *s, FILE *f) {
 967         assert(s);
 968
 969         if (!f)
 970                 f = stdout;
 971
 972         fputs("[Scope protocol=", f);
 973         fputs(dns_protocol_to_string(s->protocol), f);
 974
 975         if (s->link) {
 976                 fputs(" interface=", f);
 977                 fputs(s->link->name, f);
 978         }
 979
 980         if (s->family != AF_UNSPEC) {
 981                 fputs(" family=", f);
 982                 fputs(af_to_name(s->family), f);
 983         }
 984
 985         fputs("]\n", f);
 986
 987         if (!dns_zone_is_empty(&s->zone)) {
 988                 fputs("ZONE:\n", f);
 989                 dns_zone_dump(&s->zone, f);
 990         }
 991
 992         if (!dns_cache_is_empty(&s->cache)) {
 993                 fputs("CACHE:\n", f);
 994                 dns_cache_dump(&s->cache, f);
 995         }
 996 }
 997
 998 DnsSearchDomain *dns_scope_get_search_domains(DnsScope *s) {
 999         assert(s);
1000
1001         if (s->protocol != DNS_PROTOCOL_DNS)
1002                 return NULL;
1003
1004         if (s->link)
1005                 return s->link->search_domains;
1006
1007         return s->manager->search_domains;
1008 }
1009
1010 bool dns_scope_name_needs_search_domain(DnsScope *s, const char *name) {
1011         assert(s);
1012
1013         if (s->protocol != DNS_PROTOCOL_DNS)
1014                 return false;
1015
1016         return dns_name_is_single_label(name);
1017 }
1018
1019 bool dns_scope_network_good(DnsScope *s) {
1020         /* Checks whether the network is in good state for lookups on this scope. For mDNS/LLMNR/Classic DNS scopes
1021          * bound to links this is easy, as they don't even exist if the link isn't in a suitable state. For the global
1022          * DNS scope we check whether there are any links that are up and have an address. */
1023
1024         if (s->link)
1025                 return true;
1026
1027         return manager_routable(s->manager, AF_UNSPEC);
1028 }
1029
1030 int dns_scope_ifindex(DnsScope *s) {
1031         assert(s);
1032
1033         if (s->link)
1034                 return s->link->ifindex;
1035
1036         return 0;
1037 }