-
Notifications
You must be signed in to change notification settings - Fork 930
/
dns.c
2209 lines (1984 loc) · 75.1 KB
/
dns.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* Copyright (c) 2003-2004, Roger Dingledine.
* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
* Copyright (c) 2007-2020, The Tor Project, Inc. */
/* See LICENSE for licensing information */
/**
* \file dns.c
* \brief Implements a local cache for DNS results for Tor servers.
* This is implemented as a wrapper around Adam Langley's eventdns.c code.
* (We can't just use gethostbyname() and friends because we really need to
* be nonblocking.)
*
* There are three main cases when a Tor relay uses dns.c to launch a DNS
* request:
* <ol>
* <li>To check whether the DNS server is working more or less correctly.
* This happens via dns_launch_correctness_checks(). The answer is
* reported in the return value from later calls to
* dns_seems_to_be_broken().
* <li>When a client has asked the relay, in a RELAY_BEGIN cell, to connect
* to a given server by hostname. This happens via dns_resolve().
* <li>When a client has asked the relay, in a RELAY_RESOLVE cell, to look
* up a given server's IP address(es) by hostname. This also happens via
* dns_resolve().
* </ol>
*
* Each of these gets handled a little differently.
*
* To check for correctness, we look up some hostname we expect to exist and
* have real entries, some hostnames which we expect to definitely not exist,
* and some hostnames that we expect to probably not exist. If too many of
* the hostnames that shouldn't exist do exist, that's a DNS hijacking
* attempt. If too many of the hostnames that should exist have the same
* addresses as the ones that shouldn't exist, that's a very bad DNS hijacking
* attempt, or a very naughty captive portal. And if the hostnames that
* should exist simply don't exist, we probably have a broken nameserver.
*
* To handle client requests, we first check our cache for answers. If there
* isn't something up-to-date, we've got to launch A or AAAA requests as
* appropriate. How we handle responses to those in particular is a bit
* complex; see dns_lookup() and set_exitconn_info_from_resolve().
*
* When a lookup is finally complete, the inform_pending_connections()
* function will tell all of the streams that have been waiting for the
* resolve, by calling connection_exit_connect() if the client sent a
* RELAY_BEGIN cell, and by calling send_resolved_cell() or
* send_hostname_cell() if the client sent a RELAY_RESOLVE cell.
**/
#define DNS_PRIVATE
#include "core/or/or.h"
#include "app/config/config.h"
#include "core/mainloop/connection.h"
#include "core/mainloop/mainloop.h"
#include "core/mainloop/netstatus.h"
#include "core/or/circuitlist.h"
#include "core/or/circuituse.h"
#include "core/or/connection_edge.h"
#include "core/or/policies.h"
#include "core/or/relay.h"
#include "feature/control/control_events.h"
#include "feature/relay/dns.h"
#include "feature/relay/router.h"
#include "feature/relay/routermode.h"
#include "lib/crypt_ops/crypto_rand.h"
#include "lib/evloop/compat_libevent.h"
#include "lib/sandbox/sandbox.h"
#include "core/or/edge_connection_st.h"
#include "core/or/or_circuit_st.h"
#include "ht.h"
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#include <event2/event.h>
#include <event2/dns.h>
/** How long will we wait for an answer from the resolver before we decide
* that the resolver is wedged? */
#define RESOLVE_MAX_TIMEOUT 300
/** Our evdns_base; this structure handles all our name lookups. */
static struct evdns_base *the_evdns_base = NULL;
/** Have we currently configured nameservers with eventdns? */
static int nameservers_configured = 0;
/** Did our most recent attempt to configure nameservers with eventdns fail? */
static int nameserver_config_failed = 0;
/** What was the resolv_conf fname we last used when configuring the
* nameservers? Used to check whether we need to reconfigure. */
static char *resolv_conf_fname = NULL;
/** What was the mtime on the resolv.conf file we last used when configuring
* the nameservers? Used to check whether we need to reconfigure. */
static time_t resolv_conf_mtime = 0;
static void purge_expired_resolves(time_t now);
static void dns_found_answer(const char *address, uint8_t query_type,
int dns_answer,
const tor_addr_t *addr,
const char *hostname,
uint32_t ttl);
static void add_wildcarded_test_address(const char *address);
static int configure_nameservers(int force);
static int answer_is_wildcarded(const char *ip);
static int evdns_err_is_transient(int err);
static void inform_pending_connections(cached_resolve_t *resolve);
static void make_pending_resolve_cached(cached_resolve_t *cached);
#ifdef DEBUG_DNS_CACHE
static void assert_cache_ok_(void);
#define assert_cache_ok() assert_cache_ok_()
#else
#define assert_cache_ok() STMT_NIL
#endif /* defined(DEBUG_DNS_CACHE) */
static void assert_resolve_ok(cached_resolve_t *resolve);
/** Hash table of cached_resolve objects. */
static HT_HEAD(cache_map, cached_resolve_t) cache_root;
/** Global: how many IPv6 requests have we made in all? */
static uint64_t n_ipv6_requests_made = 0;
/** Global: how many IPv6 requests have timed out? */
static uint64_t n_ipv6_timeouts = 0;
/** Global: Do we think that IPv6 DNS is broken? */
static int dns_is_broken_for_ipv6 = 0;
/** Function to compare hashed resolves on their addresses; used to
* implement hash tables. */
static inline int
cached_resolves_eq(cached_resolve_t *a, cached_resolve_t *b)
{
/* make this smarter one day? */
assert_resolve_ok(a); // Not b; b may be just a search.
return !strncmp(a->address, b->address, MAX_ADDRESSLEN);
}
/** Hash function for cached_resolve objects */
static inline unsigned int
cached_resolve_hash(cached_resolve_t *a)
{
return (unsigned) siphash24g((const uint8_t*)a->address, strlen(a->address));
}
HT_PROTOTYPE(cache_map, cached_resolve_t, node, cached_resolve_hash,
cached_resolves_eq)
HT_GENERATE2(cache_map, cached_resolve_t, node, cached_resolve_hash,
cached_resolves_eq, 0.6, tor_reallocarray_, tor_free_)
/** Initialize the DNS cache. */
static void
init_cache_map(void)
{
HT_INIT(cache_map, &cache_root);
}
/** Helper: called by eventdns when eventdns wants to log something. */
static void
evdns_log_cb(int warn, const char *msg)
{
const char *cp;
static int all_down = 0;
int severity = warn ? LOG_WARN : LOG_INFO;
if (!strcmpstart(msg, "Resolve requested for") &&
get_options()->SafeLogging) {
log_info(LD_EXIT, "eventdns: Resolve requested.");
return;
} else if (!strcmpstart(msg, "Search: ")) {
return;
}
if (!strcmpstart(msg, "Nameserver ") && (cp=strstr(msg, " has failed: "))) {
char *ns = tor_strndup(msg+11, cp-(msg+11));
const char *colon = strchr(cp, ':');
tor_assert(colon);
const char *err = colon+2;
/* Don't warn about a single failed nameserver; we'll warn with 'all
* nameservers have failed' if we're completely out of nameservers;
* otherwise, the situation is tolerable. */
severity = LOG_INFO;
control_event_server_status(LOG_NOTICE,
"NAMESERVER_STATUS NS=%s STATUS=DOWN ERR=%s",
ns, escaped(err));
tor_free(ns);
} else if (!strcmpstart(msg, "Nameserver ") &&
(cp=strstr(msg, " is back up"))) {
char *ns = tor_strndup(msg+11, cp-(msg+11));
severity = (all_down && warn) ? LOG_NOTICE : LOG_INFO;
all_down = 0;
control_event_server_status(LOG_NOTICE,
"NAMESERVER_STATUS NS=%s STATUS=UP", ns);
tor_free(ns);
} else if (!strcmp(msg, "All nameservers have failed")) {
control_event_server_status(LOG_WARN, "NAMESERVER_ALL_DOWN");
all_down = 1;
} else if (!strcmpstart(msg, "Address mismatch on received DNS")) {
static ratelim_t mismatch_limit = RATELIM_INIT(3600);
const char *src = strstr(msg, " Apparent source");
if (!src || get_options()->SafeLogging) {
src = "";
}
log_fn_ratelim(&mismatch_limit, severity, LD_EXIT,
"eventdns: Received a DNS packet from "
"an IP address to which we did not send a request. This "
"could be a DNS spoofing attempt, or some kind of "
"misconfiguration.%s", src);
return;
}
tor_log(severity, LD_EXIT, "eventdns: %s", msg);
}
/** Helper: passed to eventdns.c as a callback so it can generate random
* numbers for transaction IDs and 0x20-hack coding. */
static void
dns_randfn_(char *b, size_t n)
{
crypto_rand(b,n);
}
/** Initialize the DNS subsystem; called by the OR process. */
int
dns_init(void)
{
init_cache_map();
evdns_set_random_bytes_fn(dns_randfn_);
if (server_mode(get_options())) {
int r = configure_nameservers(1);
return r;
}
return 0;
}
/** Called when DNS-related options change (or may have changed). Returns -1
* on failure, 0 on success. */
int
dns_reset(void)
{
const or_options_t *options = get_options();
if (! server_mode(options)) {
if (!the_evdns_base) {
if (!(the_evdns_base = evdns_base_new(tor_libevent_get_base(), 0))) {
log_err(LD_BUG, "Couldn't create an evdns_base");
return -1;
}
}
evdns_base_clear_nameservers_and_suspend(the_evdns_base);
evdns_base_search_clear(the_evdns_base);
nameservers_configured = 0;
tor_free(resolv_conf_fname);
resolv_conf_mtime = 0;
} else {
if (configure_nameservers(0) < 0) {
return -1;
}
}
return 0;
}
/** Return true iff the most recent attempt to initialize the DNS subsystem
* failed. */
int
has_dns_init_failed(void)
{
return nameserver_config_failed;
}
/** Helper: free storage held by an entry in the DNS cache. */
static void
free_cached_resolve_(cached_resolve_t *r)
{
if (!r)
return;
while (r->pending_connections) {
pending_connection_t *victim = r->pending_connections;
r->pending_connections = victim->next;
tor_free(victim);
}
if (r->res_status_hostname == RES_STATUS_DONE_OK)
tor_free(r->result_ptr.hostname);
r->magic = 0xFF00FF00;
tor_free(r);
}
/** Compare two cached_resolve_t pointers by expiry time, and return
* less-than-zero, zero, or greater-than-zero as appropriate. Used for
* the priority queue implementation. */
static int
compare_cached_resolves_by_expiry_(const void *_a, const void *_b)
{
const cached_resolve_t *a = _a, *b = _b;
if (a->expire < b->expire)
return -1;
else if (a->expire == b->expire)
return 0;
else
return 1;
}
/** Priority queue of cached_resolve_t objects to let us know when they
* will expire. */
static smartlist_t *cached_resolve_pqueue = NULL;
static void
cached_resolve_add_answer(cached_resolve_t *resolve,
int query_type,
int dns_result,
const tor_addr_t *answer_addr,
const char *answer_hostname,
uint32_t ttl)
{
if (query_type == DNS_PTR) {
if (resolve->res_status_hostname != RES_STATUS_INFLIGHT)
return;
if (dns_result == DNS_ERR_NONE && answer_hostname) {
resolve->result_ptr.hostname = tor_strdup(answer_hostname);
resolve->res_status_hostname = RES_STATUS_DONE_OK;
} else {
resolve->result_ptr.err_hostname = dns_result;
resolve->res_status_hostname = RES_STATUS_DONE_ERR;
}
resolve->ttl_hostname = ttl;
} else if (query_type == DNS_IPv4_A) {
if (resolve->res_status_ipv4 != RES_STATUS_INFLIGHT)
return;
if (dns_result == DNS_ERR_NONE && answer_addr &&
tor_addr_family(answer_addr) == AF_INET) {
resolve->result_ipv4.addr_ipv4 = tor_addr_to_ipv4h(answer_addr);
resolve->res_status_ipv4 = RES_STATUS_DONE_OK;
} else {
resolve->result_ipv4.err_ipv4 = dns_result;
resolve->res_status_ipv4 = RES_STATUS_DONE_ERR;
}
resolve->ttl_ipv4 = ttl;
} else if (query_type == DNS_IPv6_AAAA) {
if (resolve->res_status_ipv6 != RES_STATUS_INFLIGHT)
return;
if (dns_result == DNS_ERR_NONE && answer_addr &&
tor_addr_family(answer_addr) == AF_INET6) {
memcpy(&resolve->result_ipv6.addr_ipv6,
tor_addr_to_in6(answer_addr),
sizeof(struct in6_addr));
resolve->res_status_ipv6 = RES_STATUS_DONE_OK;
} else {
resolve->result_ipv6.err_ipv6 = dns_result;
resolve->res_status_ipv6 = RES_STATUS_DONE_ERR;
}
resolve->ttl_ipv6 = ttl;
}
}
/** Return true iff there are no in-flight requests for <b>resolve</b>. */
static int
cached_resolve_have_all_answers(const cached_resolve_t *resolve)
{
return (resolve->res_status_ipv4 != RES_STATUS_INFLIGHT &&
resolve->res_status_ipv6 != RES_STATUS_INFLIGHT &&
resolve->res_status_hostname != RES_STATUS_INFLIGHT);
}
/** Set an expiry time for a cached_resolve_t, and add it to the expiry
* priority queue */
static void
set_expiry(cached_resolve_t *resolve, time_t expires)
{
tor_assert(resolve && resolve->expire == 0);
if (!cached_resolve_pqueue)
cached_resolve_pqueue = smartlist_new();
resolve->expire = expires;
smartlist_pqueue_add(cached_resolve_pqueue,
compare_cached_resolves_by_expiry_,
offsetof(cached_resolve_t, minheap_idx),
resolve);
}
/** Free all storage held in the DNS cache and related structures. */
void
dns_free_all(void)
{
cached_resolve_t **ptr, **next, *item;
assert_cache_ok();
if (cached_resolve_pqueue) {
SMARTLIST_FOREACH(cached_resolve_pqueue, cached_resolve_t *, res,
{
if (res->state == CACHE_STATE_DONE)
free_cached_resolve_(res);
});
}
for (ptr = HT_START(cache_map, &cache_root); ptr != NULL; ptr = next) {
item = *ptr;
next = HT_NEXT_RMV(cache_map, &cache_root, ptr);
free_cached_resolve_(item);
}
HT_CLEAR(cache_map, &cache_root);
smartlist_free(cached_resolve_pqueue);
cached_resolve_pqueue = NULL;
tor_free(resolv_conf_fname);
}
/** Remove every cached_resolve whose <b>expire</b> time is before or
* equal to <b>now</b> from the cache. */
static void
purge_expired_resolves(time_t now)
{
cached_resolve_t *resolve, *removed;
pending_connection_t *pend;
edge_connection_t *pendconn;
assert_cache_ok();
if (!cached_resolve_pqueue)
return;
while (smartlist_len(cached_resolve_pqueue)) {
resolve = smartlist_get(cached_resolve_pqueue, 0);
if (resolve->expire > now)
break;
smartlist_pqueue_pop(cached_resolve_pqueue,
compare_cached_resolves_by_expiry_,
offsetof(cached_resolve_t, minheap_idx));
if (resolve->state == CACHE_STATE_PENDING) {
log_debug(LD_EXIT,
"Expiring a dns resolve %s that's still pending. Forgot to "
"cull it? DNS resolve didn't tell us about the timeout?",
escaped_safe_str(resolve->address));
} else if (resolve->state == CACHE_STATE_CACHED) {
log_debug(LD_EXIT,
"Forgetting old cached resolve (address %s, expires %lu)",
escaped_safe_str(resolve->address),
(unsigned long)resolve->expire);
tor_assert(!resolve->pending_connections);
} else {
tor_assert(resolve->state == CACHE_STATE_DONE);
tor_assert(!resolve->pending_connections);
}
if (resolve->pending_connections) {
log_debug(LD_EXIT,
"Closing pending connections on timed-out DNS resolve!");
while (resolve->pending_connections) {
pend = resolve->pending_connections;
resolve->pending_connections = pend->next;
/* Connections should only be pending if they have no socket. */
tor_assert(!SOCKET_OK(pend->conn->base_.s));
pendconn = pend->conn;
/* Prevent double-remove */
pendconn->base_.state = EXIT_CONN_STATE_RESOLVEFAILED;
if (!pendconn->base_.marked_for_close) {
connection_edge_end(pendconn, END_STREAM_REASON_TIMEOUT);
circuit_detach_stream(circuit_get_by_edge_conn(pendconn), pendconn);
connection_free_(TO_CONN(pendconn));
}
tor_free(pend);
}
}
if (resolve->state == CACHE_STATE_CACHED ||
resolve->state == CACHE_STATE_PENDING) {
removed = HT_REMOVE(cache_map, &cache_root, resolve);
if (removed != resolve) {
log_err(LD_BUG, "The expired resolve we purged didn't match any in"
" the cache. Tried to purge %s (%p); instead got %s (%p).",
resolve->address, (void*)resolve,
removed ? removed->address : "NULL", (void*)removed);
}
tor_assert(removed == resolve);
} else {
/* This should be in state DONE. Make sure it's not in the cache. */
cached_resolve_t *tmp = HT_FIND(cache_map, &cache_root, resolve);
tor_assert(tmp != resolve);
}
if (resolve->res_status_hostname == RES_STATUS_DONE_OK)
tor_free(resolve->result_ptr.hostname);
resolve->magic = 0xF0BBF0BB;
tor_free(resolve);
}
assert_cache_ok();
}
/* argument for send_resolved_cell only, meaning "let the answer type be ipv4
* or ipv6 depending on the connection's address". */
#define RESOLVED_TYPE_AUTO 0xff
/** Send a response to the RESOLVE request of a connection.
* <b>answer_type</b> must be one of
* RESOLVED_TYPE_(AUTO|ERROR|ERROR_TRANSIENT|).
*
* If <b>circ</b> is provided, and we have a cached answer, send the
* answer back along circ; otherwise, send the answer back along
* <b>conn</b>'s attached circuit.
*/
MOCK_IMPL(STATIC void,
send_resolved_cell,(edge_connection_t *conn, uint8_t answer_type,
const cached_resolve_t *resolved))
{
char buf[RELAY_PAYLOAD_SIZE], *cp = buf;
size_t buflen = 0;
uint32_t ttl;
buf[0] = answer_type;
ttl = clip_dns_ttl(conn->address_ttl);
switch (answer_type)
{
case RESOLVED_TYPE_AUTO:
if (resolved && resolved->res_status_ipv4 == RES_STATUS_DONE_OK) {
cp[0] = RESOLVED_TYPE_IPV4;
cp[1] = 4;
set_uint32(cp+2, htonl(resolved->result_ipv4.addr_ipv4));
set_uint32(cp+6, htonl(ttl));
cp += 10;
}
if (resolved && resolved->res_status_ipv6 == RES_STATUS_DONE_OK) {
const uint8_t *bytes = resolved->result_ipv6.addr_ipv6.s6_addr;
cp[0] = RESOLVED_TYPE_IPV6;
cp[1] = 16;
memcpy(cp+2, bytes, 16);
set_uint32(cp+18, htonl(ttl));
cp += 22;
}
if (cp != buf) {
buflen = cp - buf;
break;
} else {
answer_type = RESOLVED_TYPE_ERROR;
/* fall through. */
}
/* Falls through. */
case RESOLVED_TYPE_ERROR_TRANSIENT:
case RESOLVED_TYPE_ERROR:
{
const char *errmsg = "Error resolving hostname";
size_t msglen = strlen(errmsg);
buf[0] = answer_type;
buf[1] = msglen;
strlcpy(buf+2, errmsg, sizeof(buf)-2);
set_uint32(buf+2+msglen, htonl(ttl));
buflen = 6+msglen;
break;
}
default:
tor_assert(0);
return;
}
// log_notice(LD_EXIT, "Sending a regular RESOLVED reply: ");
connection_edge_send_command(conn, RELAY_COMMAND_RESOLVED, buf, buflen);
}
/** Send a response to the RESOLVE request of a connection for an in-addr.arpa
* address on connection <b>conn</b> which yielded the result <b>hostname</b>.
* The answer type will be RESOLVED_HOSTNAME.
*
* If <b>circ</b> is provided, and we have a cached answer, send the
* answer back along circ; otherwise, send the answer back along
* <b>conn</b>'s attached circuit.
*/
MOCK_IMPL(STATIC void,
send_resolved_hostname_cell,(edge_connection_t *conn,
const char *hostname))
{
char buf[RELAY_PAYLOAD_SIZE];
size_t buflen;
uint32_t ttl;
if (BUG(!hostname))
return;
size_t namelen = strlen(hostname);
tor_assert(namelen < 256);
ttl = clip_dns_ttl(conn->address_ttl);
buf[0] = RESOLVED_TYPE_HOSTNAME;
buf[1] = (uint8_t)namelen;
memcpy(buf+2, hostname, namelen);
set_uint32(buf+2+namelen, htonl(ttl));
buflen = 2+namelen+4;
// log_notice(LD_EXIT, "Sending a reply RESOLVED reply: %s", hostname);
connection_edge_send_command(conn, RELAY_COMMAND_RESOLVED, buf, buflen);
// log_notice(LD_EXIT, "Sent");
}
/** See if we have a cache entry for <b>exitconn</b>-\>address. If so,
* if resolve valid, put it into <b>exitconn</b>-\>addr and return 1.
* If resolve failed, free exitconn and return -1.
*
* (For EXIT_PURPOSE_RESOLVE connections, send back a RESOLVED error cell
* on returning -1. For EXIT_PURPOSE_CONNECT connections, there's no
* need to send back an END cell, since connection_exit_begin_conn will
* do that for us.)
*
* If we have a cached answer, send the answer back along <b>exitconn</b>'s
* circuit.
*
* Else, if seen before and pending, add conn to the pending list,
* and return 0.
*
* Else, if not seen before, add conn to pending list, hand to
* dns farm, and return 0.
*
* Exitconn's on_circuit field must be set, but exitconn should not
* yet be linked onto the n_streams/resolving_streams list of that circuit.
* On success, link the connection to n_streams if it's an exit connection.
* On "pending", link the connection to resolving streams. Otherwise,
* clear its on_circuit field.
*/
int
dns_resolve(edge_connection_t *exitconn)
{
or_circuit_t *oncirc = TO_OR_CIRCUIT(exitconn->on_circuit);
int is_resolve, r;
int made_connection_pending = 0;
char *hostname = NULL;
cached_resolve_t *resolve = NULL;
is_resolve = exitconn->base_.purpose == EXIT_PURPOSE_RESOLVE;
r = dns_resolve_impl(exitconn, is_resolve, oncirc, &hostname,
&made_connection_pending, &resolve);
switch (r) {
case 1:
/* We got an answer without a lookup -- either the answer was
* cached, or it was obvious (like an IP address). */
if (is_resolve) {
/* Send the answer back right now, and detach. */
if (hostname)
send_resolved_hostname_cell(exitconn, hostname);
else
send_resolved_cell(exitconn, RESOLVED_TYPE_AUTO, resolve);
exitconn->on_circuit = NULL;
} else {
/* Add to the n_streams list; the calling function will send back a
* connected cell. */
exitconn->next_stream = oncirc->n_streams;
oncirc->n_streams = exitconn;
}
break;
case 0:
/* The request is pending: add the connection into the linked list of
* resolving_streams on this circuit. */
exitconn->base_.state = EXIT_CONN_STATE_RESOLVING;
exitconn->next_stream = oncirc->resolving_streams;
oncirc->resolving_streams = exitconn;
break;
case -2:
case -1:
/* The request failed before it could start: cancel this connection,
* and stop everybody waiting for the same connection. */
if (is_resolve) {
send_resolved_cell(exitconn,
(r == -1) ? RESOLVED_TYPE_ERROR : RESOLVED_TYPE_ERROR_TRANSIENT,
NULL);
}
exitconn->on_circuit = NULL;
dns_cancel_pending_resolve(exitconn->base_.address);
if (!made_connection_pending && !exitconn->base_.marked_for_close) {
/* If we made the connection pending, then we freed it already in
* dns_cancel_pending_resolve(). If we marked it for close, it'll
* get freed from the main loop. Otherwise, can free it now. */
connection_free_(TO_CONN(exitconn));
}
break;
default:
tor_assert(0);
}
tor_free(hostname);
return r;
}
/** Helper function for dns_resolve: same functionality, but does not handle:
* - marking connections on error and clearing their on_circuit
* - linking connections to n_streams/resolving_streams,
* - sending resolved cells if we have an answer/error right away,
*
* Return -2 on a transient error. If it's a reverse resolve and it's
* successful, sets *<b>hostname_out</b> to a newly allocated string
* holding the cached reverse DNS value.
*
* Set *<b>made_connection_pending_out</b> to true if we have placed
* <b>exitconn</b> on the list of pending connections for some resolve; set it
* to false otherwise.
*
* Set *<b>resolve_out</b> to a cached resolve, if we found one.
*/
MOCK_IMPL(STATIC int,
dns_resolve_impl,(edge_connection_t *exitconn, int is_resolve,
or_circuit_t *oncirc, char **hostname_out,
int *made_connection_pending_out,
cached_resolve_t **resolve_out))
{
cached_resolve_t *resolve;
cached_resolve_t search;
pending_connection_t *pending_connection;
int is_reverse = 0;
tor_addr_t addr;
time_t now = time(NULL);
int r;
assert_connection_ok(TO_CONN(exitconn), 0);
tor_assert(!SOCKET_OK(exitconn->base_.s));
assert_cache_ok();
tor_assert(oncirc);
*made_connection_pending_out = 0;
/* first check if exitconn->base_.address is an IP. If so, we already
* know the answer. */
if (tor_addr_parse(&addr, exitconn->base_.address) >= 0) {
if (tor_addr_family(&addr) == AF_INET ||
tor_addr_family(&addr) == AF_INET6) {
tor_addr_copy(&exitconn->base_.addr, &addr);
exitconn->address_ttl = DEFAULT_DNS_TTL;
return 1;
} else {
/* XXXX unspec? Bogus? */
return -1;
}
}
/* If we're a non-exit, don't even do DNS lookups. */
if (router_my_exit_policy_is_reject_star())
return -1;
if (address_is_invalid_destination(exitconn->base_.address, 0)) {
tor_log(LOG_PROTOCOL_WARN, LD_EXIT,
"Rejecting invalid destination address %s",
escaped_safe_str(exitconn->base_.address));
return -1;
}
/* then take this opportunity to see if there are any expired
* resolves in the hash table. */
purge_expired_resolves(now);
/* lower-case exitconn->base_.address, so it's in canonical form */
tor_strlower(exitconn->base_.address);
/* Check whether this is a reverse lookup. If it's malformed, or it's a
* .in-addr.arpa address but this isn't a resolve request, kill the
* connection.
*/
if ((r = tor_addr_parse_PTR_name(&addr, exitconn->base_.address,
AF_UNSPEC, 0)) != 0) {
if (r == 1) {
is_reverse = 1;
if (tor_addr_is_internal(&addr, 0)) /* internal address? */
return -1;
}
if (!is_reverse || !is_resolve) {
if (!is_reverse)
log_info(LD_EXIT, "Bad .in-addr.arpa address \"%s\"; sending error.",
escaped_safe_str(exitconn->base_.address));
else if (!is_resolve)
log_info(LD_EXIT,
"Attempt to connect to a .in-addr.arpa address \"%s\"; "
"sending error.",
escaped_safe_str(exitconn->base_.address));
return -1;
}
//log_notice(LD_EXIT, "Looks like an address %s",
//exitconn->base_.address);
}
exitconn->is_reverse_dns_lookup = is_reverse;
/* now check the hash table to see if 'address' is already there. */
strlcpy(search.address, exitconn->base_.address, sizeof(search.address));
resolve = HT_FIND(cache_map, &cache_root, &search);
if (resolve && resolve->expire > now) { /* already there */
switch (resolve->state) {
case CACHE_STATE_PENDING:
/* add us to the pending list */
pending_connection = tor_malloc_zero(
sizeof(pending_connection_t));
pending_connection->conn = exitconn;
pending_connection->next = resolve->pending_connections;
resolve->pending_connections = pending_connection;
*made_connection_pending_out = 1;
log_debug(LD_EXIT,"Connection (fd "TOR_SOCKET_T_FORMAT") waiting "
"for pending DNS resolve of %s", exitconn->base_.s,
escaped_safe_str(exitconn->base_.address));
return 0;
case CACHE_STATE_CACHED:
log_debug(LD_EXIT,"Connection (fd "TOR_SOCKET_T_FORMAT") found "
"cached answer for %s",
exitconn->base_.s,
escaped_safe_str(resolve->address));
*resolve_out = resolve;
return set_exitconn_info_from_resolve(exitconn, resolve, hostname_out);
case CACHE_STATE_DONE:
log_err(LD_BUG, "Found a 'DONE' dns resolve still in the cache.");
tor_fragile_assert();
}
tor_assert(0);
}
tor_assert(!resolve);
/* not there, need to add it */
resolve = tor_malloc_zero(sizeof(cached_resolve_t));
resolve->magic = CACHED_RESOLVE_MAGIC;
resolve->state = CACHE_STATE_PENDING;
resolve->minheap_idx = -1;
strlcpy(resolve->address, exitconn->base_.address, sizeof(resolve->address));
/* add this connection to the pending list */
pending_connection = tor_malloc_zero(sizeof(pending_connection_t));
pending_connection->conn = exitconn;
resolve->pending_connections = pending_connection;
*made_connection_pending_out = 1;
/* Add this resolve to the cache and priority queue. */
HT_INSERT(cache_map, &cache_root, resolve);
set_expiry(resolve, now + RESOLVE_MAX_TIMEOUT);
log_debug(LD_EXIT,"Launching %s.",
escaped_safe_str(exitconn->base_.address));
assert_cache_ok();
return launch_resolve(resolve);
}
/** Given an exit connection <b>exitconn</b>, and a cached_resolve_t
* <b>resolve</b> whose DNS lookups have all either succeeded or failed,
* update the appropriate fields (address_ttl and addr) of <b>exitconn</b>.
*
* The logic can be complicated here, since we might have launched both
* an A lookup and an AAAA lookup, and since either of those might have
* succeeded or failed, and since we want to answer a RESOLVE cell with
* a full answer but answer a BEGIN cell with whatever answer the client
* would accept <i>and</i> we could still connect to.
*
* If this is a reverse lookup, set *<b>hostname_out</b> to a newly allocated
* copy of the name resulting hostname.
*
* Return -2 on a transient error, -1 on a permenent error, and 1 on
* a successful lookup.
*/
MOCK_IMPL(STATIC int,
set_exitconn_info_from_resolve,(edge_connection_t *exitconn,
const cached_resolve_t *resolve,
char **hostname_out))
{
int ipv4_ok, ipv6_ok, answer_with_ipv4, r;
uint32_t begincell_flags;
const int is_resolve = exitconn->base_.purpose == EXIT_PURPOSE_RESOLVE;
tor_assert(exitconn);
tor_assert(resolve);
if (exitconn->is_reverse_dns_lookup) {
exitconn->address_ttl = resolve->ttl_hostname;
if (resolve->res_status_hostname == RES_STATUS_DONE_OK) {
*hostname_out = tor_strdup(resolve->result_ptr.hostname);
return 1;
} else {
return -1;
}
}
/* If we're here then the connection wants one or either of ipv4, ipv6, and
* we can give it one or both. */
if (is_resolve) {
begincell_flags = BEGIN_FLAG_IPV6_OK;
} else {
begincell_flags = exitconn->begincell_flags;
}
ipv4_ok = (resolve->res_status_ipv4 == RES_STATUS_DONE_OK) &&
! (begincell_flags & BEGIN_FLAG_IPV4_NOT_OK);
ipv6_ok = (resolve->res_status_ipv6 == RES_STATUS_DONE_OK) &&
(begincell_flags & BEGIN_FLAG_IPV6_OK) &&
get_options()->IPv6Exit;
/* Now decide which one to actually give. */
if (ipv4_ok && ipv6_ok && is_resolve) {
answer_with_ipv4 = 1;
} else if (ipv4_ok && ipv6_ok) {
/* If we have both, see if our exit policy has an opinion. */
const uint16_t port = exitconn->base_.port;
int ipv4_allowed, ipv6_allowed;
tor_addr_t a4, a6;
tor_addr_from_ipv4h(&a4, resolve->result_ipv4.addr_ipv4);
tor_addr_from_in6(&a6, &resolve->result_ipv6.addr_ipv6);
ipv4_allowed = !router_compare_to_my_exit_policy(&a4, port);
ipv6_allowed = !router_compare_to_my_exit_policy(&a6, port);
if (ipv4_allowed && !ipv6_allowed) {
answer_with_ipv4 = 1;
} else if (ipv6_allowed && !ipv4_allowed) {
answer_with_ipv4 = 0;
} else {
/* Our exit policy would permit both. Answer with whichever the user
* prefers */
answer_with_ipv4 = !(begincell_flags &
BEGIN_FLAG_IPV6_PREFERRED);
}
} else {
/* Otherwise if one is okay, send it back. */
if (ipv4_ok) {
answer_with_ipv4 = 1;
} else if (ipv6_ok) {
answer_with_ipv4 = 0;
} else {
/* Neither one was okay. Choose based on user preference. */
answer_with_ipv4 = !(begincell_flags &
BEGIN_FLAG_IPV6_PREFERRED);
}
}
/* Finally, we write the answer back. */
r = 1;
if (answer_with_ipv4) {
if (resolve->res_status_ipv4 == RES_STATUS_DONE_OK) {
tor_addr_from_ipv4h(&exitconn->base_.addr,
resolve->result_ipv4.addr_ipv4);
} else {
r = evdns_err_is_transient(resolve->result_ipv4.err_ipv4) ? -2 : -1;
}
exitconn->address_ttl = resolve->ttl_ipv4;
} else {
if (resolve->res_status_ipv6 == RES_STATUS_DONE_OK) {
tor_addr_from_in6(&exitconn->base_.addr,
&resolve->result_ipv6.addr_ipv6);
} else {
r = evdns_err_is_transient(resolve->result_ipv6.err_ipv6) ? -2 : -1;
}
exitconn->address_ttl = resolve->ttl_ipv6;
}
return r;
}
/** Log an error and abort if conn is waiting for a DNS resolve.
*/
void
assert_connection_edge_not_dns_pending(edge_connection_t *conn)
{
pending_connection_t *pend;
cached_resolve_t search;
#if 1
cached_resolve_t *resolve;
strlcpy(search.address, conn->base_.address, sizeof(search.address));
resolve = HT_FIND(cache_map, &cache_root, &search);
if (!resolve)
return;
for (pend = resolve->pending_connections; pend; pend = pend->next) {
tor_assert(pend->conn != conn);
}
#else /* !(1) */
cached_resolve_t **resolve;
HT_FOREACH(resolve, cache_map, &cache_root) {
for (pend = (*resolve)->pending_connections; pend; pend = pend->next) {
tor_assert(pend->conn != conn);
}
}
#endif /* 1 */
}
/** Remove <b>conn</b> from the list of connections waiting for conn-\>address.
*/
void
connection_dns_remove(edge_connection_t *conn)
{
pending_connection_t *pend, *victim;
cached_resolve_t search;
cached_resolve_t *resolve;
tor_assert(conn->base_.type == CONN_TYPE_EXIT);
tor_assert(conn->base_.state == EXIT_CONN_STATE_RESOLVING);
strlcpy(search.address, conn->base_.address, sizeof(search.address));
resolve = HT_FIND(cache_map, &cache_root, &search);
if (!resolve) {
log_notice(LD_BUG, "Address %s is not pending. Dropping.",
escaped_safe_str(conn->base_.address));
return;
}
tor_assert(resolve->pending_connections);
assert_connection_ok(TO_CONN(conn),0);
pend = resolve->pending_connections;
if (pend->conn == conn) {