X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fresolve%2Fresolved-dns-query.c;h=85702515285f1325b86b2acf1b804f10eb81ef0b;hb=d2f47562d5d834339ef3030e345a76a8c6f09c74;hp=6e04324da5d9f8b319b139e4e13013dd3b8afe45;hpb=8ba9fd9cee0eef572f7b3ed7a8c3ed31160e93d3;p=elogind.git

diff --git a/src/resolve/resolved-dns-query.c b/src/resolve/resolved-dns-query.c
index 6e04324da..857025152 100644
--- a/src/resolve/resolved-dns-query.c
+++ b/src/resolve/resolved-dns-query.c
@@ -19,6 +19,8 @@
   along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/
 
+#include "af-list.h"
+
 #include "resolved-dns-query.h"
 #include "resolved-dns-domain.h"
 
@@ -26,28 +28,36 @@
 #define QUERY_TIMEOUT_USEC (30 * USEC_PER_SEC)
 #define ATTEMPTS_MAX 8
 #define CNAME_MAX 8
+#define QUERIES_MAX 2048
 
-static int dns_query_transaction_start(DnsQueryTransaction *t);
+static int dns_query_transaction_go(DnsQueryTransaction *t);
 
 DnsQueryTransaction* dns_query_transaction_free(DnsQueryTransaction *t) {
+        DnsQuery *q;
+
         if (!t)
                 return NULL;
 
         sd_event_source_unref(t->timeout_event_source);
 
+        dns_question_unref(t->question);
         dns_packet_unref(t->sent);
         dns_packet_unref(t->received);
+        dns_answer_unref(t->cached);
 
-        sd_event_source_unref(t->tcp_event_source);
-        safe_close(t->tcp_fd);
+        dns_stream_free(t->stream);
+
+        if (t->scope) {
+                LIST_REMOVE(transactions_by_scope, t->scope->transactions, t);
 
-        if (t->query) {
-                LIST_REMOVE(transactions_by_query, t->query->transactions, t);
-                hashmap_remove(t->query->manager->dns_query_transactions, UINT_TO_PTR(t->id));
+                if (t->id != 0)
+                        hashmap_remove(t->scope->manager->dns_query_transactions, UINT_TO_PTR(t->id));
         }
 
-        if (t->scope)
-                LIST_REMOVE(transactions_by_scope, t->scope->transactions, t);
+        while ((q = set_steal_first(t->queries)))
+                set_remove(q->transactions, t);
+
+        set_free(t->queries);
 
         free(t);
         return NULL;
@@ -55,14 +65,25 @@ DnsQueryTransaction* dns_query_transaction_free(DnsQueryTransaction *t) {
 
 DEFINE_TRIVIAL_CLEANUP_FUNC(DnsQueryTransaction*, dns_query_transaction_free);
 
-static int dns_query_transaction_new(DnsQuery *q, DnsQueryTransaction **ret, DnsScope *s) {
+static void dns_query_transaction_gc(DnsQueryTransaction *t) {
+        assert(t);
+
+        if (t->block_gc > 0)
+                return;
+
+        if (set_isempty(t->queries))
+                dns_query_transaction_free(t);
+}
+
+static int dns_query_transaction_new(DnsQueryTransaction **ret, DnsScope *s, DnsQuestion *q) {
         _cleanup_(dns_query_transaction_freep) DnsQueryTransaction *t = NULL;
         int r;
 
-        assert(q);
+        assert(ret);
         assert(s);
+        assert(q);
 
-        r = hashmap_ensure_allocated(&q->manager->dns_query_transactions, NULL, NULL);
+        r = hashmap_ensure_allocated(&s->manager->dns_query_transactions, NULL, NULL);
         if (r < 0)
                 return r;
 
@@ -70,22 +91,19 @@ static int dns_query_transaction_new(DnsQuery *q, DnsQueryTransaction **ret, Dns
         if (!t)
                 return -ENOMEM;
 
-        t->tcp_fd = -1;
+        t->question = dns_question_ref(q);
 
         do
                 random_bytes(&t->id, sizeof(t->id));
         while (t->id == 0 ||
-               hashmap_get(q->manager->dns_query_transactions, UINT_TO_PTR(t->id)));
+               hashmap_get(s->manager->dns_query_transactions, UINT_TO_PTR(t->id)));
 
-        r = hashmap_put(q->manager->dns_query_transactions, UINT_TO_PTR(t->id), t);
+        r = hashmap_put(s->manager->dns_query_transactions, UINT_TO_PTR(t->id), t);
         if (r < 0) {
                 t->id = 0;
                 return r;
         }
 
-        LIST_PREPEND(transactions_by_query, q->transactions, t);
-        t->query = q;
-
         LIST_PREPEND(transactions_by_scope, s->transactions, t);
         t->scope = s;
 
@@ -101,193 +119,217 @@ static void dns_query_transaction_stop(DnsQueryTransaction *t) {
         assert(t);
 
         t->timeout_event_source = sd_event_source_unref(t->timeout_event_source);
-        t->tcp_event_source = sd_event_source_unref(t->tcp_event_source);
-        t->tcp_fd = safe_close(t->tcp_fd);
+        t->stream = dns_stream_free(t->stream);
 }
 
-static void dns_query_transaction_set_state(DnsQueryTransaction *t, DnsQueryState state) {
+void dns_query_transaction_complete(DnsQueryTransaction *t, DnsQueryState state) {
+        DnsQuery *q;
+        Iterator i;
+
         assert(t);
+        assert(!IN_SET(state, DNS_QUERY_NULL, DNS_QUERY_PENDING));
+        assert(IN_SET(t->state, DNS_QUERY_NULL, DNS_QUERY_PENDING));
 
-        if (t->state == state)
-                return;
+        /* Note that this call might invalidate the query. Callers
+         * should hence not attempt to access the query or transaction
+         * after calling this function. */
+
+        log_debug("Transaction on scope %s on %s/%s now complete with %s",
+                  dns_protocol_to_string(t->scope->protocol),
+                  t->scope->link ? t->scope->link->name : "*",
+                  t->scope->family == AF_UNSPEC ? "*" : af_to_name(t->scope->family),
+                  dns_query_state_to_string(state));
 
         t->state = state;
 
-        if (state != DNS_QUERY_PENDING) {
-                dns_query_transaction_stop(t);
-                dns_query_finish(t->query);
-        }
+        dns_query_transaction_stop(t);
+
+        /* Notify all queries that are interested, but make sure the
+         * transaction isn't freed while we are still looking at it */
+        t->block_gc++;
+        SET_FOREACH(q, t->queries, i)
+                dns_query_ready(q);
+        t->block_gc--;
+
+        dns_query_transaction_gc(t);
 }
 
-static int on_tcp_ready(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
-        DnsQueryTransaction *t = userdata;
-        int r;
+static int on_stream_complete(DnsStream *s, int error) {
+        _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
+        DnsQueryTransaction *t;
 
-        assert(t);
+        assert(s);
+        assert(s->transaction);
 
-        if (revents & EPOLLOUT) {
-                struct iovec iov[2];
-                be16_t sz;
-                ssize_t ss;
+        /* Copy the data we care about out of the stream before we
+         * destroy it. */
+        t = s->transaction;
+        p = dns_packet_ref(s->read_packet);
 
-                sz = htobe16(t->sent->size);
+        t->stream = dns_stream_free(t->stream);
 
-                iov[0].iov_base = &sz;
-                iov[0].iov_len = sizeof(sz);
-                iov[1].iov_base = DNS_PACKET_DATA(t->sent);
-                iov[1].iov_len = t->sent->size;
+        if (error != 0) {
+                dns_query_transaction_complete(t, DNS_QUERY_RESOURCES);
+                return 0;
+        }
 
-                IOVEC_INCREMENT(iov, 2, t->tcp_written);
+        t->block_gc++;
+        dns_query_transaction_process_reply(t, p);
+        t->block_gc--;
 
-                ss = writev(fd, iov, 2);
-                if (ss < 0) {
-                        if (errno != EINTR && errno != EAGAIN) {
-                                dns_query_transaction_set_state(t, DNS_QUERY_RESOURCES);
-                                return -errno;
-                        }
-                } else
-                        t->tcp_written += ss;
+        /* If the response wasn't useful, then complete the transition now */
+        if (t->state == DNS_QUERY_PENDING)
+                dns_query_transaction_complete(t, DNS_QUERY_INVALID_REPLY);
 
-                /* Are we done? If so, disable the event source for EPOLLOUT */
-                if (t->tcp_written >= sizeof(sz) + t->sent->size) {
-                        r = sd_event_source_set_io_events(s, EPOLLIN);
-                        if (r < 0) {
-                                dns_query_transaction_set_state(t, DNS_QUERY_RESOURCES);
-                                return r;
-                        }
-                }
-        }
+        return 0;
+}
 
-        if (revents & (EPOLLIN|EPOLLHUP|EPOLLRDHUP)) {
+static int dns_query_transaction_open_tcp(DnsQueryTransaction *t) {
+        _cleanup_close_ int fd = -1;
+        int r;
 
-                if (t->tcp_read < sizeof(t->tcp_read_size)) {
-                        ssize_t ss;
+        assert(t);
 
-                        ss = read(fd, (uint8_t*) &t->tcp_read_size + t->tcp_read, sizeof(t->tcp_read_size) - t->tcp_read);
-                        if (ss < 0) {
-                                if (errno != EINTR && errno != EAGAIN) {
-                                        dns_query_transaction_set_state(t, DNS_QUERY_RESOURCES);
-                                        return -errno;
-                                }
-                        } else if (ss == 0) {
-                                dns_query_transaction_set_state(t, DNS_QUERY_RESOURCES);
-                                return -EIO;
-                        } else
-                                t->tcp_read += ss;
-                }
+        if (t->stream)
+                return 0;
 
-                if (t->tcp_read >= sizeof(t->tcp_read_size)) {
+        if (t->scope->protocol == DNS_PROTOCOL_DNS)
+                fd = dns_scope_tcp_socket(t->scope, AF_UNSPEC, NULL, 53);
+        else if (t->scope->protocol == DNS_PROTOCOL_LLMNR) {
+
+                /* When we already received a query to this (but it was truncated), send to its sender address */
+                if (t->received)
+                        fd = dns_scope_tcp_socket(t->scope, t->received->family, &t->received->sender, t->received->sender_port);
+                else {
+                        union in_addr_union address;
+                        int family;
+
+                        /* Otherwise, try to talk to the owner of a
+                         * the IP address, in case this is a reverse
+                         * PTR lookup */
+                        r = dns_question_extract_reverse_address(t->question, &family, &address);
+                        if (r < 0)
+                                return r;
+                        if (r == 0)
+                                return -EINVAL;
 
-                        if (be16toh(t->tcp_read_size) < DNS_PACKET_HEADER_SIZE) {
-                                dns_query_transaction_set_state(t, DNS_QUERY_INVALID_REPLY);
-                                return -EBADMSG;
-                        }
+                        fd = dns_scope_tcp_socket(t->scope, family, &address, 5355);
+                }
+        } else
+                return -EAFNOSUPPORT;
 
-                        if (t->tcp_read < sizeof(t->tcp_read_size) + be16toh(t->tcp_read_size)) {
-                                ssize_t ss;
+        if (fd < 0)
+                return fd;
 
-                                if (!t->received) {
-                                        r = dns_packet_new(&t->received, be16toh(t->tcp_read_size));
-                                        if (r < 0) {
-                                                dns_query_transaction_set_state(t, DNS_QUERY_RESOURCES);
-                                                return r;
-                                        }
-                                }
+        r = dns_stream_new(t->scope->manager, &t->stream, t->scope->protocol, fd);
+        if (r < 0)
+                return r;
 
-                                ss = read(fd,
-                                          (uint8_t*) DNS_PACKET_DATA(t->received) + t->tcp_read - sizeof(t->tcp_read_size),
-                                          sizeof(t->tcp_read_size) + be16toh(t->tcp_read_size) - t->tcp_read);
-                                if (ss < 0) {
-                                        if (errno != EINTR && errno != EAGAIN) {
-                                                dns_query_transaction_set_state(t, DNS_QUERY_RESOURCES);
-                                                return -errno;
-                                        }
-                                } else if (ss == 0) {
-                                        dns_query_transaction_set_state(t, DNS_QUERY_RESOURCES);
-                                        return -EIO;
-                                }  else
-                                        t->tcp_read += ss;
-                        }
+        fd = -1;
 
-                        if (t->tcp_read >= sizeof(t->tcp_read_size) + be16toh(t->tcp_read_size)) {
-                                t->received->size = be16toh(t->tcp_read_size);
-                                dns_query_transaction_reply(t, t->received);
-                                return 0;
-                        }
-                }
+        r = dns_stream_write_packet(t->stream, t->sent);
+        if (r < 0) {
+                t->stream = dns_stream_free(t->stream);
+                return r;
         }
 
+        t->received = dns_packet_unref(t->received);
+        t->stream->complete = on_stream_complete;
+        t->stream->transaction = t;
+
+        /* The interface index is difficult to determine if we are
+         * connecting to the local host, hence fill this in right away
+         * instead of determining it from the socket */
+        if (t->scope->link)
+                t->stream->ifindex = t->scope->link->ifindex;
+
         return 0;
 }
 
-static int dns_query_transaction_start_tcp(DnsQueryTransaction *t) {
+void dns_query_transaction_process_reply(DnsQueryTransaction *t, DnsPacket *p) {
         int r;
 
         assert(t);
+        assert(p);
+        assert(t->state == DNS_QUERY_PENDING);
 
-        if (t->tcp_fd >= 0)
-                return 0;
+        /* Note that this call might invalidate the query. Callers
+         * should hence not attempt to access the query or transaction
+         * after calling this function. */
 
-        t->tcp_written = 0;
-        t->tcp_read = 0;
-        t->received = dns_packet_unref(t->received);
+        if (t->scope->protocol == DNS_PROTOCOL_LLMNR) {
+                assert(t->scope->link);
 
-        t->tcp_fd = dns_scope_tcp_socket(t->scope);
-        if (t->tcp_fd < 0)
-                return t->tcp_fd;
+                /* For LLMNR we will not accept any packets from other
+                 * interfaces */
 
-        r = sd_event_add_io(t->query->manager->event, &t->tcp_event_source, t->tcp_fd, EPOLLIN|EPOLLOUT, on_tcp_ready, t);
-        if (r < 0) {
-                t->tcp_fd = safe_close(t->tcp_fd);
-                return r;
+                if (p->ifindex != t->scope->link->ifindex)
+                        return;
+
+                if (p->family != t->scope->family)
+                        return;
+
+                /* Tentative replies shall be discarded, see RFC 4795,
+                 * 2.1.1 */
+
+                if (DNS_PACKET_T(p))
+                        return;
         }
 
-        return 0;
-}
+        if (t->scope->protocol == DNS_PROTOCOL_DNS) {
 
-void dns_query_transaction_reply(DnsQueryTransaction *t, DnsPacket *p) {
-        int r;
+                /* For DNS we are fine with accepting packets on any
+                 * interface, but the source IP address must be one of
+                 * a valid DNS server */
 
-        assert(t);
-        assert(p);
+                if (!dns_scope_good_dns_server(t->scope, p->family, &p->sender))
+                        return;
 
-        if (t->state != DNS_QUERY_PENDING)
-                return;
+                if (p->sender_port != 53)
+                        return;
+        }
 
         if (t->received != p) {
                 dns_packet_unref(t->received);
                 t->received = dns_packet_ref(p);
         }
 
-        if (t->tcp_fd >= 0) {
+        if (p->ipproto == IPPROTO_TCP) {
                 if (DNS_PACKET_TC(p)) {
                         /* Truncated via TCP? Somebody must be fucking with us */
-                        dns_query_transaction_set_state(t, DNS_QUERY_INVALID_REPLY);
+                        dns_query_transaction_complete(t, DNS_QUERY_INVALID_REPLY);
                         return;
                 }
 
                 if (DNS_PACKET_ID(p) != t->id) {
                         /* Not the reply to our query? Somebody must be fucking with us */
-                        dns_query_transaction_set_state(t, DNS_QUERY_INVALID_REPLY);
+                        dns_query_transaction_complete(t, DNS_QUERY_INVALID_REPLY);
                         return;
                 }
         }
 
         if (DNS_PACKET_TC(p)) {
                 /* Response was truncated, let's try again with good old TCP */
-                r = dns_query_transaction_start_tcp(t);
+                r = dns_query_transaction_open_tcp(t);
                 if (r == -ESRCH) {
                         /* No servers found? Damn! */
-                        dns_query_transaction_set_state(t, DNS_QUERY_NO_SERVERS);
+                        dns_query_transaction_complete(t, DNS_QUERY_NO_SERVERS);
                         return;
                 }
                 if (r < 0) {
-                        /* Couldn't send? Try immediately again, with a new server */
+                        /* On LLMNR, if we cannot connect to the host,
+                         * we immediately give up */
+                        if (t->scope->protocol == DNS_PROTOCOL_LLMNR) {
+                                dns_query_transaction_complete(t, DNS_QUERY_RESOURCES);
+                                return;
+                        }
+
+                        /* On DNS, couldn't send? Try immediately again, with a new server */
                         dns_scope_next_dns_server(t->scope);
 
-                        r = dns_query_transaction_start(t);
+                        r = dns_query_transaction_go(t);
                         if (r < 0) {
-                                dns_query_transaction_set_state(t, DNS_QUERY_RESOURCES);
+                                dns_query_transaction_complete(t, DNS_QUERY_RESOURCES);
                                 return;
                         }
 
@@ -295,10 +337,20 @@ void dns_query_transaction_reply(DnsQueryTransaction *t, DnsPacket *p) {
                 }
         }
 
+        /* Parse and update the cache */
+        r = dns_packet_extract(p);
+        if (r < 0) {
+                dns_query_transaction_complete(t, DNS_QUERY_INVALID_REPLY);
+                return;
+        }
+
+        /* According to RFC 4795, section 2.9. only the RRs from the answer section shall be cached */
+        dns_cache_put(&t->scope->cache, p->question, DNS_PACKET_RCODE(p), p->answer, DNS_PACKET_ANCOUNT(p), 0);
+
         if (DNS_PACKET_RCODE(p) == DNS_RCODE_SUCCESS)
-                dns_query_transaction_set_state(t, DNS_QUERY_SUCCESS);
+                dns_query_transaction_complete(t, DNS_QUERY_SUCCESS);
         else
-                dns_query_transaction_set_state(t, DNS_QUERY_FAILURE);
+                dns_query_transaction_complete(t, DNS_QUERY_FAILURE);
 }
 
 static int on_transaction_timeout(sd_event_source *s, usec_t usec, void *userdata) {
@@ -311,16 +363,16 @@ static int on_transaction_timeout(sd_event_source *s, usec_t usec, void *userdat
         /* Timeout reached? Try again, with a new server */
         dns_scope_next_dns_server(t->scope);
 
-        r = dns_query_transaction_start(t);
+        r = dns_query_transaction_go(t);
         if (r < 0)
-                dns_query_transaction_set_state(t, DNS_QUERY_RESOURCES);
+                dns_query_transaction_complete(t, DNS_QUERY_RESOURCES);
 
         return 0;
 }
 
 static int dns_query_make_packet(DnsQueryTransaction *t) {
         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
-        unsigned n;
+        unsigned n, added = 0;
         int r;
 
         assert(t);
@@ -328,17 +380,28 @@ static int dns_query_make_packet(DnsQueryTransaction *t) {
         if (t->sent)
                 return 0;
 
-        r = dns_packet_new_query(&p, 0);
+        r = dns_packet_new_query(&p, t->scope->protocol, 0);
         if (r < 0)
                 return r;
 
-        for (n = 0; n < t->query->n_keys; n++) {
-                r = dns_packet_append_key(p, &t->query->keys[n], NULL);
+        for (n = 0; n < t->question->n_keys; n++) {
+                r = dns_scope_good_key(t->scope, t->question->keys[n]);
                 if (r < 0)
                         return r;
+                if (r == 0)
+                        continue;
+
+                r = dns_packet_append_key(p, t->question->keys[n], NULL);
+                if (r < 0)
+                        return r;
+
+                added++;
         }
 
-        DNS_PACKET_HEADER(p)->qdcount = htobe16(t->query->n_keys);
+        if (added <= 0)
+                return -EDOM;
+
+        DNS_PACKET_HEADER(p)->qdcount = htobe16(added);
         DNS_PACKET_HEADER(p)->id = t->id;
 
         t->sent = p;
@@ -347,106 +410,146 @@ static int dns_query_make_packet(DnsQueryTransaction *t) {
         return 0;
 }
 
-static int dns_query_transaction_start(DnsQueryTransaction *t) {
+static int dns_query_transaction_go(DnsQueryTransaction *t) {
         int r;
 
         assert(t);
 
         dns_query_transaction_stop(t);
 
+        log_debug("Beginning transaction on scope %s on %s/%s",
+                  dns_protocol_to_string(t->scope->protocol),
+                  t->scope->link ? t->scope->link->name : "*",
+                  t->scope->family == AF_UNSPEC ? "*" : af_to_name(t->scope->family));
+
         if (t->n_attempts >= ATTEMPTS_MAX) {
-                dns_query_transaction_set_state(t, DNS_QUERY_ATTEMPTS_MAX);
+                dns_query_transaction_complete(t, DNS_QUERY_ATTEMPTS_MAX);
                 return 0;
         }
 
-        r = dns_query_make_packet(t);
-        if (r < 0)
-                return r;
-
         t->n_attempts++;
         t->received = dns_packet_unref(t->received);
+        t->cached = dns_answer_unref(t->cached);
+        t->cached_rcode = 0;
 
-        /* Try via UDP, and if that fails due to large size try via TCP */
-        r = dns_scope_send(t->scope, t->sent);
-        if (r == -EMSGSIZE)
-                r = dns_query_transaction_start_tcp(t);
+        /* First, let's try the cache */
+        dns_cache_prune(&t->scope->cache);
+        r = dns_cache_lookup(&t->scope->cache, t->question, &t->cached_rcode, &t->cached);
+        if (r < 0)
+                return r;
+        if (r > 0) {
+                if (t->cached_rcode == DNS_RCODE_SUCCESS)
+                        dns_query_transaction_complete(t, DNS_QUERY_SUCCESS);
+                else
+                        dns_query_transaction_complete(t, DNS_QUERY_FAILURE);
+                return 0;
+        }
 
+        /* Otherwise, we need to ask the network */
+        r = dns_query_make_packet(t);
+        if (r == -EDOM) {
+                /* Not the right request to make on this network?
+                 * (i.e. an A request made on IPv6 or an AAAA request
+                 * made on IPv4, on LLMNR or mDNS.) */
+                dns_query_transaction_complete(t, DNS_QUERY_NO_SERVERS);
+                return 0;
+        }
+        if (r < 0)
+                return r;
+
+        if (t->scope->protocol == DNS_PROTOCOL_LLMNR &&
+            (dns_question_endswith(t->question, "in-addr.arpa") > 0 ||
+             dns_question_endswith(t->question, "ip6.arpa") > 0)) {
+
+                /* RFC 4795, Section 2.4. says reverse lookups shall
+                 * always be made via TCP on LLMNR */
+                r = dns_query_transaction_open_tcp(t);
+        } else {
+                /* Try via UDP, and if that fails due to large size try via TCP */
+                r = dns_scope_send(t->scope, t->sent);
+                if (r == -EMSGSIZE)
+                        r = dns_query_transaction_open_tcp(t);
+        }
         if (r == -ESRCH) {
-                dns_query_transaction_set_state(t, DNS_QUERY_NO_SERVERS);
+                /* No servers to send this to? */
+                dns_query_transaction_complete(t, DNS_QUERY_NO_SERVERS);
                 return 0;
         }
         if (r < 0) {
                 /* Couldn't send? Try immediately again, with a new server */
                 dns_scope_next_dns_server(t->scope);
 
-                return dns_query_transaction_start(t);
+                return dns_query_transaction_go(t);
         }
 
-        r = sd_event_add_time(t->query->manager->event, &t->timeout_event_source, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + TRANSACTION_TIMEOUT_USEC, 0, on_transaction_timeout, t);
+        r = sd_event_add_time(t->scope->manager->event, &t->timeout_event_source, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + TRANSACTION_TIMEOUT_USEC, 0, on_transaction_timeout, t);
         if (r < 0)
                 return r;
 
-        dns_query_transaction_set_state(t, DNS_QUERY_PENDING);
+        t->state = DNS_QUERY_PENDING;
         return 1;
 }
 
 DnsQuery *dns_query_free(DnsQuery *q) {
-        unsigned n;
+        DnsQueryTransaction *t;
 
         if (!q)
                 return NULL;
 
         sd_bus_message_unref(q->request);
-        dns_packet_unref(q->received);
+
+        dns_question_unref(q->question);
+        dns_answer_unref(q->answer);
+
         sd_event_source_unref(q->timeout_event_source);
 
-        while (q->transactions)
-                dns_query_transaction_free(q->transactions);
+        while ((t = set_steal_first(q->transactions))) {
+                set_remove(t->queries, q);
+                dns_query_transaction_gc(t);
+        }
+
+        set_free(q->transactions);
 
-        if (q->manager)
+        if (q->manager) {
                 LIST_REMOVE(queries, q->manager->dns_queries, q);
+                q->manager->n_dns_queries--;
+        }
 
-        for (n = 0; n < q->n_keys; n++)
-                free(q->keys[n].name);
-        free(q->keys);
         free(q);
 
         return NULL;
 }
 
-int dns_query_new(Manager *m, DnsQuery **ret, DnsResourceKey *keys, unsigned n_keys) {
+int dns_query_new(Manager *m, DnsQuery **ret, DnsQuestion *question) {
         _cleanup_(dns_query_freep) DnsQuery *q = NULL;
-        const char *name = NULL;
+        unsigned i;
+        int r;
 
         assert(m);
+        assert(question);
 
-        if (n_keys <= 0 || n_keys >= 65535)
-                return -EINVAL;
+        r = dns_question_is_valid(question);
+        if (r < 0)
+                return r;
 
-        assert(keys);
+        if (m->n_dns_queries >= QUERIES_MAX)
+                return -EBUSY;
 
         q = new0(DnsQuery, 1);
         if (!q)
                 return -ENOMEM;
 
-        q->keys = new(DnsResourceKey, n_keys);
-        if (!q->keys)
-                return -ENOMEM;
+        q->question = dns_question_ref(question);
 
-        for (q->n_keys = 0; q->n_keys < n_keys; q->n_keys++) {
-                q->keys[q->n_keys].class = keys[q->n_keys].class;
-                q->keys[q->n_keys].type = keys[q->n_keys].type;
-                q->keys[q->n_keys].name = strdup(keys[q->n_keys].name);
-                if (!q->keys[q->n_keys].name)
-                        return -ENOMEM;
-
-                if (!name)
-                        name = q->keys[q->n_keys].name;
-                else if (!dns_name_equal(name, q->keys[q->n_keys].name))
-                        return -EINVAL;
+        for (i = 0; i < question->n_keys; i++) {
+                log_debug("Looking up RR for %s %s %s",
+                          strna(dns_class_to_string(question->keys[i]->class)),
+                          strna(dns_type_to_string(question->keys[i]->type)),
+                          DNS_RESOURCE_KEY_NAME(question->keys[i]));
         }
 
         LIST_PREPEND(queries, m->dns_queries, q);
+        m->n_dns_queries++;
         q->manager = m;
 
         if (ret)
@@ -457,30 +560,32 @@ int dns_query_new(Manager *m, DnsQuery **ret, DnsResourceKey *keys, unsigned n_k
 }
 
 static void dns_query_stop(DnsQuery *q) {
+        DnsQueryTransaction *t;
+
         assert(q);
 
         q->timeout_event_source = sd_event_source_unref(q->timeout_event_source);
 
-        while (q->transactions)
-                dns_query_transaction_free(q->transactions);
+        while ((t = set_steal_first(q->transactions))) {
+                set_remove(t->queries, q);
+                dns_query_transaction_gc(t);
+        }
 }
 
-static void dns_query_set_state(DnsQuery *q, DnsQueryState state) {
-        DnsQueryState old_state;
+static void dns_query_complete(DnsQuery *q, DnsQueryState state) {
         assert(q);
+        assert(!IN_SET(state, DNS_QUERY_NULL, DNS_QUERY_PENDING));
+        assert(IN_SET(q->state, DNS_QUERY_NULL, DNS_QUERY_PENDING));
 
-        if (q->state == state)
-                return;
+        /* Note that this call might invalidate the query. Callers
+         * should hence not attempt to access the query or transaction
+         * after calling this function. */
 
-        old_state = q->state;
         q->state = state;
 
-        if (!IN_SET(state, DNS_QUERY_NULL, DNS_QUERY_PENDING)) {
-                dns_query_stop(q);
-
-                if (old_state == DNS_QUERY_PENDING && q->complete)
-                        q->complete(q);
-        }
+        dns_query_stop(q);
+        if (q->complete)
+                q->complete(q);
 }
 
 static int on_query_timeout(sd_event_source *s, usec_t usec, void *userdata) {
@@ -489,14 +594,96 @@ static int on_query_timeout(sd_event_source *s, usec_t usec, void *userdata) {
         assert(s);
         assert(q);
 
-        dns_query_set_state(q, DNS_QUERY_TIMEOUT);
+        dns_query_complete(q, DNS_QUERY_TIMEOUT);
         return 0;
 }
 
-int dns_query_start(DnsQuery *q) {
+static int dns_query_add_transaction(DnsQuery *q, DnsScope *s, DnsResourceKey *key) {
+        _cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
+        DnsQueryTransaction *t;
+        int r;
+
+        assert(q);
+
+        r = set_ensure_allocated(&q->transactions, NULL, NULL);
+        if (r < 0)
+                return r;
+
+        if (key) {
+                question = dns_question_new(1);
+                if (!question)
+                        return -ENOMEM;
+
+                r = dns_question_add(question, key);
+                if (r < 0)
+                        return r;
+        } else
+                question = dns_question_ref(q->question);
+
+        LIST_FOREACH(transactions_by_scope, t, s->transactions)
+                if (dns_question_is_superset(t->question, question))
+                        break;
+
+        if (!t) {
+                r = dns_query_transaction_new(&t, s, question);
+                if (r < 0)
+                        return r;
+        }
+
+        r = set_ensure_allocated(&t->queries, NULL, NULL);
+        if (r < 0)
+                goto fail;
+
+        r = set_put(t->queries, q);
+        if (r < 0)
+                goto fail;
+
+        r = set_put(q->transactions, t);
+        if (r < 0) {
+                set_remove(t->queries, q);
+                goto fail;
+        }
+
+        return 0;
+
+fail:
+        dns_query_transaction_gc(t);
+        return r;
+}
+
+static int dns_query_add_transaction_split(DnsQuery *q, DnsScope *s) {
+        int r;
+
+        assert(q);
+        assert(s);
+
+        if (s->protocol == DNS_PROTOCOL_MDNS) {
+                r = dns_query_add_transaction(q, s, NULL);
+                if (r < 0)
+                        return r;
+        } else {
+                unsigned i;
+
+                /* On DNS and LLMNR we can only send a single
+                 * question per datagram, hence issue multiple
+                 * transactions. */
+
+                for (i = 0; i < q->question->n_keys; i++) {
+                        r = dns_query_add_transaction(q, s, q->question->keys[i]);
+                        if (r < 0)
+                                return r;
+                }
+        }
+
+        return 0;
+}
+
+int dns_query_go(DnsQuery *q) {
         DnsScopeMatch found = DNS_SCOPE_NO;
         DnsScope *s, *first = NULL;
         DnsQueryTransaction *t;
+        const char *name;
+        Iterator i;
         int r;
 
         assert(q);
@@ -504,12 +691,15 @@ int dns_query_start(DnsQuery *q) {
         if (q->state != DNS_QUERY_NULL)
                 return 0;
 
-        assert(q->n_keys > 0);
+        assert(q->question);
+        assert(q->question->n_keys > 0);
+
+        name = DNS_RESOURCE_KEY_NAME(q->question->keys[0]);
 
         LIST_FOREACH(scopes, s, q->manager->dns_scopes) {
                 DnsScopeMatch match;
 
-                match = dns_scope_test(s, q->keys[0].name);
+                match = dns_scope_good_domain(s, name);
                 if (match < 0)
                         return match;
 
@@ -532,43 +722,47 @@ int dns_query_start(DnsQuery *q) {
         if (found == DNS_SCOPE_NO)
                 return -ESRCH;
 
-        r = dns_query_transaction_new(q, NULL, first);
+        r = dns_query_add_transaction_split(q, first);
         if (r < 0)
                 return r;
 
         LIST_FOREACH(scopes, s, first->scopes_next) {
                 DnsScopeMatch match;
 
-                match = dns_scope_test(s, q->keys[0].name);
+                match = dns_scope_good_domain(s, name);
                 if (match < 0)
                         return match;
 
                 if (match != found)
                         continue;
 
-                r = dns_query_transaction_new(q, NULL, s);
+                r = dns_query_add_transaction_split(q, s);
                 if (r < 0)
                         return r;
         }
 
-        q->received = dns_packet_unref(q->received);
+        q->answer = dns_answer_unref(q->answer);
+        q->answer_ifindex = 0;
+        q->answer_rcode = 0;
 
         r = sd_event_add_time(q->manager->event, &q->timeout_event_source, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + QUERY_TIMEOUT_USEC, 0, on_query_timeout, q);
         if (r < 0)
                 goto fail;
 
-        dns_query_set_state(q, DNS_QUERY_PENDING);
-
-        LIST_FOREACH(transactions_by_query, t, q->transactions) {
+        q->state = DNS_QUERY_PENDING;
+        q->block_ready++;
 
-                r = dns_query_transaction_start(t);
-                if (r < 0)
-                        goto fail;
-
-                if (q->state != DNS_QUERY_PENDING)
-                        break;
+        SET_FOREACH(t, q->transactions, i) {
+                if (t->state == DNS_QUERY_NULL) {
+                        r = dns_query_transaction_go(t);
+                        if (r < 0)
+                                goto fail;
+                }
         }
 
+        q->block_ready--;
+        dns_query_ready(q);
+
         return 1;
 
 fail:
@@ -576,34 +770,87 @@ fail:
         return r;
 }
 
-void dns_query_finish(DnsQuery *q) {
+void dns_query_ready(DnsQuery *q) {
         DnsQueryTransaction *t;
         DnsQueryState state = DNS_QUERY_NO_SERVERS;
-        DnsPacket *received = NULL;
+        _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
+        int rcode = 0;
+        DnsScope *scope = NULL;
+        Iterator i;
 
         assert(q);
+        assert(IN_SET(q->state, DNS_QUERY_NULL, DNS_QUERY_PENDING));
 
-        if (q->state != DNS_QUERY_PENDING)
+        /* Note that this call might invalidate the query. Callers
+         * should hence not attempt to access the query or transaction
+         * after calling this function, unless the block_ready
+         * counter was explicitly bumped before doing so. */
+
+        if (q->block_ready > 0)
                 return;
 
-        LIST_FOREACH(transactions_by_query, t, q->transactions) {
+        SET_FOREACH(t, q->transactions, i) {
+
+                /* If we found a successful answer, ignore all answers from other scopes */
+                if (state == DNS_QUERY_SUCCESS && t->scope != scope)
+                        continue;
 
                 /* One of the transactions is still going on, let's wait for it */
                 if (t->state == DNS_QUERY_PENDING || t->state == DNS_QUERY_NULL)
                         return;
 
-                /* One of the transactions is successful, let's use it */
+                /* One of the transactions is successful, let's use
+                 * it, and copy its data out */
                 if (t->state == DNS_QUERY_SUCCESS) {
-                        q->received = dns_packet_ref(t->received);
-                        dns_query_set_state(q, DNS_QUERY_SUCCESS);
-                        return;
+                        DnsAnswer *a;
+
+                        if (t->received) {
+                                rcode = DNS_PACKET_RCODE(t->received);
+                                a = t->received->answer;
+                        } else {
+                                rcode = t->cached_rcode;
+                                a = t->cached;
+                        }
+
+                        if (state == DNS_QUERY_SUCCESS) {
+                                DnsAnswer *merged;
+
+                                merged = dns_answer_merge(answer, a);
+                                if (!merged) {
+                                        dns_query_complete(q, DNS_QUERY_RESOURCES);
+                                        return;
+                                }
+
+                                dns_answer_unref(answer);
+                                answer = merged;
+                        } else {
+                                dns_answer_unref(answer);
+                                answer = dns_answer_ref(a);
+                        }
+
+                        scope = t->scope;
+                        state = DNS_QUERY_SUCCESS;
+                        continue;
                 }
 
                 /* One of the transactions has failed, let's see
                  * whether we find anything better, but if not, return
-                 * its response packet */
-                if (t->state == DNS_QUERY_FAILURE) {
-                        received = t->received;
+                 * its response data */
+                if (state != DNS_QUERY_SUCCESS && t->state == DNS_QUERY_FAILURE) {
+                        DnsAnswer *a;
+
+                        if (t->received) {
+                                rcode = DNS_PACKET_RCODE(t->received);
+                                a = t->received->answer;
+                        } else {
+                                rcode = t->cached_rcode;
+                                a = t->cached;
+                        }
+
+                        dns_answer_unref(answer);
+                        answer = dns_answer_ref(a);
+
+                        scope = t->scope;
                         state = DNS_QUERY_FAILURE;
                         continue;
                 }
@@ -612,93 +859,50 @@ void dns_query_finish(DnsQuery *q) {
                         state = t->state;
         }
 
-        if (state == DNS_QUERY_FAILURE)
-                q->received = dns_packet_ref(received);
-
-        dns_query_set_state(q, state);
-}
-
-int dns_query_follow_cname(DnsQuery *q, const char *name) {
-        DnsResourceKey *keys;
-        unsigned i;
-
-        assert(q);
-
-        if (q->n_cname > CNAME_MAX)
-                return -ELOOP;
-
-        keys = new(DnsResourceKey, q->n_keys);
-        if (!keys)
-                return -ENOMEM;
-
-        for (i = 0; i < q->n_keys; i++) {
-                keys[i].class = q->keys[i].class;
-                keys[i].type = q->keys[i].type;
-                keys[i].name = strdup(name);
-                if (!keys[i].name) {
-
-                        for (; i > 0; i--)
-                                free(keys[i-1].name);
-                        free(keys);
-                        return -ENOMEM;
-                }
+        if (IN_SET(state, DNS_QUERY_SUCCESS, DNS_QUERY_FAILURE)) {
+                q->answer = dns_answer_ref(answer);
+                q->answer_rcode = rcode;
+                q->answer_ifindex = (scope && scope->link) ? scope->link->ifindex : 0;
         }
 
-        for (i = 0; i < q->n_keys; i++)
-                free(q->keys[i].name);
-        free(q->keys);
-
-        q->keys = keys;
-
-        q->n_cname++;
-
-        dns_query_set_state(q, DNS_QUERY_NULL);
-        return 0;
+        dns_query_complete(q, state);
 }
 
-int dns_query_matches_rr(DnsQuery *q, DnsResourceRecord *rr) {
-        unsigned i;
+int dns_query_cname_redirect(DnsQuery *q, const char *name) {
+        _cleanup_(dns_question_unrefp) DnsQuestion *nq = NULL;
         int r;
 
         assert(q);
-        assert(rr);
-
-        for (i = 0; i < q->n_keys; i++) {
-
-                if (rr->key.class != q->keys[i].class)
-                        continue;
-
-                if (rr->key.type != q->keys[i].type &&
-                    q->keys[i].type != DNS_TYPE_ANY)
-                        continue;
-
-                r = dns_name_equal(rr->key.name, q->keys[i].name);
-                if (r != 0)
-                        return r;
-        }
-
-        return 0;
-}
-
-int dns_query_matches_cname(DnsQuery *q, DnsResourceRecord *rr) {
-        unsigned i;
-        int r;
 
-        assert(q);
-        assert(rr);
+        if (q->n_cname_redirects > CNAME_MAX)
+                return -ELOOP;
 
-        for (i = 0; i < q->n_keys; i++) {
+        r = dns_question_cname_redirect(q->question, name, &nq);
+        if (r < 0)
+                return r;
 
-                if (rr->key.class != q->keys[i].class)
-                        continue;
+        dns_question_unref(q->question);
+        q->question = nq;
+        nq = NULL;
 
-                if (rr->key.type != DNS_TYPE_CNAME)
-                        continue;
+        q->n_cname_redirects++;
 
-                r = dns_name_equal(rr->key.name, q->keys[i].name);
-                if (r != 0)
-                        return r;
-        }
+        dns_query_stop(q);
+        q->state = DNS_QUERY_NULL;
 
         return 0;
 }
+
+static const char* const dns_query_state_table[_DNS_QUERY_STATE_MAX] = {
+        [DNS_QUERY_NULL] = "null",
+        [DNS_QUERY_PENDING] = "pending",
+        [DNS_QUERY_FAILURE] = "failure",
+        [DNS_QUERY_SUCCESS] = "success",
+        [DNS_QUERY_NO_SERVERS] = "no-servers",
+        [DNS_QUERY_TIMEOUT] = "timeout",
+        [DNS_QUERY_ATTEMPTS_MAX] = "attempts-max",
+        [DNS_QUERY_INVALID_REPLY] = "invalid-reply",
+        [DNS_QUERY_RESOURCES] = "resources",
+        [DNS_QUERY_ABORTED] = "aborted",
+};
+DEFINE_STRING_TABLE_LOOKUP(dns_query_state, DnsQueryState);