resolved: LOC records

[elogind.git] / src / resolve / resolved-dns-query.c

diff --git a/src/resolve/resolved-dns-query.c b/src/resolve/resolved-dns-query.c
index 85702515285f1325b86b2acf1b804f10eb81ef0b..22770023047fdd3cd18b84cd42c9bccb2b15459f 100644 (file)
--- a/src/resolve/resolved-dns-query.c
+++ b/src/resolve/resolved-dns-query.c
@@ -24,12 +24,27 @@
 #include "resolved-dns-query.h"
 #include "resolved-dns-domain.h"
 
-#define TRANSACTION_TIMEOUT_USEC (5 * USEC_PER_SEC)
+/* After how much time to repeat classic DNS requests */
+#define DNS_TRANSACTION_TIMEOUT_USEC (5 * USEC_PER_SEC)
+
+/* After how much time to repeat LLMNR requests, see RFC 4795 Section 7 */
+#define LLMNR_TRANSACTION_TIMEOUT_USEC (1 * USEC_PER_SEC)
+
+/* How long to wait for the query in total */
 #define QUERY_TIMEOUT_USEC (30 * USEC_PER_SEC)
-#define ATTEMPTS_MAX 8
+
+/* Maximum attempts to send DNS requests, across all DNS servers */
+#define DNS_TRANSACTION_ATTEMPTS_MAX 8
+
+/* Maximum attempts to send LLMNR requests, see RFC 4795 Section 2.7 */
+#define LLMNR_TRANSACTION_ATTEMPTS_MAX 3
+
 #define CNAME_MAX 8
 #define QUERIES_MAX 2048
 
+#define TRANSACTION_TIMEOUT_USEC(p) ((t)->scope->protocol == DNS_PROTOCOL_LLMNR ? LLMNR_TRANSACTION_TIMEOUT_USEC : DNS_TRANSACTION_TIMEOUT_USEC)
+#define TRANSACTION_ATTEMPTS_MAX(p) ((t)->scope->protocol == DNS_PROTOCOL_LLMNR ? LLMNR_TRANSACTION_ATTEMPTS_MAX : DNS_TRANSACTION_ATTEMPTS_MAX)
+
 static int dns_query_transaction_go(DnsQueryTransaction *t);
 
 DnsQueryTransaction* dns_query_transaction_free(DnsQueryTransaction *t) {
@@ -411,10 +426,13 @@ static int dns_query_make_packet(DnsQueryTransaction *t) {
 }
 
 static int dns_query_transaction_go(DnsQueryTransaction *t) {
+        bool had_stream;
         int r;
 
         assert(t);
 
+        had_stream = !!t->stream;
+
         dns_query_transaction_stop(t);
 
         log_debug("Beginning transaction on scope %s on %s/%s",
@@ -422,7 +440,14 @@ static int dns_query_transaction_go(DnsQueryTransaction *t) {
                   t->scope->link ? t->scope->link->name : "*",
                   t->scope->family == AF_UNSPEC ? "*" : af_to_name(t->scope->family));
 
-        if (t->n_attempts >= ATTEMPTS_MAX) {
+        if (t->n_attempts >= TRANSACTION_ATTEMPTS_MAX(t)) {
+                dns_query_transaction_complete(t, DNS_QUERY_ATTEMPTS_MAX);
+                return 0;
+        }
+
+        if (t->scope->protocol == DNS_PROTOCOL_LLMNR && had_stream) {
+                /* If we already tried via a stream, then we don't
+                 * retry on LLMNR. See RFC 4795, Section 2.7. */
                 dns_query_transaction_complete(t, DNS_QUERY_ATTEMPTS_MAX);
                 return 0;
         }
@@ -482,7 +507,7 @@ static int dns_query_transaction_go(DnsQueryTransaction *t) {
                 return dns_query_transaction_go(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);
+        r = sd_event_add_time(t->scope->manager->event, &t->timeout_event_source, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + TRANSACTION_TIMEOUT_USEC(t), 0, on_transaction_timeout, t);
         if (r < 0)
                 return r;
 
@@ -542,10 +567,13 @@ int dns_query_new(Manager *m, DnsQuery **ret, DnsQuestion *question) {
         q->question = dns_question_ref(question);
 
         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]));
+                _cleanup_free_ char *p;
+
+                r = dns_resource_key_to_string(question->keys[i], &p);
+                if (r < 0)
+                        return r;
+
+                log_debug("Looking up RR for %s", p);
         }
 
         LIST_PREPEND(queries, m->dns_queries, q);
@@ -776,6 +804,7 @@ void dns_query_ready(DnsQuery *q) {
         _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
         int rcode = 0;
         DnsScope *scope = NULL;
+        bool pending = false;
         Iterator i;
 
         assert(q);
@@ -795,9 +824,11 @@ void dns_query_ready(DnsQuery *q) {
                 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 still going on, let's maybe wait for it */
+                if (IN_SET(t->state, DNS_QUERY_PENDING, DNS_QUERY_NULL)) {
+                        pending = true;
+                        continue;
+                }
 
                 /* One of the transactions is successful, let's use
                  * it, and copy its data out */
@@ -859,6 +890,21 @@ void dns_query_ready(DnsQuery *q) {
                         state = t->state;
         }
 
+        if (pending) {
+
+                /* If so far we weren't successful, and there's
+                 * something still pending, then wait for it */
+                if (state != DNS_QUERY_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_QUERY_PENDING, DNS_QUERY_NULL))
+                                return;
+                }
+        }
+
         if (IN_SET(state, DNS_QUERY_SUCCESS, DNS_QUERY_FAILURE)) {
                 q->answer = dns_answer_ref(answer);
                 q->answer_rcode = rcode;