src/resolve/resolved-dns-transaction.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2014 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include "af-list.h"
  23 #include "alloc-util.h"
  24 #include "dns-domain.h"
  25 #include "fd-util.h"
  26 #include "random-util.h"
  27 #include "resolved-dns-transaction.h"
  28 #include "resolved-llmnr.h"
  29 #include "string-table.h"
  30
  31 DnsTransaction* dns_transaction_free(DnsTransaction *t) {
  32         DnsQueryCandidate *c;
  33         DnsZoneItem *i;
  34
  35         if (!t)
  36                 return NULL;
  37
  38         sd_event_source_unref(t->timeout_event_source);
  39
  40         dns_packet_unref(t->sent);
  41         dns_packet_unref(t->received);
  42
  43         dns_answer_unref(t->answer);
  44
  45         sd_event_source_unref(t->dns_udp_event_source);
  46         safe_close(t->dns_udp_fd);
  47
  48         dns_server_unref(t->server);
  49         dns_stream_free(t->stream);
  50
  51         if (t->scope) {
  52                 hashmap_remove_value(t->scope->transactions_by_key, t->key, t);
  53                 LIST_REMOVE(transactions_by_scope, t->scope->transactions, t);
  54
  55                 if (t->id != 0)
  56                         hashmap_remove(t->scope->manager->dns_transactions, UINT_TO_PTR(t->id));
  57         }
  58
  59         dns_resource_key_unref(t->key);
  60
  61         while ((c = set_steal_first(t->query_candidates)))
  62                 set_remove(c->transactions, t);
  63
  64         set_free(t->query_candidates);
  65
  66         while ((i = set_steal_first(t->zone_items)))
  67                 i->probe_transaction = NULL;
  68         set_free(t->zone_items);
  69
  70         free(t);
  71         return NULL;
  72 }
  73
  74 DEFINE_TRIVIAL_CLEANUP_FUNC(DnsTransaction*, dns_transaction_free);
  75
  76 void dns_transaction_gc(DnsTransaction *t) {
  77         assert(t);
  78
  79         if (t->block_gc > 0)
  80                 return;
  81
  82         if (set_isempty(t->query_candidates) && set_isempty(t->zone_items))
  83                 dns_transaction_free(t);
  84 }
  85
  86 int dns_transaction_new(DnsTransaction **ret, DnsScope *s, DnsResourceKey *key) {
  87         _cleanup_(dns_transaction_freep) DnsTransaction *t = NULL;
  88         int r;
  89
  90         assert(ret);
  91         assert(s);
  92         assert(key);
  93
  94         r = hashmap_ensure_allocated(&s->manager->dns_transactions, NULL);
  95         if (r < 0)
  96                 return r;
  97
  98         r = hashmap_ensure_allocated(&s->transactions_by_key, &dns_resource_key_hash_ops);
  99         if (r < 0)
 100                 return r;
 101
 102         t = new0(DnsTransaction, 1);
 103         if (!t)
 104                 return -ENOMEM;
 105
 106         t->dns_udp_fd = -1;
 107         t->answer_source = _DNS_TRANSACTION_SOURCE_INVALID;
 108         t->key = dns_resource_key_ref(key);
 109
 110         /* Find a fresh, unused transaction id */
 111         do
 112                 random_bytes(&t->id, sizeof(t->id));
 113         while (t->id == 0 ||
 114                hashmap_get(s->manager->dns_transactions, UINT_TO_PTR(t->id)));
 115
 116         r = hashmap_put(s->manager->dns_transactions, UINT_TO_PTR(t->id), t);
 117         if (r < 0) {
 118                 t->id = 0;
 119                 return r;
 120         }
 121
 122         r = hashmap_replace(s->transactions_by_key, t->key, t);
 123         if (r < 0) {
 124                 hashmap_remove(s->manager->dns_transactions, UINT_TO_PTR(t->id));
 125                 return r;
 126         }
 127
 128         LIST_PREPEND(transactions_by_scope, s->transactions, t);
 129         t->scope = s;
 130
 131         if (ret)
 132                 *ret = t;
 133
 134         t = NULL;
 135
 136         return 0;
 137 }
 138
 139 static void dns_transaction_stop(DnsTransaction *t) {
 140         assert(t);
 141
 142         t->timeout_event_source = sd_event_source_unref(t->timeout_event_source);
 143         t->stream = dns_stream_free(t->stream);
 144
 145         /* Note that we do not drop the UDP socket here, as we want to
 146          * reuse it to repeat the interaction. */
 147 }
 148
 149 static void dns_transaction_tentative(DnsTransaction *t, DnsPacket *p) {
 150         _cleanup_free_ char *pretty = NULL;
 151         DnsZoneItem *z;
 152
 153         assert(t);
 154         assert(p);
 155
 156         if (manager_our_packet(t->scope->manager, p) != 0)
 157                 return;
 158
 159         in_addr_to_string(p->family, &p->sender, &pretty);
 160
 161         log_debug("Transaction on scope %s on %s/%s got tentative packet from %s",
 162                   dns_protocol_to_string(t->scope->protocol),
 163                   t->scope->link ? t->scope->link->name : "*",
 164                   t->scope->family == AF_UNSPEC ? "*" : af_to_name(t->scope->family),
 165                   pretty);
 166
 167         /* RFC 4795, Section 4.1 says that the peer with the
 168          * lexicographically smaller IP address loses */
 169         if (memcmp(&p->sender, &p->destination, FAMILY_ADDRESS_SIZE(p->family)) >= 0) {
 170                 log_debug("Peer has lexicographically larger IP address and thus lost in the conflict.");
 171                 return;
 172         }
 173
 174         log_debug("We have the lexicographically larger IP address and thus lost in the conflict.");
 175
 176         t->block_gc++;
 177         while ((z = set_first(t->zone_items))) {
 178                 /* First, make sure the zone item drops the reference
 179                  * to us */
 180                 dns_zone_item_probe_stop(z);
 181
 182                 /* Secondly, report this as conflict, so that we might
 183                  * look for a different hostname */
 184                 dns_zone_item_conflict(z);
 185         }
 186         t->block_gc--;
 187
 188         dns_transaction_gc(t);
 189 }
 190
 191 void dns_transaction_complete(DnsTransaction *t, DnsTransactionState state) {
 192         DnsQueryCandidate *c;
 193         DnsZoneItem *z;
 194         Iterator i;
 195
 196         assert(t);
 197         assert(!IN_SET(state, DNS_TRANSACTION_NULL, DNS_TRANSACTION_PENDING));
 198
 199         /* Note that this call might invalidate the query. Callers
 200          * should hence not attempt to access the query or transaction
 201          * after calling this function. */
 202
 203         log_debug("Transaction on scope %s on %s/%s now complete with <%s> from %s",
 204                   dns_protocol_to_string(t->scope->protocol),
 205                   t->scope->link ? t->scope->link->name : "*",
 206                   t->scope->family == AF_UNSPEC ? "*" : af_to_name(t->scope->family),
 207                   dns_transaction_state_to_string(state),
 208                   t->answer_source < 0 ? "none" : dns_transaction_source_to_string(t->answer_source));
 209
 210         t->state = state;
 211
 212         dns_transaction_stop(t);
 213
 214         /* Notify all queries that are interested, but make sure the
 215          * transaction isn't freed while we are still looking at it */
 216         t->block_gc++;
 217         SET_FOREACH(c, t->query_candidates, i)
 218                 dns_query_candidate_ready(c);
 219         SET_FOREACH(z, t->zone_items, i)
 220                 dns_zone_item_ready(z);
 221         t->block_gc--;
 222
 223         dns_transaction_gc(t);
 224 }
 225
 226 static int on_stream_complete(DnsStream *s, int error) {
 227         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 228         DnsTransaction *t;
 229
 230         assert(s);
 231         assert(s->transaction);
 232
 233         /* Copy the data we care about out of the stream before we
 234          * destroy it. */
 235         t = s->transaction;
 236         p = dns_packet_ref(s->read_packet);
 237
 238         t->stream = dns_stream_free(t->stream);
 239
 240         if (error != 0) {
 241                 dns_transaction_complete(t, DNS_TRANSACTION_RESOURCES);
 242                 return 0;
 243         }
 244
 245         if (dns_packet_validate_reply(p) <= 0) {
 246                 log_debug("Invalid LLMNR TCP packet.");
 247                 dns_transaction_complete(t, DNS_TRANSACTION_INVALID_REPLY);
 248                 return 0;
 249         }
 250
 251         dns_scope_check_conflicts(t->scope, p);
 252
 253         t->block_gc++;
 254         dns_transaction_process_reply(t, p);
 255         t->block_gc--;
 256
 257         /* If the response wasn't useful, then complete the transition now */
 258         if (t->state == DNS_TRANSACTION_PENDING)
 259                 dns_transaction_complete(t, DNS_TRANSACTION_INVALID_REPLY);
 260
 261         return 0;
 262 }
 263
 264 static int dns_transaction_open_tcp(DnsTransaction *t) {
 265         DnsServer *server = NULL;
 266         _cleanup_close_ int fd = -1;
 267         int r;
 268
 269         assert(t);
 270
 271         if (t->stream)
 272                 return 0;
 273
 274         switch (t->scope->protocol) {
 275         case DNS_PROTOCOL_DNS:
 276                 fd = dns_scope_tcp_socket(t->scope, AF_UNSPEC, NULL, 53, &server);
 277                 break;
 278
 279         case DNS_PROTOCOL_LLMNR:
 280                 /* When we already received a reply to this (but it was truncated), send to its sender address */
 281                 if (t->received)
 282                         fd = dns_scope_tcp_socket(t->scope, t->received->family, &t->received->sender, t->received->sender_port, NULL);
 283                 else {
 284                         union in_addr_union address;
 285                         int family = AF_UNSPEC;
 286
 287                         /* Otherwise, try to talk to the owner of a
 288                          * the IP address, in case this is a reverse
 289                          * PTR lookup */
 290
 291                         r = dns_name_address(DNS_RESOURCE_KEY_NAME(t->key), &family, &address);
 292                         if (r < 0)
 293                                 return r;
 294                         if (r == 0)
 295                                 return -EINVAL;
 296                         if (family != t->scope->family)
 297                                 return -ESRCH;
 298
 299                         fd = dns_scope_tcp_socket(t->scope, family, &address, LLMNR_PORT, NULL);
 300                 }
 301
 302                 break;
 303
 304         default:
 305                 return -EAFNOSUPPORT;
 306         }
 307
 308         if (fd < 0)
 309                 return fd;
 310
 311         r = dns_stream_new(t->scope->manager, &t->stream, t->scope->protocol, fd);
 312         if (r < 0)
 313                 return r;
 314
 315         fd = -1;
 316
 317         r = dns_stream_write_packet(t->stream, t->sent);
 318         if (r < 0) {
 319                 t->stream = dns_stream_free(t->stream);
 320                 return r;
 321         }
 322
 323         dns_server_unref(t->server);
 324         t->server = dns_server_ref(server);
 325         t->received = dns_packet_unref(t->received);
 326         t->answer = dns_answer_unref(t->answer);
 327         t->answer_rcode = 0;
 328         t->stream->complete = on_stream_complete;
 329         t->stream->transaction = t;
 330
 331         /* The interface index is difficult to determine if we are
 332          * connecting to the local host, hence fill this in right away
 333          * instead of determining it from the socket */
 334         if (t->scope->link)
 335                 t->stream->ifindex = t->scope->link->ifindex;
 336
 337         return 0;
 338 }
 339
 340 static void dns_transaction_next_dns_server(DnsTransaction *t) {
 341         assert(t);
 342
 343         t->server = dns_server_unref(t->server);
 344         t->dns_udp_event_source = sd_event_source_unref(t->dns_udp_event_source);
 345         t->dns_udp_fd = safe_close(t->dns_udp_fd);
 346
 347         dns_scope_next_dns_server(t->scope);
 348 }
 349
 350 void dns_transaction_process_reply(DnsTransaction *t, DnsPacket *p) {
 351         usec_t ts;
 352         int r;
 353
 354         assert(t);
 355         assert(p);
 356         assert(t->state == DNS_TRANSACTION_PENDING);
 357         assert(t->scope);
 358         assert(t->scope->manager);
 359
 360         /* Note that this call might invalidate the query. Callers
 361          * should hence not attempt to access the query or transaction
 362          * after calling this function. */
 363
 364         switch (t->scope->protocol) {
 365         case DNS_PROTOCOL_LLMNR:
 366                 assert(t->scope->link);
 367
 368                 /* For LLMNR we will not accept any packets from other
 369                  * interfaces */
 370
 371                 if (p->ifindex != t->scope->link->ifindex)
 372                         return;
 373
 374                 if (p->family != t->scope->family)
 375                         return;
 376
 377                 /* Tentative packets are not full responses but still
 378                  * useful for identifying uniqueness conflicts during
 379                  * probing. */
 380                 if (DNS_PACKET_LLMNR_T(p)) {
 381                         dns_transaction_tentative(t, p);
 382                         return;
 383                 }
 384
 385                 break;
 386
 387         case DNS_PROTOCOL_DNS:
 388                 break;
 389
 390         default:
 391                 assert_not_reached("Invalid DNS protocol.");
 392         }
 393
 394         if (t->received != p) {
 395                 dns_packet_unref(t->received);
 396                 t->received = dns_packet_ref(p);
 397         }
 398
 399         t->answer_source = DNS_TRANSACTION_NETWORK;
 400
 401         if (p->ipproto == IPPROTO_TCP) {
 402                 if (DNS_PACKET_TC(p)) {
 403                         /* Truncated via TCP? Somebody must be fucking with us */
 404                         dns_transaction_complete(t, DNS_TRANSACTION_INVALID_REPLY);
 405                         return;
 406                 }
 407
 408                 if (DNS_PACKET_ID(p) != t->id) {
 409                         /* Not the reply to our query? Somebody must be fucking with us */
 410                         dns_transaction_complete(t, DNS_TRANSACTION_INVALID_REPLY);
 411                         return;
 412                 }
 413         }
 414
 415         assert_se(sd_event_now(t->scope->manager->event, clock_boottime_or_monotonic(), &ts) >= 0);
 416
 417         switch (t->scope->protocol) {
 418         case DNS_PROTOCOL_DNS:
 419                 assert(t->server);
 420
 421                 dns_server_packet_received(t->server, ts - t->start_usec);
 422
 423                 break;
 424         case DNS_PROTOCOL_LLMNR:
 425         case DNS_PROTOCOL_MDNS:
 426                 dns_scope_packet_received(t->scope, ts - t->start_usec);
 427
 428                 break;
 429         default:
 430                 break;
 431         }
 432
 433         if (DNS_PACKET_TC(p)) {
 434                 /* Response was truncated, let's try again with good old TCP */
 435                 r = dns_transaction_open_tcp(t);
 436                 if (r == -ESRCH) {
 437                         /* No servers found? Damn! */
 438                         dns_transaction_complete(t, DNS_TRANSACTION_NO_SERVERS);
 439                         return;
 440                 }
 441                 if (r < 0) {
 442                         /* On LLMNR, if we cannot connect to the host,
 443                          * we immediately give up */
 444                         if (t->scope->protocol == DNS_PROTOCOL_LLMNR) {
 445                                 dns_transaction_complete(t, DNS_TRANSACTION_RESOURCES);
 446                                 return;
 447                         }
 448
 449                         /* On DNS, couldn't send? Try immediately again, with a new server */
 450                         dns_transaction_next_dns_server(t);
 451
 452                         r = dns_transaction_go(t);
 453                         if (r < 0) {
 454                                 dns_transaction_complete(t, DNS_TRANSACTION_RESOURCES);
 455                                 return;
 456                         }
 457
 458                         return;
 459                 }
 460         }
 461
 462         /* Parse and update the cache */
 463         r = dns_packet_extract(p);
 464         if (r < 0) {
 465                 dns_transaction_complete(t, DNS_TRANSACTION_INVALID_REPLY);
 466                 return;
 467         }
 468
 469         /* Install the answer as answer to the transaction */
 470         dns_answer_unref(t->answer);
 471         t->answer = dns_answer_ref(p->answer);
 472         t->answer_rcode = DNS_PACKET_RCODE(p);
 473
 474         /* Only consider responses with equivalent query section to the request */
 475         if (p->question->n_keys != 1 || dns_resource_key_equal(p->question->keys[0], t->key) <= 0) {
 476                 dns_transaction_complete(t, DNS_TRANSACTION_INVALID_REPLY);
 477                 return;
 478         }
 479
 480         /* According to RFC 4795, section 2.9. only the RRs from the answer section shall be cached */
 481         if (DNS_PACKET_SHALL_CACHE(p))
 482                 dns_cache_put(&t->scope->cache, t->key, DNS_PACKET_RCODE(p), p->answer, DNS_PACKET_ANCOUNT(p), 0, p->family, &p->sender);
 483
 484         if (DNS_PACKET_RCODE(p) == DNS_RCODE_SUCCESS)
 485                 dns_transaction_complete(t, DNS_TRANSACTION_SUCCESS);
 486         else
 487                 dns_transaction_complete(t, DNS_TRANSACTION_FAILURE);
 488 }
 489
 490 static int on_dns_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 491         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 492         DnsTransaction *t = userdata;
 493         int r;
 494
 495         assert(t);
 496         assert(t->scope);
 497
 498         r = manager_recv(t->scope->manager, fd, DNS_PROTOCOL_DNS, &p);
 499         if (r <= 0)
 500                 return r;
 501
 502         if (dns_packet_validate_reply(p) > 0 &&
 503             DNS_PACKET_ID(p) == t->id)
 504                 dns_transaction_process_reply(t, p);
 505         else
 506                 log_debug("Invalid DNS packet.");
 507
 508         return 0;
 509 }
 510
 511 static int dns_transaction_emit(DnsTransaction *t) {
 512         int r;
 513
 514         assert(t);
 515
 516         if (t->scope->protocol == DNS_PROTOCOL_DNS && !t->server) {
 517                 DnsServer *server = NULL;
 518                 _cleanup_close_ int fd = -1;
 519
 520                 fd = dns_scope_udp_dns_socket(t->scope, &server);
 521                 if (fd < 0)
 522                         return fd;
 523
 524                 r = sd_event_add_io(t->scope->manager->event, &t->dns_udp_event_source, fd, EPOLLIN, on_dns_packet, t);
 525                 if (r < 0)
 526                         return r;
 527
 528                 t->dns_udp_fd = fd;
 529                 fd = -1;
 530                 t->server = dns_server_ref(server);
 531         }
 532
 533         r = dns_scope_emit(t->scope, t->dns_udp_fd, t->sent);
 534         if (r < 0)
 535                 return r;
 536
 537         return 0;
 538 }
 539
 540 static int on_transaction_timeout(sd_event_source *s, usec_t usec, void *userdata) {
 541         DnsTransaction *t = userdata;
 542         int r;
 543
 544         assert(s);
 545         assert(t);
 546
 547         /* Timeout reached? Try again, with a new server */
 548         dns_transaction_next_dns_server(t);
 549
 550         /* ... and possibly increased timeout */
 551         if (t->server)
 552                 dns_server_packet_lost(t->server, usec - t->start_usec);
 553         else
 554                 dns_scope_packet_lost(t->scope, usec - t->start_usec);
 555
 556         r = dns_transaction_go(t);
 557         if (r < 0)
 558                 dns_transaction_complete(t, DNS_TRANSACTION_RESOURCES);
 559
 560         return 0;
 561 }
 562
 563 static int dns_transaction_make_packet(DnsTransaction *t) {
 564         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 565         int r;
 566
 567         assert(t);
 568
 569         if (t->sent)
 570                 return 0;
 571
 572         r = dns_packet_new_query(&p, t->scope->protocol, 0);
 573         if (r < 0)
 574                 return r;
 575
 576         r = dns_scope_good_key(t->scope, t->key);
 577         if (r < 0)
 578                 return r;
 579         if (r == 0)
 580                 return -EDOM;
 581
 582         r = dns_packet_append_key(p, t->key, NULL);
 583         if (r < 0)
 584                 return r;
 585
 586         DNS_PACKET_HEADER(p)->qdcount = htobe16(1);
 587         DNS_PACKET_HEADER(p)->id = t->id;
 588
 589         t->sent = p;
 590         p = NULL;
 591
 592         return 0;
 593 }
 594
 595 static usec_t transaction_get_resend_timeout(DnsTransaction *t) {
 596         assert(t);
 597         assert(t->scope);
 598
 599         switch (t->scope->protocol) {
 600         case DNS_PROTOCOL_DNS:
 601                 assert(t->server);
 602
 603                 return t->server->resend_timeout;
 604         case DNS_PROTOCOL_LLMNR:
 605         case DNS_PROTOCOL_MDNS:
 606                 return t->scope->resend_timeout;
 607         default:
 608                 assert_not_reached("Invalid DNS protocol.");
 609         }
 610 }
 611
 612 int dns_transaction_go(DnsTransaction *t) {
 613         bool had_stream;
 614         usec_t ts;
 615         int r;
 616
 617         assert(t);
 618
 619         had_stream = !!t->stream;
 620
 621         dns_transaction_stop(t);
 622
 623         log_debug("Excercising transaction on scope %s on %s/%s",
 624                   dns_protocol_to_string(t->scope->protocol),
 625                   t->scope->link ? t->scope->link->name : "*",
 626                   t->scope->family == AF_UNSPEC ? "*" : af_to_name(t->scope->family));
 627
 628         if (t->n_attempts >= TRANSACTION_ATTEMPTS_MAX(t->scope->protocol)) {
 629                 dns_transaction_complete(t, DNS_TRANSACTION_ATTEMPTS_MAX_REACHED);
 630                 return 0;
 631         }
 632
 633         if (t->scope->protocol == DNS_PROTOCOL_LLMNR && had_stream) {
 634                 /* If we already tried via a stream, then we don't
 635                  * retry on LLMNR. See RFC 4795, Section 2.7. */
 636                 dns_transaction_complete(t, DNS_TRANSACTION_ATTEMPTS_MAX_REACHED);
 637                 return 0;
 638         }
 639
 640         assert_se(sd_event_now(t->scope->manager->event, clock_boottime_or_monotonic(), &ts) >= 0);
 641
 642         t->n_attempts++;
 643         t->start_usec = ts;
 644         t->received = dns_packet_unref(t->received);
 645         t->answer = dns_answer_unref(t->answer);
 646         t->answer_rcode = 0;
 647         t->answer_source = _DNS_TRANSACTION_SOURCE_INVALID;
 648
 649         /* Check the zone, but obly if this transaction is not used
 650          * for probing or verifying a zone item. */
 651         if (set_isempty(t->zone_items)) {
 652
 653                 r = dns_zone_lookup(&t->scope->zone, t->key, &t->answer, NULL, NULL);
 654                 if (r < 0)
 655                         return r;
 656                 if (r > 0) {
 657                         t->answer_rcode = DNS_RCODE_SUCCESS;
 658                         t->answer_source = DNS_TRANSACTION_ZONE;
 659                         dns_transaction_complete(t, DNS_TRANSACTION_SUCCESS);
 660                         return 0;
 661                 }
 662         }
 663
 664         /* Check the cache, but only if this transaction is not used
 665          * for probing or verifying a zone item. */
 666         if (set_isempty(t->zone_items)) {
 667
 668                 /* Before trying the cache, let's make sure we figured out a
 669                  * server to use. Should this cause a change of server this
 670                  * might flush the cache. */
 671                 dns_scope_get_dns_server(t->scope);
 672
 673                 /* Let's then prune all outdated entries */
 674                 dns_cache_prune(&t->scope->cache);
 675
 676                 r = dns_cache_lookup(&t->scope->cache, t->key, &t->answer_rcode, &t->answer);
 677                 if (r < 0)
 678                         return r;
 679                 if (r > 0) {
 680                         t->answer_source = DNS_TRANSACTION_CACHE;
 681                         if (t->answer_rcode == DNS_RCODE_SUCCESS)
 682                                 dns_transaction_complete(t, DNS_TRANSACTION_SUCCESS);
 683                         else
 684                                 dns_transaction_complete(t, DNS_TRANSACTION_FAILURE);
 685                         return 0;
 686                 }
 687         }
 688
 689         if (t->scope->protocol == DNS_PROTOCOL_LLMNR && !t->initial_jitter) {
 690                 usec_t jitter;
 691
 692                 /* RFC 4795 Section 2.7 suggests all queries should be
 693                  * delayed by a random time from 0 to JITTER_INTERVAL. */
 694
 695                 t->initial_jitter = true;
 696
 697                 random_bytes(&jitter, sizeof(jitter));
 698                 jitter %= LLMNR_JITTER_INTERVAL_USEC;
 699
 700                 r = sd_event_add_time(
 701                                 t->scope->manager->event,
 702                                 &t->timeout_event_source,
 703                                 clock_boottime_or_monotonic(),
 704                                 ts + jitter,
 705                                 LLMNR_JITTER_INTERVAL_USEC,
 706                                 on_transaction_timeout, t);
 707                 if (r < 0)
 708                         return r;
 709
 710                 t->n_attempts = 0;
 711                 t->state = DNS_TRANSACTION_PENDING;
 712
 713                 log_debug("Delaying LLMNR transaction for " USEC_FMT "us.", jitter);
 714                 return 0;
 715         }
 716
 717         /* Otherwise, we need to ask the network */
 718         r = dns_transaction_make_packet(t);
 719         if (r == -EDOM) {
 720                 /* Not the right request to make on this network?
 721                  * (i.e. an A request made on IPv6 or an AAAA request
 722                  * made on IPv4, on LLMNR or mDNS.) */
 723                 dns_transaction_complete(t, DNS_TRANSACTION_NO_SERVERS);
 724                 return 0;
 725         }
 726         if (r < 0)
 727                 return r;
 728
 729         if (t->scope->protocol == DNS_PROTOCOL_LLMNR &&
 730             (dns_name_endswith(DNS_RESOURCE_KEY_NAME(t->key), "in-addr.arpa") > 0 ||
 731              dns_name_endswith(DNS_RESOURCE_KEY_NAME(t->key), "ip6.arpa") > 0)) {
 732
 733                 /* RFC 4795, Section 2.4. says reverse lookups shall
 734                  * always be made via TCP on LLMNR */
 735                 r = dns_transaction_open_tcp(t);
 736         } else {
 737                 /* Try via UDP, and if that fails due to large size try via TCP */
 738                 r = dns_transaction_emit(t);
 739                 if (r == -EMSGSIZE)
 740                         r = dns_transaction_open_tcp(t);
 741         }
 742         if (r == -ESRCH) {
 743                 /* No servers to send this to? */
 744                 dns_transaction_complete(t, DNS_TRANSACTION_NO_SERVERS);
 745                 return 0;
 746         } else if (r < 0) {
 747                 if (t->scope->protocol != DNS_PROTOCOL_DNS) {
 748                         dns_transaction_complete(t, DNS_TRANSACTION_RESOURCES);
 749                         return 0;
 750                 }
 751
 752                 /* Couldn't send? Try immediately again, with a new server */
 753                 dns_transaction_next_dns_server(t);
 754
 755                 return dns_transaction_go(t);
 756         }
 757
 758         r = sd_event_add_time(
 759                         t->scope->manager->event,
 760                         &t->timeout_event_source,
 761                         clock_boottime_or_monotonic(),
 762                         ts + transaction_get_resend_timeout(t), 0,
 763                         on_transaction_timeout, t);
 764         if (r < 0)
 765                 return r;
 766
 767         t->state = DNS_TRANSACTION_PENDING;
 768         return 1;
 769 }
 770
 771 static const char* const dns_transaction_state_table[_DNS_TRANSACTION_STATE_MAX] = {
 772         [DNS_TRANSACTION_NULL] = "null",
 773         [DNS_TRANSACTION_PENDING] = "pending",
 774         [DNS_TRANSACTION_FAILURE] = "failure",
 775         [DNS_TRANSACTION_SUCCESS] = "success",
 776         [DNS_TRANSACTION_NO_SERVERS] = "no-servers",
 777         [DNS_TRANSACTION_TIMEOUT] = "timeout",
 778         [DNS_TRANSACTION_ATTEMPTS_MAX_REACHED] = "attempts-max-reached",
 779         [DNS_TRANSACTION_INVALID_REPLY] = "invalid-reply",
 780         [DNS_TRANSACTION_RESOURCES] = "resources",
 781         [DNS_TRANSACTION_ABORTED] = "aborted",
 782 };
 783 DEFINE_STRING_TABLE_LOOKUP(dns_transaction_state, DnsTransactionState);
 784
 785 static const char* const dns_transaction_source_table[_DNS_TRANSACTION_SOURCE_MAX] = {
 786         [DNS_TRANSACTION_NETWORK] = "network",
 787         [DNS_TRANSACTION_CACHE] = "cache",
 788         [DNS_TRANSACTION_ZONE] = "zone",
 789 };
 790 DEFINE_STRING_TABLE_LOOKUP(dns_transaction_source, DnsTransactionSource);