X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fresolve%2Fresolved-dns-query.c;h=6d77c109b4ec5002c7b4edf16152f2fe9b48b0d0;hp=dd812150cfc6554da47a98a1e5c02fc26f990ef9;hb=90ab504273a7f186ebb76e6acfb778b4e0d7c91b;hpb=b9d394ea565fd742bcdd34e8dd61ae07c58a9565

diff --git a/src/resolve/resolved-dns-query.c b/src/resolve/resolved-dns-query.c
index dd812150c..6d77c109b 100644
--- a/src/resolve/resolved-dns-query.c
+++ b/src/resolve/resolved-dns-query.c
@@ -19,236 +19,221 @@
   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"
 
-#define TRANSACTION_TIMEOUT_USEC (5 * USEC_PER_SEC)
+/* How long to wait for the query in total */
 #define QUERY_TIMEOUT_USEC (30 * USEC_PER_SEC)
-#define ATTEMPTS_MAX 8
 
-DnsQueryTransaction* dns_query_transaction_free(DnsQueryTransaction *t) {
-        if (!t)
+#define CNAME_MAX 8
+#define QUERIES_MAX 2048
+
+static void dns_query_stop(DnsQuery *q) {
+        DnsTransaction *t;
+
+        assert(q);
+
+        q->timeout_event_source = sd_event_source_unref(q->timeout_event_source);
+
+        while ((t = set_steal_first(q->transactions))) {
+                set_remove(t->queries, q);
+                dns_transaction_gc(t);
+        }
+}
+
+DnsQuery *dns_query_free(DnsQuery *q) {
+        if (!q)
                 return NULL;
 
-        sd_event_source_unref(t->timeout_event_source);
-        dns_packet_unref(t->packet);
+        dns_query_stop(q);
+        set_free(q->transactions);
+
+        dns_question_unref(q->question);
+        dns_answer_unref(q->answer);
 
-        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));
+        sd_bus_message_unref(q->request);
+        sd_bus_track_unref(q->bus_track);
+
+        if (q->manager) {
+                LIST_REMOVE(queries, q->manager->dns_queries, q);
+                q->manager->n_dns_queries--;
         }
 
-        if (t->scope)
-                LIST_REMOVE(transactions_by_scope, t->scope->transactions, t);
+        free(q);
 
-        free(t);
         return NULL;
 }
 
-DEFINE_TRIVIAL_CLEANUP_FUNC(DnsQueryTransaction*, dns_query_transaction_free);
-
-static int dns_query_transaction_new(DnsQuery *q, DnsQueryTransaction **ret, DnsScope *s) {
-        _cleanup_(dns_query_transaction_freep) DnsQueryTransaction *t = NULL;
+int dns_query_new(Manager *m, DnsQuery **ret, DnsQuestion *question) {
+        _cleanup_(dns_query_freep) DnsQuery *q = NULL;
+        unsigned i;
         int r;
 
-        assert(q);
-        assert(s);
+        assert(m);
+        assert(question);
 
-        r = hashmap_ensure_allocated(&q->manager->dns_query_transactions, NULL, NULL);
+        r = dns_question_is_valid(question);
         if (r < 0)
                 return r;
 
-        t = new0(DnsQueryTransaction, 1);
-        if (!t)
+        if (m->n_dns_queries >= QUERIES_MAX)
+                return -EBUSY;
+
+        q = new0(DnsQuery, 1);
+        if (!q)
                 return -ENOMEM;
 
-        do
-                random_bytes(&t->id, sizeof(t->id));
-        while (t->id == 0 ||
-               hashmap_get(q->manager->dns_query_transactions, UINT_TO_PTR(t->id)));
+        q->question = dns_question_ref(question);
 
-        r = hashmap_put(q->manager->dns_query_transactions, UINT_TO_PTR(t->id), t);
-        if (r < 0) {
-                t->id = 0;
-                return r;
-        }
+        for (i = 0; i < question->n_keys; i++) {
+                _cleanup_free_ char *p;
+
+                r = dns_resource_key_to_string(question->keys[i], &p);
+                if (r < 0)
+                        return r;
 
-        LIST_PREPEND(transactions_by_query, q->transactions, t);
-        t->query = q;
+                log_debug("Looking up RR for %s", p);
+        }
 
-        LIST_PREPEND(transactions_by_scope, s->transactions, t);
-        t->scope = s;
+        LIST_PREPEND(queries, m->dns_queries, q);
+        m->n_dns_queries++;
+        q->manager = m;
 
         if (ret)
-                *ret = t;
-
-        t = NULL;
+                *ret = q;
+        q = NULL;
 
         return 0;
 }
 
-static void dns_query_transaction_set_state(DnsQueryTransaction *t, DnsQueryState state) {
-        assert(t);
-
-        if (t->state == state)
-                return;
+static void dns_query_complete(DnsQuery *q, DnsTransactionState state) {
+        assert(q);
+        assert(!IN_SET(state, DNS_TRANSACTION_NULL, DNS_TRANSACTION_PENDING));
+        assert(IN_SET(q->state, DNS_TRANSACTION_NULL, DNS_TRANSACTION_PENDING));
 
-        t->state = state;
+        /* Note that this call might invalidate the query. Callers
+         * should hence not attempt to access the query or transaction
+         * after calling this function. */
 
-        if (state != DNS_QUERY_SENT)
-                t->timeout_event_source = sd_event_source_unref(t->timeout_event_source);
+        q->state = state;
 
-        dns_query_finish(t->query);
+        dns_query_stop(q);
+        if (q->complete)
+                q->complete(q);
 }
 
-int dns_query_transaction_reply(DnsQueryTransaction *t, DnsPacket *p) {
-        assert(t);
-        assert(p);
-
-        t->packet = dns_packet_ref(p);
+static int on_query_timeout(sd_event_source *s, usec_t usec, void *userdata) {
+        DnsQuery *q = userdata;
 
-        if (DNS_PACKET_RCODE(p) == DNS_RCODE_SUCCESS)
-                dns_query_transaction_set_state(t, DNS_QUERY_SUCCESS);
-        else
-                dns_query_transaction_set_state(t, DNS_QUERY_FAILURE);
+        assert(s);
+        assert(q);
 
+        dns_query_complete(q, DNS_TRANSACTION_TIMEOUT);
         return 0;
 }
 
-static int on_transaction_timeout(sd_event_source *s, usec_t usec, void *userdata) {
-        DnsQueryTransaction *t = userdata;
+static int dns_query_add_transaction(DnsQuery *q, DnsScope *s, DnsResourceKey *key) {
+        _cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
+        DnsTransaction *t;
         int r;
 
+        assert(q);
         assert(s);
-        assert(t);
-
-        /* Timeout reached? Try again, with a new server */
-        dns_scope_next_dns_server(t->scope);
 
-        r = dns_query_transaction_start(t);
+        r = set_ensure_allocated(&q->transactions, NULL, NULL);
         if (r < 0)
-                dns_query_transaction_set_state(t, DNS_QUERY_FAILURE);
-
-        return 0;
-}
-
-int dns_query_transaction_start(DnsQueryTransaction *t) {
-        _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
-        unsigned n;
-        int r;
-
-        assert(t);
-
-        t->timeout_event_source = sd_event_source_unref(t->timeout_event_source);
-
-        if (t->n_attempts >= ATTEMPTS_MAX) {
-                dns_query_transaction_set_state(t, DNS_QUERY_ATTEMPTS_MAX);
-                return 0;
-        }
+                return r;
 
-        t->n_attempts++;
+        if (key) {
+                question = dns_question_new(1);
+                if (!question)
+                        return -ENOMEM;
 
-        r = dns_packet_new_query(&p, 0);
-        if (r < 0)
-                return r;
+                r = dns_question_add(question, key);
+                if (r < 0)
+                        return r;
+        } else
+                question = dns_question_ref(q->question);
 
-        for (n = 0; n < t->query->n_keys; n++) {
-                r = dns_packet_append_key(p, &t->query->keys[n], NULL);
+        t = dns_scope_find_transaction(s, question, true);
+        if (!t) {
+                r = dns_transaction_new(&t, s, question);
                 if (r < 0)
                         return r;
         }
 
-        DNS_PACKET_HEADER(p)->qdcount = htobe16(t->query->n_keys);
-        DNS_PACKET_HEADER(p)->id = t->id;
+        r = set_ensure_allocated(&t->queries, NULL, NULL);
+        if (r < 0)
+                goto gc;
 
-        r = dns_scope_send(t->scope, p);
-        if (r < 0) {
-                /* Couldn't send? Try immediately again, with a new server */
-                dns_scope_next_dns_server(t->scope);
+        r = set_put(t->queries, q);
+        if (r < 0)
+                goto gc;
 
-                return dns_query_transaction_start(t);
+        r = set_put(q->transactions, t);
+        if (r < 0) {
+                set_remove(t->queries, q);
+                goto gc;
         }
 
-        if (r > 0) {
-                int q;
-
-                q = 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);
-                if (q < 0)
-                        return q;
-
-                dns_query_transaction_set_state(t, DNS_QUERY_SENT);
-        } else
-                dns_query_transaction_set_state(t, DNS_QUERY_SKIPPED);
+        return 0;
 
+gc:
+        dns_transaction_gc(t);
         return r;
 }
 
-DnsQuery *dns_query_free(DnsQuery *q) {
-        unsigned n;
-
-        if (!q)
-                return NULL;
+static int dns_query_add_transaction_split(DnsQuery *q, DnsScope *s) {
+        int r;
 
-        sd_bus_message_unref(q->request);
-        dns_packet_unref(q->packet);
-        sd_event_source_unref(q->timeout_event_source);
+        assert(q);
+        assert(s);
 
-        while (q->transactions)
-                dns_query_transaction_free(q->transactions);
+        if (s->protocol == DNS_PROTOCOL_MDNS) {
+                r = dns_query_add_transaction(q, s, NULL);
+                if (r < 0)
+                        return r;
+        } else {
+                unsigned i;
 
-        if (q->manager)
-                LIST_REMOVE(queries, q->manager->dns_queries, q);
+                /* On DNS and LLMNR we can only send a single
+                 * question per datagram, hence issue multiple
+                 * transactions. */
 
-        for (n = 0; n < q->n_keys; n++)
-                free(q->keys[n].name);
-        free(q->keys);
-        free(q);
+                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 NULL;
+        return 0;
 }
 
-int dns_query_new(Manager *m, DnsQuery **ret, DnsResourceKey *keys, unsigned n_keys) {
-        _cleanup_(dns_query_freep) DnsQuery *q = NULL;
-        DnsScope *s, *first = NULL;
+int dns_query_go(DnsQuery *q) {
         DnsScopeMatch found = DNS_SCOPE_NO;
-        const char *name = NULL;
-        int n, r;
-
-        assert(m);
-
-        if (n_keys <= 0 || n_keys >= 65535)
-                return -EINVAL;
-
-        assert(keys);
+        DnsScope *s, *first = NULL;
+        DnsTransaction *t;
+        const char *name;
+        Iterator i;
+        int r;
 
-        q = new0(DnsQuery, 1);
-        if (!q)
-                return -ENOMEM;
+        assert(q);
 
-        q->keys = new(DnsResourceKey, n_keys);
-        if (!q->keys)
-                return -ENOMEM;
+        if (q->state != DNS_TRANSACTION_NULL)
+                return 0;
 
-        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;
+        assert(q->question);
+        assert(q->question->n_keys > 0);
 
-                if (!name)
-                        name = q->keys[q->n_keys].name;
-                else if (!dns_name_equal(name, q->keys[q->n_keys].name))
-                        return -EINVAL;
-        }
+        name = DNS_RESOURCE_KEY_NAME(q->question->keys[0]);
 
-        LIST_PREPEND(queries, m->dns_queries, q);
-        q->manager = m;
-
-        LIST_FOREACH(scopes, s, m->dns_scopes) {
+        LIST_FOREACH(scopes, s, q->manager->dns_scopes) {
                 DnsScopeMatch match;
 
-                match = dns_scope_test(s, name);
+                match = dns_scope_good_domain(s, name);
                 if (match < 0)
                         return match;
 
@@ -269,137 +254,230 @@ int dns_query_new(Manager *m, DnsQuery **ret, DnsResourceKey *keys, unsigned n_k
         }
 
         if (found == DNS_SCOPE_NO)
-                return -ENETDOWN;
+                return -ESRCH;
 
-        r = dns_query_transaction_new(q, NULL, first);
+        r = dns_query_add_transaction_split(q, first);
         if (r < 0)
-                return r;
+                goto fail;
 
-        n = 1;
         LIST_FOREACH(scopes, s, first->scopes_next) {
                 DnsScopeMatch match;
 
-                match = dns_scope_test(s, name);
+                match = dns_scope_good_domain(s, name);
                 if (match < 0)
-                        return match;
+                        goto fail;
 
                 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;
+                        goto fail;
+        }
+
+        q->answer = dns_answer_unref(q->answer);
+        q->answer_ifindex = 0;
+        q->answer_rcode = 0;
 
-                n++;
+        r = sd_event_add_time(
+                        q->manager->event,
+                        &q->timeout_event_source,
+                        clock_boottime_or_monotonic(),
+                        now(clock_boottime_or_monotonic()) + QUERY_TIMEOUT_USEC, 0,
+                        on_query_timeout, q);
+        if (r < 0)
+                goto fail;
+
+        q->state = DNS_TRANSACTION_PENDING;
+        q->block_ready++;
+
+        /* Start the transactions that are not started yet */
+        SET_FOREACH(t, q->transactions, i) {
+                if (t->state != DNS_TRANSACTION_NULL)
+                        continue;
+
+                r = dns_transaction_go(t);
+                if (r < 0)
+                        goto fail;
         }
 
-        if (ret)
-                *ret = q;
-        q = NULL;
+        q->block_ready--;
+        dns_query_ready(q);
+
+        return 1;
 
-        return n;
+fail:
+        dns_query_stop(q);
+        return r;
 }
 
-static void dns_query_set_state(DnsQuery *q, DnsQueryState state) {
+void dns_query_ready(DnsQuery *q) {
+        DnsTransaction *t;
+        DnsTransactionState state = DNS_TRANSACTION_NO_SERVERS;
+        _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
+        int rcode = 0;
+        DnsScope *scope = NULL;
+        bool pending = false;
+        Iterator i;
+
         assert(q);
+        assert(IN_SET(q->state, DNS_TRANSACTION_NULL, DNS_TRANSACTION_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->state == state)
+        if (q->block_ready > 0)
                 return;
 
-        q->state = state;
+        SET_FOREACH(t, q->transactions, i) {
 
-        if (state == DNS_QUERY_SENT)
-                return;
+                /* If we found a successful answer, ignore all answers from other scopes */
+                if (state == DNS_TRANSACTION_SUCCESS && t->scope != scope)
+                        continue;
 
-        q->timeout_event_source = sd_event_source_unref(q->timeout_event_source);
+                /* One of the transactions is still going on, let's maybe wait for it */
+                if (IN_SET(t->state, DNS_TRANSACTION_PENDING, DNS_TRANSACTION_NULL)) {
+                        pending = true;
+                        continue;
+                }
 
-        while (q->transactions)
-                dns_query_transaction_free(q->transactions);
+                /* One of the transactions is successful, let's use
+                 * it, and copy its data out */
+                if (t->state == DNS_TRANSACTION_SUCCESS) {
+                        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_TRANSACTION_SUCCESS) {
+                                DnsAnswer *merged;
+
+                                merged = dns_answer_merge(answer, a);
+                                if (!merged) {
+                                        dns_query_complete(q, DNS_TRANSACTION_RESOURCES);
+                                        return;
+                                }
+
+                                dns_answer_unref(answer);
+                                answer = merged;
+                        } else {
+                                dns_answer_unref(answer);
+                                answer = dns_answer_ref(a);
+                        }
+
+                        scope = t->scope;
+                        state = DNS_TRANSACTION_SUCCESS;
+                        continue;
+                }
 
-        if (q->complete)
-                q->complete(q);
-}
+                /* One of the transactions has failed, let's see
+                 * whether we find anything better, but if not, return
+                 * its response data */
+                if (state != DNS_TRANSACTION_SUCCESS && t->state == DNS_TRANSACTION_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_TRANSACTION_FAILURE;
+                        continue;
+                }
 
-static int on_query_timeout(sd_event_source *s, usec_t usec, void *userdata) {
-        DnsQuery *q = userdata;
+                if (state == DNS_TRANSACTION_NO_SERVERS && t->state != DNS_TRANSACTION_NO_SERVERS)
+                        state = t->state;
+        }
 
-        assert(s);
-        assert(q);
+        if (pending) {
 
-        dns_query_set_state(q, DNS_QUERY_TIMEOUT);
-        return 0;
+                /* If so far we weren't successful, and there's
+                 * something still pending, then wait for it */
+                if (state != DNS_TRANSACTION_SUCCESS)
+                        return;
+
+                /* If we already were successful, then only wait for
+                 * other transactions on the same scope to finish. */
+                SET_FOREACH(t, q->transactions, i) {
+                        if (t->scope == scope && IN_SET(t->state, DNS_TRANSACTION_PENDING, DNS_TRANSACTION_NULL))
+                                return;
+                }
+        }
+
+        if (IN_SET(state, DNS_TRANSACTION_SUCCESS, DNS_TRANSACTION_FAILURE)) {
+                q->answer = dns_answer_ref(answer);
+                q->answer_rcode = rcode;
+                q->answer_ifindex = (scope && scope->link) ? scope->link->ifindex : 0;
+        }
+
+        dns_query_complete(q, state);
 }
 
-int dns_query_start(DnsQuery *q) {
-        DnsQueryTransaction *t;
+int dns_query_cname_redirect(DnsQuery *q, const char *name) {
+        _cleanup_(dns_question_unrefp) DnsQuestion *nq = NULL;
         int r;
 
         assert(q);
-        assert(q->state == DNS_QUERY_NULL);
 
-        if (!q->transactions)
-                return -ENETDOWN;
+        if (q->n_cname_redirects > CNAME_MAX)
+                return -ELOOP;
 
-        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);
+        r = dns_question_cname_redirect(q->question, name, &nq);
         if (r < 0)
-                goto fail;
-
-        dns_query_set_state(q, DNS_QUERY_SENT);
+                return r;
 
-        LIST_FOREACH(transactions_by_query, t, q->transactions) {
+        dns_question_unref(q->question);
+        q->question = nq;
+        nq = NULL;
 
-                r = dns_query_transaction_start(t);
-                if (r < 0)
-                        goto fail;
+        q->n_cname_redirects++;
 
-                if (q->state != DNS_QUERY_SENT)
-                        break;
-        }
+        dns_query_stop(q);
+        q->state = DNS_TRANSACTION_NULL;
 
         return 0;
-
-fail:
-        while (q->transactions)
-                dns_query_transaction_free(q->transactions);
-
-        return r;
 }
 
-void dns_query_finish(DnsQuery *q) {
-        DnsQueryTransaction *t;
-        DnsQueryState state = DNS_QUERY_SKIPPED;
-        uint16_t rcode = 0;
+static int on_bus_track(sd_bus_track *t, void *userdata) {
+        DnsQuery *q = userdata;
 
+        assert(t);
         assert(q);
 
-        if (q->state != DNS_QUERY_SENT)
-                return;
-
-        LIST_FOREACH(transactions_by_query, t, q->transactions) {
-
-                /* One of the transactions is still going on, let's wait for it */
-                if (t->state == DNS_QUERY_SENT || t->state == DNS_QUERY_NULL)
-                        return;
-
-                /* One of the transactions is sucecssful, let's use it */
-                if (t->state == DNS_QUERY_SUCCESS) {
-                        q->packet = dns_packet_ref(t->packet);
-                        dns_query_set_state(q, DNS_QUERY_SUCCESS);
-                        return;
-                }
+        log_debug("Client of active query vanished, aborting query.");
+        dns_query_complete(q, DNS_TRANSACTION_ABORTED);
+        return 0;
+}
 
-                if (t->state == DNS_QUERY_FAILURE) {
-                        state = DNS_QUERY_FAILURE;
+int dns_query_bus_track(DnsQuery *q, sd_bus *bus, sd_bus_message *m) {
+        int r;
 
-                        if (rcode == 0 && t->packet)
-                                rcode = DNS_PACKET_RCODE(t->packet);
+        assert(q);
+        assert(m);
 
-                } else if (state == DNS_QUERY_SKIPPED && t->state != DNS_QUERY_SKIPPED)
-                        state = t->state;
+        if (!q->bus_track) {
+                r = sd_bus_track_new(bus, &q->bus_track, on_bus_track, q);
+                if (r < 0)
+                        return r;
         }
 
-        if (state == DNS_QUERY_FAILURE)
-                q->rcode = rcode;
+        r = sd_bus_track_add_sender(q->bus_track, m);
+        if (r < 0)
+                return r;
 
-        dns_query_set_state(q, state);
+        return 0;
 }