dns.c 52.7 KB
Newer Older
Roger Dingledine's avatar
Roger Dingledine committed
1
/* Copyright 2003-2004 Roger Dingledine.
2
 * Copyright 2004-2007 Roger Dingledine, Nick Mathewson. */
3
4
/* See LICENSE for licensing information */
/* $Id$ */
5
6
const char dns_c_id[] =
  "$Id$";
7

Roger Dingledine's avatar
Roger Dingledine committed
8
9
/**
 * \file dns.c
10
 * \brief Implements a local cache for DNS results for Tor servers.
Roger Dingledine's avatar
Roger Dingledine committed
11
 * This is implemented as a wrapper around Adam Langley's eventdns.c code.
12
13
 * (We can't just use gethostbyname() and friends because we really need to
 * be nonblocking.)
Roger Dingledine's avatar
Roger Dingledine committed
14
 **/
15

16
#include "or.h"
17
#include "../common/ht.h"
18
#include "eventdns.h"
19

Roger Dingledine's avatar
Roger Dingledine committed
20
/** Longest hostname we're willing to resolve. */
21
22
#define MAX_ADDRESSLEN 256

23
24
/** How long will we wait for an answer from the resolver before we decide
 * that the resolver is wedged? */
25
26
#define RESOLVE_MAX_TIMEOUT 300

Roger Dingledine's avatar
Roger Dingledine committed
27
/** Possible outcomes from hostname lookup: permanent failure,
28
 * transient (retryable) failure, and success. */
29
30
31
32
#define DNS_RESOLVE_FAILED_TRANSIENT 1
#define DNS_RESOLVE_FAILED_PERMANENT 2
#define DNS_RESOLVE_SUCCEEDED 3

33
34
35
36
37
38
39
40
/** Have we currently configured nameservers with eventdns? */
static int nameservers_configured = 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;
41

Roger Dingledine's avatar
Roger Dingledine committed
42
/** Linked list of connections waiting for a DNS answer. */
43
typedef struct pending_connection_t {
44
  edge_connection_t *conn;
45
  struct pending_connection_t *next;
46
} pending_connection_t;
47

48
49
/** Value of 'magic' field for cached_resolve_t.  Used to try to catch bad
 * pointers and memory stomping. */
50
51
#define CACHED_RESOLVE_MAGIC 0x1234F00D

52
53
54
55
56
57
58
/* Possible states for a cached resolve_t */
/** We are waiting for the resolver system to tell us an answer here.
 * When we get one, or when we time out, the state of this cached_resolve_t
 * will become "DONE" and we'll possibly add a CACHED_VALID or a CACHED_FAILED
 * entry. This cached_resolve_t will be in the hash table so that we will
 * know not to launch more requests for this addr, but rather to add more
 * connections to the pending list for the addr. */
59
#define CACHE_STATE_PENDING 0
60
61
62
/** This used to be a pending cached_resolve_t, and we got an answer for it.
 * Now we're waiting for this cached_resolve_t to expire.  This should
 * have no pending connections, and should not appear in the hash table. */
63
#define CACHE_STATE_DONE 1
64
65
/** We are caching an answer for this address. This should have no pending
 * connections, and should appear in the hash table. */
66
#define CACHE_STATE_CACHED_VALID 2
67
68
/** We are caching a failure for this address. This should have no pending
 * connections, and should appear in the hash table */
69
70
#define CACHE_STATE_CACHED_FAILED 3

Roger Dingledine's avatar
Roger Dingledine committed
71
/** A DNS request: possibly completed, possibly pending; cached_resolve
72
 * structs are stored at the OR side in a hash table, and as a linked
73
74
 * list from oldest to newest.
 */
75
typedef struct cached_resolve_t {
76
  HT_ENTRY(cached_resolve_t) node;
77
  uint32_t magic;
78
  char address[MAX_ADDRESSLEN]; /**< The hostname to be resolved. */
79
80
81
82
  union {
    uint32_t addr;  /**< IPv4 addr for <b>address</b>. */
    char *hostname; /**< Hostname for <b>address</b> (if a reverse lookup) */
  } result;
83
  uint8_t state; /**< Is this cached entry pending/done/valid/failed? */
84
  uint8_t is_reverse; /**< Is this a reverse (addr-to-hostname) lookup? */
85
  time_t expire; /**< Remove items from cache after this time. */
86
  uint32_t ttl; /**< What TTL did the nameserver tell us? */
87
  /** Connections that want to know when we get an answer for this resolve. */
88
89
  pending_connection_t *pending_connections;
} cached_resolve_t;
90

91
static void purge_expired_resolves(time_t now);
92
93
static void dns_found_answer(const char *address, int is_reverse,
                             uint32_t addr, const char *hostname, char outcome,
94
                             uint32_t ttl);
95
96
static void send_resolved_cell(edge_connection_t *conn, uint8_t answer_type);
static int launch_resolve(edge_connection_t *exitconn);
97
static void add_wildcarded_test_address(const char *address);
98
static int configure_nameservers(int force);
99
static int answer_is_wildcarded(const char *ip);
100
101
static int dns_resolve_impl(edge_connection_t *exitconn, int is_resolve,
                            or_circuit_t *oncirc, char **resolved_to_hostname);
102
#ifdef DEBUG_DNS_CACHE
103
static void _assert_cache_ok(void);
104
105
#define assert_cache_ok() _assert_cache_ok()
#else
106
#define assert_cache_ok() do {} while (0)
107
#endif
108
static void assert_resolve_ok(cached_resolve_t *resolve);
109

110
111
/** Hash table of cached_resolve objects. */
static HT_HEAD(cache_map, cached_resolve_t) cache_root;
112

Roger Dingledine's avatar
Roger Dingledine committed
113
/** Function to compare hashed resolves on their addresses; used to
114
 * implement hash tables. */
115
116
static INLINE int
cached_resolves_eq(cached_resolve_t *a, cached_resolve_t *b)
117
{
118
  /* make this smarter one day? */
119
  assert_resolve_ok(a); // Not b; b may be just a search.
120
121
122
  return !strncmp(a->address, b->address, MAX_ADDRESSLEN);
}

123
/** Hash function for cached_resolve objects */
124
125
126
127
static INLINE unsigned int
cached_resolve_hash(cached_resolve_t *a)
{
  return ht_string_hash(a->address);
128
129
}

130
HT_PROTOTYPE(cache_map, cached_resolve_t, node, cached_resolve_hash,
131
             cached_resolves_eq);
132
HT_GENERATE(cache_map, cached_resolve_t, node, cached_resolve_hash,
133
            cached_resolves_eq, 0.6, malloc, realloc, free);
134

135
/** Initialize the DNS cache. */
136
static void
137
init_cache_map(void)
138
{
139
  HT_INIT(cache_map, &cache_root);
140
141
}

142
/** Helper: called by eventdns when eventdns wants to log something. */
143
static void
144
evdns_log_cb(int warn, const char *msg)
145
{
146
  const char *cp;
147
148
  static int all_down = 0;
  int severity = warn ? LOG_WARN : LOG_INFO;
149
150
151
152
  if (!strcmpstart(msg, "Resolve requested for") &&
      get_options()->SafeLogging) {
    log(LOG_INFO, LD_EXIT, "eventdns: Resolve requested.");
    return;
153
154
  } else if (!strcmpstart(msg, "Search: ")) {
    return;
155
  }
156
157
158
  if (!strcmpstart(msg, "Nameserver ") && (cp=strstr(msg, " has failed: "))) {
    char *ns = tor_strndup(msg+11, cp-(msg+11));
    const char *err = strchr(cp, ':'+2);
159
160
161
    /* 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. */
162
    severity = LOG_INFO;
163
    control_event_server_status(LOG_NOTICE,
164
165
166
167
168
169
                                "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));
170
    severity = (all_down && warn) ? LOG_NOTICE : LOG_INFO;
171
    all_down = 0;
172
173
174
175
176
    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");
177
    all_down = 1;
178
  }
179
  log(severity, LD_EXIT, "eventdns: %s", msg);
180
181
}

Roger Dingledine's avatar
Roger Dingledine committed
182
/** Initialize the DNS subsystem; called by the OR process. */
183
int
184
185
dns_init(void)
{
186
  init_cache_map();
187
  if (server_mode(get_options()))
188
    return configure_nameservers(1);
189
  return 0;
190
}
191

192
193
194
/** Called when DNS-related options change (or may have changed).  Returns -1
 * on failure, 0 on success. */
int
195
196
197
198
dns_reset(void)
{
  or_options_t *options = get_options();
  if (! server_mode(options)) {
199
200
    evdns_clear_nameservers_and_suspend();
    evdns_search_clear();
201
202
203
204
205
    nameservers_configured = 0;
    tor_free(resolv_conf_fname);
    resolv_conf_mtime = 0;
  } else {
    if (configure_nameservers(0) < 0)
206
      return -1;
207
  }
208
  return 0;
209
210
}

211
212
/** Helper: Given a TTL from a DNS response, determine what TTL to give the
 * OP that asked us to resolve it. */
213
214
215
216
217
218
219
220
221
222
223
uint32_t
dns_clip_ttl(uint32_t ttl)
{
  if (ttl < MIN_DNS_TTL)
    return MIN_DNS_TTL;
  else if (ttl > MAX_DNS_TTL)
    return MAX_DNS_TTL;
  else
    return ttl;
}

224
225
/** Helper: Given a TTL from a DNS response, determine how long to hold it in
 * our cache. */
226
227
228
229
230
231
232
233
234
235
236
static uint32_t
dns_get_expiry_ttl(uint32_t ttl)
{
  if (ttl < MIN_DNS_TTL)
    return MIN_DNS_TTL;
  else if (ttl > MAX_DNS_ENTRY_AGE)
    return MAX_DNS_ENTRY_AGE;
  else
    return ttl;
}

237
/** Helper: free storage held by an entry in the DNS cache. */
238
static void
239
_free_cached_resolve(cached_resolve_t *r)
240
{
Nick Mathewson's avatar
Nick Mathewson committed
241
  while (r->pending_connections) {
242
    pending_connection_t *victim = r->pending_connections;
243
244
245
    r->pending_connections = victim->next;
    tor_free(victim);
  }
246
247
  if (r->is_reverse)
    tor_free(r->result.hostname);
248
  r->magic = 0xFF00FF00;
249
250
251
  tor_free(r);
}

252
253
254
/** 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. */
255
static int
256
_compare_cached_resolves_by_expiry(const void *_a, const void *_b)
257
{
258
  const cached_resolve_t *a = _a, *b = _b;
259
  return a->expire - b->expire;
260
261
}

262
263
/** Priority queue of cached_resolve_t objects to let us know when they
 * will expire. */
264
265
static smartlist_t *cached_resolve_pqueue = NULL;

266
267
/** Set an expiry time for a cached_resolve_t, and add it to the expiry
 * priority queue */
268
269
270
271
static void
set_expiry(cached_resolve_t *resolve, time_t expires)
{
  tor_assert(resolve && resolve->expire == 0);
272
273
  if (!cached_resolve_pqueue)
    cached_resolve_pqueue = smartlist_create();
274
275
276
277
278
279
  resolve->expire = expires;
  smartlist_pqueue_add(cached_resolve_pqueue,
                       _compare_cached_resolves_by_expiry,
                       resolve);
}

280
/** Free all storage held in the DNS cache and related structures. */
281
282
283
void
dns_free_all(void)
{
284
  cached_resolve_t **ptr, **next, *item;
285
  assert_cache_ok();
286
287
288
  if (cached_resolve_pqueue) {
    SMARTLIST_FOREACH(cached_resolve_pqueue, cached_resolve_t *, res,
      {
289
        if (res->state == CACHE_STATE_DONE)
290
291
292
          _free_cached_resolve(res);
      });
  }
293
  for (ptr = HT_START(cache_map, &cache_root); ptr != NULL; ptr = next) {
294
    item = *ptr;
295
    next = HT_NEXT_RMV(cache_map, &cache_root, ptr);
296
    _free_cached_resolve(item);
297
  }
298
  HT_CLEAR(cache_map, &cache_root);
299
300
  if (cached_resolve_pqueue)
    smartlist_free(cached_resolve_pqueue);
301
  cached_resolve_pqueue = NULL;
302
  tor_free(resolv_conf_fname);
303
304
}

Nick Mathewson's avatar
Nick Mathewson committed
305
/** Remove every cached_resolve whose <b>expire</b> time is before <b>now</b>
306
 * from the cache. */
307
static void
308
purge_expired_resolves(time_t now)
309
{
Nick Mathewson's avatar
Nick Mathewson committed
310
  cached_resolve_t *resolve, *removed;
311
  pending_connection_t *pend;
312
  edge_connection_t *pendconn;
313

Nick Mathewson's avatar
Nick Mathewson committed
314
  assert_cache_ok();
315
316
317
318
319
320
321
322
323
324
  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);

325
    if (resolve->state == CACHE_STATE_PENDING) {
326
      log_debug(LD_EXIT,
327
328
                "Expiring a dns resolve %s that's still pending. Forgot to "
                "cull it? DNS resolve didn't tell us about the timeout?",
329
330
331
332
333
334
335
336
337
338
339
                escaped_safe_str(resolve->address));
    } else if (resolve->state == CACHE_STATE_CACHED_VALID ||
               resolve->state == CACHE_STATE_CACHED_FAILED) {
      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);
340
    }
341

342
    if (resolve->pending_connections) {
343
      log_debug(LD_EXIT,
344
                "Closing pending connections on timed-out DNS resolve!");
345
      tor_fragile_assert();
346
347
348
349
      while (resolve->pending_connections) {
        pend = resolve->pending_connections;
        resolve->pending_connections = pend->next;
        /* Connections should only be pending if they have no socket. */
350
        tor_assert(pend->conn->_base.s == -1);
351
        pendconn = pend->conn;
352
        connection_edge_end(pendconn, END_STREAM_REASON_TIMEOUT);
353
        circuit_detach_stream(circuit_get_by_edge_conn(pendconn), pendconn);
354
        connection_free(TO_CONN(pendconn));
355
356
        tor_free(pend);
      }
357
    }
358

359
360
361
362
363
364
365
    if (resolve->state == CACHE_STATE_CACHED_VALID ||
        resolve->state == CACHE_STATE_CACHED_FAILED ||
        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).",
366
367
                resolve->address, (void*)resolve,
                removed ? removed->address : "NULL", (void*)remove);
368
369
      }
      tor_assert(removed == resolve);
370
371
      if (resolve->is_reverse)
        tor_free(resolve->result.hostname);
372
373
374
      resolve->magic = 0xF0BBF0BB;
      tor_free(resolve);
    } else {
375
      /* This should be in state DONE. Make sure it's not in the cache. */
376
377
      cached_resolve_t *tmp = HT_FIND(cache_map, &cache_root, resolve);
      tor_assert(tmp != resolve);
378
    }
379
  }
380

Nick Mathewson's avatar
Nick Mathewson committed
381
  assert_cache_ok();
382
383
}

384
385
386
/** Send a response to the RESOLVE request of a connection.
 * <b>answer_type</b> must be one of
 * RESOLVED_TYPE_(IPV4|ERROR|ERROR_TRANSIENT).
387
388
 *
 * If <b>circ</b> is provided, and we have a cached answer, send the
389
390
 * answer back along circ; otherwise, send the answer back along
 * <b>conn</b>'s attached circuit.
391
 */
392
static void
393
send_resolved_cell(edge_connection_t *conn, uint8_t answer_type)
394
395
{
  char buf[RELAY_PAYLOAD_SIZE];
396
  size_t buflen;
397
  uint32_t ttl;
398
399

  buf[0] = answer_type;
400
  ttl = dns_clip_ttl(conn->address_ttl);
401
402
403
404
405

  switch (answer_type)
    {
    case RESOLVED_TYPE_IPV4:
      buf[1] = 4;
406
      set_uint32(buf+2, htonl(conn->_base.addr));
407
      set_uint32(buf+6, htonl(ttl));
408
      buflen = 10;
409
410
411
      break;
    case RESOLVED_TYPE_ERROR_TRANSIENT:
    case RESOLVED_TYPE_ERROR:
412
413
414
      {
        const char *errmsg = "Error resolving hostname";
        int msglen = strlen(errmsg);
415

416
417
        buf[1] = msglen;
        strlcpy(buf+2, errmsg, sizeof(buf)-2);
418
        set_uint32(buf+2+msglen, htonl(ttl));
419
420
421
        buflen = 6+msglen;
        break;
      }
422
423
    default:
      tor_assert(0);
424
      return;
425
    }
426
  // log_notice(LD_EXIT, "Sending a regular RESOLVED reply: ");
Roger Dingledine's avatar
Roger Dingledine committed
427

428
  connection_edge_send_command(conn, RELAY_COMMAND_RESOLVED, buf, buflen);
429
430
}

431
432
433
/** 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.
434
435
436
 *
 * If <b>circ</b> is provided, and we have a cached answer, send the
 * answer back along circ; otherwise, send the answer back along
437
 * <b>conn</b>'s attached circuit.
438
439
 */
static void
440
send_resolved_hostname_cell(edge_connection_t *conn, const char *hostname)
441
442
443
444
445
{
  char buf[RELAY_PAYLOAD_SIZE];
  size_t buflen;
  uint32_t ttl;
  size_t namelen = strlen(hostname);
446
  tor_assert(hostname);
447
448
449
450
451
452
453
454
455
456

  tor_assert(namelen < 256);
  ttl = dns_clip_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;

457
  // log_notice(LD_EXIT, "Sending a reply RESOLVED reply: %s", hostname);
458
  connection_edge_send_command(conn, RELAY_COMMAND_RESOLVED, buf, buflen);
459
  // log_notice(LD_EXIT, "Sent");
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
}

/** Given a lower-case <b>address</b>, check to see whether it's a
 * 1.2.3.4.in-addr.arpa address used for reverse lookups.  If so,
 * parse it and place the address in <b>in</b> if present. Return 1 on success;
 * 0 if the address is not in in-addr.arpa format, and -1 if the address is
 * malformed. */
static int
parse_inaddr_arpa_address(const char *address, struct in_addr *in)
{
  char buf[INET_NTOA_BUF_LEN];
  char *cp;
  size_t len;
  struct in_addr inaddr;

  cp = strstr(address, ".in-addr.arpa");
  if (!cp || *(cp+strlen(".in-addr.arpa")))
    return 0; /* not an .in-addr.arpa address  */

  len = cp - address;

  if (len >= INET_NTOA_BUF_LEN)
    return -1; /* Too long. */

484
  memcpy(buf, address, len);
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
  buf[len] = '\0';
  if (tor_inet_aton(buf, &inaddr) == 0)
    return -1; /* malformed. */

  if (in) {
    uint32_t a;
    /* reverse the bytes */
    a = (  ((inaddr.s_addr & 0x000000fful) << 24)
          |((inaddr.s_addr & 0x0000ff00ul) << 8)
          |((inaddr.s_addr & 0x00ff0000ul) >> 8)
          |((inaddr.s_addr & 0xff000000ul) >> 24));
    inaddr.s_addr = a;

    memcpy(in, &inaddr, sizeof(inaddr));
  }

  return 1;
}

Nick Mathewson's avatar
Nick Mathewson committed
504
505
/** 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.
506
 * If resolve failed, unlink exitconn if needed, free it, and return -1.
507
 *
508
509
510
511
512
 * (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.)
 *
513
 * If we have a cached answer, send the answer back along <b>exitconn</b>'s
514
 * circuit.
515
 *
516
517
518
519
520
 * 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.
521
522
523
524
525
526
 *
 * 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.
527
 */
528
int
529
dns_resolve(edge_connection_t *exitconn)
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
{
  or_circuit_t *oncirc = TO_OR_CIRCUIT(exitconn->on_circuit);
  int is_resolve, r;
  char *hostname = NULL;
  is_resolve = exitconn->_base.purpose == EXIT_PURPOSE_RESOLVE;

  r = dns_resolve_impl(exitconn, is_resolve, oncirc, &hostname);
  switch (r) {
    case 1:
      if (is_resolve) {
        if (hostname)
          send_resolved_hostname_cell(exitconn, hostname);
        else
          send_resolved_cell(exitconn, RESOLVED_TYPE_IPV4);
      } else {
        exitconn->next_stream = oncirc->n_streams;
        oncirc->n_streams = exitconn;
      }
      break;
    case 0:
      exitconn->_base.state = EXIT_CONN_STATE_RESOLVING;
      exitconn->next_stream = oncirc->resolving_streams;
      oncirc->resolving_streams = exitconn;
      break;
    case -2:
    case -1:
      if (is_resolve) {
        send_resolved_cell(exitconn,
             (r == -1) ? RESOLVED_TYPE_ERROR : RESOLVED_TYPE_ERROR_TRANSIENT);
      }
      //circuit_detach_stream(TO_CIRCUIT(oncirc), exitconn);
      exitconn->on_circuit = NULL;
      if (!exitconn->_base.marked_for_close)
        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,
 *
 * Returns -2 on a transient error.  Sets *<b>hostname_out</b> to a newly
 * allocated string holding a cached reverse DNS value, if any.
 */
static int
dns_resolve_impl(edge_connection_t *exitconn, int is_resolve,
                 or_circuit_t *oncirc, char **hostname_out)
584
{
585
586
587
  cached_resolve_t *resolve;
  cached_resolve_t search;
  pending_connection_t *pending_connection;
588
  struct in_addr in;
589
  time_t now = time(NULL);
590
  int is_reverse = 0, r;
591
592
  assert_connection_ok(TO_CONN(exitconn), 0);
  tor_assert(exitconn->_base.s == -1);
593
  assert_cache_ok();
594
  tor_assert(oncirc);
595

596
  /* first check if exitconn->_base.address is an IP. If so, we already
597
   * know the answer. */
598
599
  if (tor_inet_aton(exitconn->_base.address, &in) != 0) {
    exitconn->_base.addr = ntohl(in.s_addr);
600
    exitconn->address_ttl = DEFAULT_DNS_TTL;
601
    return 1;
602
  }
603
604
605
606
607
608
  if (address_is_invalid_destination(exitconn->_base.address, 0)) {
    log(LOG_PROTOCOL_WARN, LD_EXIT,
        "Rejecting invalid destination address %s",
        escaped_safe_str(exitconn->_base.address));
    return -1;
  }
609
610

  /* then take this opportunity to see if there are any expired
611
   * resolves in the hash table. */
612
  purge_expired_resolves(now);
613

614
615
  /* lower-case exitconn->_base.address, so it's in canonical form */
  tor_strlower(exitconn->_base.address);
616

617
618
  /* 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
619
   * connection.
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
   */
  if ((r = parse_inaddr_arpa_address(exitconn->_base.address, NULL)) != 0) {
    if (r == 1)
      is_reverse = 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;
    }
637
    //log_notice(LD_EXIT, "Looks like an address %s",
Roger Dingledine's avatar
Roger Dingledine committed
638
    //exitconn->_base.address);
639
640
  }

641
  /* now check the hash table to see if 'address' is already there. */
642
  strlcpy(search.address, exitconn->_base.address, sizeof(search.address));
643
  resolve = HT_FIND(cache_map, &cache_root, &search);
644
  if (resolve && resolve->expire > now) { /* already there */
645
    switch (resolve->state) {
646
647
      case CACHE_STATE_PENDING:
        /* add us to the pending list */
648
        pending_connection = tor_malloc_zero(
649
                                      sizeof(pending_connection_t));
650
        pending_connection->conn = exitconn;
Roger Dingledine's avatar
   
Roger Dingledine committed
651
652
        pending_connection->next = resolve->pending_connections;
        resolve->pending_connections = pending_connection;
653
        log_debug(LD_EXIT,"Connection (fd %d) waiting for pending DNS "
654
655
                  "resolve of %s", exitconn->_base.s,
                  escaped_safe_str(exitconn->_base.address));
Roger Dingledine's avatar
   
Roger Dingledine committed
656
        return 0;
657
      case CACHE_STATE_CACHED_VALID:
658
        log_debug(LD_EXIT,"Connection (fd %d) found cached answer for %s",
659
                  exitconn->_base.s,
660
661
662
663
                  escaped_safe_str(resolve->address));
        exitconn->address_ttl = resolve->ttl;
        if (resolve->is_reverse) {
          tor_assert(is_resolve);
664
          *hostname_out = tor_strdup(resolve->result.hostname);
665
666
        } else {
          exitconn->_base.addr = resolve->result.addr;
667
        }
668
        return 1;
669
      case CACHE_STATE_CACHED_FAILED:
670
        log_debug(LD_EXIT,"Connection (fd %d) found cached error for %s",
671
672
                  exitconn->_base.s,
                  escaped_safe_str(exitconn->_base.address));
673
        return -1;
674
675
676
      case CACHE_STATE_DONE:
        log_err(LD_BUG, "Found a 'DONE' dns resolve still in the cache.");
        tor_fragile_assert();
677
    }
Roger Dingledine's avatar
Roger Dingledine committed
678
    tor_assert(0);
Roger Dingledine's avatar
Roger Dingledine committed
679
680
  }
  /* not there, need to add it */
681
  resolve = tor_malloc_zero(sizeof(cached_resolve_t));
682
  resolve->magic = CACHED_RESOLVE_MAGIC;
Roger Dingledine's avatar
Roger Dingledine committed
683
  resolve->state = CACHE_STATE_PENDING;
684
  resolve->is_reverse = is_reverse;
685
  strlcpy(resolve->address, exitconn->_base.address, sizeof(resolve->address));
Roger Dingledine's avatar
Roger Dingledine committed
686

687
  /* add this connection to the pending list */
688
  pending_connection = tor_malloc_zero(sizeof(pending_connection_t));
Roger Dingledine's avatar
Roger Dingledine committed
689
690
691
  pending_connection->conn = exitconn;
  resolve->pending_connections = pending_connection;

692
  /* Add this resolve to the cache and priority queue. */
693
  HT_INSERT(cache_map, &cache_root, resolve);
694
  set_expiry(resolve, now + RESOLVE_MAX_TIMEOUT);
695

696
  log_debug(LD_EXIT,"Launching %s.",
697
            escaped_safe_str(exitconn->_base.address));
698
  assert_cache_ok();
699

700
  return launch_resolve(exitconn);
701
702
}

703
/** Log an error and abort if conn is waiting for a DNS resolve.
704
 */
705
void
706
assert_connection_edge_not_dns_pending(edge_connection_t *conn)
707
{
708
709
  pending_connection_t *pend;
  cached_resolve_t **resolve;
710

711
712
713
714
715
716
  HT_FOREACH(resolve, cache_map, &cache_root) {
    for (pend = (*resolve)->pending_connections;
         pend;
         pend = pend->next) {
      tor_assert(pend->conn != conn);
    }
717
  }
718
}
719

720
721
722
723
724
725
726
/** Log an error and abort if any connection waiting for a DNS resolve is
 * corrupted. */
void
assert_all_pending_dns_resolves_ok(void)
{
  pending_connection_t *pend;
  cached_resolve_t **resolve;
727

728
729
730
731
  HT_FOREACH(resolve, cache_map, &cache_root) {
    for (pend = (*resolve)->pending_connections;
         pend;
         pend = pend->next) {
732
733
734
      assert_connection_ok(TO_CONN(pend->conn), 0);
      tor_assert(pend->conn->_base.s == -1);
      tor_assert(!connection_in_array(TO_CONN(pend->conn)));
735
    }
736
737
738
  }
}

Nick Mathewson's avatar
Nick Mathewson committed
739
/** Remove <b>conn</b> from the list of connections waiting for conn-\>address.
740
 */
741
void
742
connection_dns_remove(edge_connection_t *conn)
743
{
744
745
746
  pending_connection_t *pend, *victim;
  cached_resolve_t search;
  cached_resolve_t *resolve;
747

748
749
  tor_assert(conn->_base.type == CONN_TYPE_EXIT);
  tor_assert(conn->_base.state == EXIT_CONN_STATE_RESOLVING);
750

751
  strlcpy(search.address, conn->_base.address, sizeof(search.address));
752

753
  resolve = HT_FIND(cache_map, &cache_root, &search);
754
  if (!resolve) {
755
    log_notice(LD_BUG, "Address %s is not pending. Dropping.",
756
               escaped_safe_str(conn->_base.address));
757
758
759
    return;
  }

Roger Dingledine's avatar
Roger Dingledine committed
760
  tor_assert(resolve->pending_connections);
761
  assert_connection_ok(TO_CONN(conn),0);
762
763
764

  pend = resolve->pending_connections;

765
  if (pend->conn == conn) {
766
    resolve->pending_connections = pend->next;
767
    tor_free(pend);
768
    log_debug(LD_EXIT, "First connection (fd %d) no longer waiting "
769
              "for resolve of %s",
770
              conn->_base.s, escaped_safe_str(conn->_base.address));
771
772
    return;
  } else {
773
774
    for ( ; pend->next; pend = pend->next) {
      if (pend->next->conn == conn) {
775
776
        victim = pend->next;
        pend->next = victim->next;
777
        tor_free(victim);
778
        log_debug(LD_EXIT,
779
                  "Connection (fd %d) no longer waiting for resolve of %s",
780
                  conn->_base.s, escaped_safe_str(conn->_base.address));
781
782
783
        return; /* more are pending */
      }
    }
Roger Dingledine's avatar
Roger Dingledine committed
784
    tor_assert(0); /* not reachable unless onlyconn not in pending list */
785
786
787
  }
}

Nick Mathewson's avatar
Nick Mathewson committed
788
789
790
/** Mark all connections waiting for <b>address</b> for close.  Then cancel
 * the resolve for <b>address</b> itself, and remove any cached results for
 * <b>address</b> from the cache.
791
 */
792
void
793
dns_cancel_pending_resolve(const char *address)
794
{
795
796
  pending_connection_t *pend;
  cached_resolve_t search;
797
  cached_resolve_t *resolve, *tmp;
798
  edge_connection_t *pendconn;
799
  circuit_t *circ;
800

Nick Mathewson's avatar
Nick Mathewson committed
801
  strlcpy(search.address, address, sizeof(search.address));
802

803
  resolve = HT_FIND(cache_map, &cache_root, &search);
804
  if (!resolve || resolve->state != CACHE_STATE_PENDING) {
805
806
    log_notice(LD_BUG,"Address %s is not pending. Dropping.",
               escaped_safe_str(address));
807
808
809
    return;
  }

810
811
  if (!resolve->pending_connections) {
    /* XXX this should never trigger, but sometimes it does */
812
    log_warn(LD_BUG,
813
             "Address %s is pending but has no pending connections!",
814
             escaped_safe_str(address));
815
    tor_fragile_assert();
816
817
    return;
  }
Roger Dingledine's avatar
Roger Dingledine committed
818
  tor_assert(resolve->pending_connections);
819

820
  /* mark all pending connections to fail */
821
  log_debug(LD_EXIT,
822
823
             "Failing all connections waiting on DNS resolve of %s",
             escaped_safe_str(address));
824
  while (resolve->pending_connections) {
825
    pend = resolve->pending_connections;
826
    pend->conn->_base.state = EXIT_CONN_STATE_RESOLVEFAILED;
827
    pendconn = pend->conn;
828
829
830
    assert_connection_ok(TO_CONN(pendconn), 0);
    tor_assert(pendconn->_base.s == -1);
    if (!pendconn->_base.marked_for_close) {
831
      connection_edge_end(pendconn, END_STREAM_REASON_RESOURCELIMIT);
832
    }
833
    circ = circuit_get_by_edge_conn(pendconn);
834
835
    if (circ)
      circuit_detach_stream(circ, pendconn);
836
837
    if (!pendconn->_base.marked_for_close)
      connection_free(TO_CONN(pendconn));
838
839
    resolve->pending_connections = pend->next;
    tor_free(pend);
840
841
  }

Nick Mathewson's avatar
Nick Mathewson committed
842
  tmp = HT_REMOVE(cache_map, &cache_root, resolve);
843
844
845
  if (tmp != resolve) {
    log_err(LD_BUG, "The cancelled resolve we purged didn't match any in"
            " the cache. Tried to purge %s (%p); instead got %s (%p).",
846
847
            resolve->address, (void*)resolve,
            tmp ? tmp->address : "NULL", (void*)tmp);
848
  }
Nick Mathewson's avatar
Nick Mathewson committed
849
  tor_assert(tmp == resolve);
850
851

  resolve->state = CACHE_STATE_DONE;
852
853
}

854
/** Helper: adds an entry to the DNS cache mapping <b>address</b> to the ipv4
855
856
 * address <b>addr</b> (if is_reverse is 0) or the hostname <b>hostname</b> (if
 * is_reverse is 1).  <b>ttl</b> is a cache ttl; <b>outcome</b> is one of
857
858
 * DNS_RESOLVE_{FAILED_TRANSIENT|FAILED_PERMANENT|SUCCEEDED}.
 **/
859
static void
860
861
add_answer_to_cache(const char *address, int is_reverse, uint32_t addr,
                    const char *hostname, char outcome, uint32_t ttl)
862
863
864
865
866
{
  cached_resolve_t *resolve;
  if (outcome == DNS_RESOLVE_FAILED_TRANSIENT)
    return;

867
868
869
870
  //log_notice(LD_EXIT, "Adding to cache: %s -> %s (%lx, %s), %d",
  //           address, is_reverse?"(reverse)":"", (unsigned long)addr,
  //           hostname?hostname:"NULL",(int)outcome);

871
872
873
874
875
  resolve = tor_malloc_zero(sizeof(cached_resolve_t));
  resolve->magic = CACHED_RESOLVE_MAGIC;
  resolve->state = (outcome == DNS_RESOLVE_SUCCEEDED) ?
    CACHE_STATE_CACHED_VALID : CACHE_STATE_CACHED_FAILED;
  strlcpy(resolve->address, address, sizeof(resolve->address));
876
  resolve->is_reverse = is_reverse;
877
  if (is_reverse) {
878
879
880
881
882
883
884
    if (outcome == DNS_RESOLVE_SUCCEEDED) {
      tor_assert(hostname);
      resolve->result.hostname = tor_strdup(hostname);
    } else {
      tor_assert(! hostname);
      resolve->result.hostname = NULL;
    }
885
886
887
888
  } else {
    tor_assert(!hostname);
    resolve->result.addr = addr;
  }
889
890
891
892
893
894
  resolve->ttl = ttl;
  assert_resolve_ok(resolve);
  HT_INSERT(cache_map, &cache_root, resolve);
  set_expiry(resolve, time(NULL) + dns_get_expiry_ttl(ttl));
}

895
896
/** Return true iff <b>address</b> is one of the addresses we use to verify
 * that well-known sites aren't being hijacked by our DNS servers. */
897
898
899
900
901
902
903
904
static INLINE int
is_test_address(const char *address)
{
  or_options_t *options = get_options();
  return options->ServerDNSTestAddresses &&
    smartlist_string_isin_case(options->ServerDNSTestAddresses, address);
}

905
906
907
908
909
/** Called on the OR side when a DNS worker or the eventdns library tells us
 * the outcome of a DNS resolve: tell all pending connections about the result
 * of the lookup, and cache the value.  (<b>address</b> is a NUL-terminated
 * string containing the address to look up; <b>addr</b> is an IPv4 address in
 * host order; <b>outcome</b> is one of
Nick Mathewson's avatar
Nick Mathewson committed
910
 * DNS_RESOLVE_{FAILED_TRANSIENT|FAILED_PERMANENT|SUCCEEDED}.
911
 */
912
static void
913
914
dns_found_answer(const char *address, int is_reverse, uint32_t addr,
                 const char *hostname, char outcome, uint32_t ttl)
915
{
916
917
  pending_connection_t *pend;
  cached_resolve_t search;
Nick Mathewson's avatar