dns.c 53.2 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
{
  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;
562
      if (!exitconn->_base.marked_for_close) {
563
        connection_free(TO_CONN(exitconn));
564
        //XXX020 ... and we just leak exitconn otherwise? -RD
565
566
567
        // If it's marked for close, it's on closeable_connection_lst in
        // main.c.  If it's on the closeable list, it will get freed from
        // main.c. -NM
568
569
        // "<armadev> If that's true, there are other bugs arond, where we
        //  don't check if it's marked, and will end up double-freeing."
570
      }
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
      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)
591
{
592
593
594
  cached_resolve_t *resolve;
  cached_resolve_t search;
  pending_connection_t *pending_connection;
595
  struct in_addr in;
596
  time_t now = time(NULL);
597
  int is_reverse = 0, r;
598
599
  assert_connection_ok(TO_CONN(exitconn), 0);
  tor_assert(exitconn->_base.s == -1);
600
  assert_cache_ok();
601
  tor_assert(oncirc);
602

603
  /* first check if exitconn->_base.address is an IP. If so, we already
604
   * know the answer. */
605
606
  if (tor_inet_aton(exitconn->_base.address, &in) != 0) {
    exitconn->_base.addr = ntohl(in.s_addr);
607
    exitconn->address_ttl = DEFAULT_DNS_TTL;
608
    return 1;
609
  }
610
611
612
613
614
615
  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;
  }
616
617

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

621
622
  /* lower-case exitconn->_base.address, so it's in canonical form */
  tor_strlower(exitconn->_base.address);
623

624
625
  /* 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
626
   * connection.
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
   */
  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;
    }
644
    //log_notice(LD_EXIT, "Looks like an address %s",
Roger Dingledine's avatar
Roger Dingledine committed
645
    //exitconn->_base.address);
646
647
  }

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

694
  /* add this connection to the pending list */
695
  pending_connection = tor_malloc_zero(sizeof(pending_connection_t));
Roger Dingledine's avatar
Roger Dingledine committed
696
697
698
  pending_connection->conn = exitconn;
  resolve->pending_connections = pending_connection;

699
  /* Add this resolve to the cache and priority queue. */
700
  HT_INSERT(cache_map, &cache_root, resolve);
701
  set_expiry(resolve, now + RESOLVE_MAX_TIMEOUT);
702

703
  log_debug(LD_EXIT,"Launching %s.",
704
            escaped_safe_str(exitconn->_base.address));
705
  assert_cache_ok();
706

707
  return launch_resolve(exitconn);
708
709
}

710
/** Log an error and abort if conn is waiting for a DNS resolve.
711
 */
712
void
713
assert_connection_edge_not_dns_pending(edge_connection_t *conn)
714
{
715
716
  pending_connection_t *pend;
  cached_resolve_t **resolve;
717

718
719
720
721
722
723
  HT_FOREACH(resolve, cache_map, &cache_root) {
    for (pend = (*resolve)->pending_connections;
         pend;
         pend = pend->next) {
      tor_assert(pend->conn != conn);
    }
724
  }
725
}
726

727
728
729
730
731
732
733
/** 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;
734

735
736
737
738
  HT_FOREACH(resolve, cache_map, &cache_root) {
    for (pend = (*resolve)->pending_connections;
         pend;
         pend = pend->next) {
739
740
741
      assert_connection_ok(TO_CONN(pend->conn), 0);
      tor_assert(pend->conn->_base.s == -1);
      tor_assert(!connection_in_array(TO_CONN(pend->conn)));
742
    }
743
744
745
  }
}

Nick Mathewson's avatar
Nick Mathewson committed
746
/** Remove <b>conn</b> from the list of connections waiting for conn-\>address.
747
 */
748
void
749
connection_dns_remove(edge_connection_t *conn)
750
{
751
752
753
  pending_connection_t *pend, *victim;
  cached_resolve_t search;
  cached_resolve_t *resolve;
754

755
756
  tor_assert(conn->_base.type == CONN_TYPE_EXIT);
  tor_assert(conn->_base.state == EXIT_CONN_STATE_RESOLVING);
757

758
  strlcpy(search.address, conn->_base.address, sizeof(search.address));
759

760
  resolve = HT_FIND(cache_map, &cache_root, &search);
761
  if (!resolve) {
762
    log_notice(LD_BUG, "Address %s is not pending. Dropping.",
763
               escaped_safe_str(conn->_base.address));
764
765
766
    return;
  }

Roger Dingledine's avatar
Roger Dingledine committed
767
  tor_assert(resolve->pending_connections);
768
  assert_connection_ok(TO_CONN(conn),0);
769
770
771

  pend = resolve->pending_connections;

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

Nick Mathewson's avatar
Nick Mathewson committed
795
796
797
/** 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.
798
 */
799
void
800
dns_cancel_pending_resolve(const char *address)
801
{
802
803
  pending_connection_t *pend;
  cached_resolve_t search;
804
  cached_resolve_t *resolve, *tmp;
805
  edge_connection_t *pendconn;
806
  circuit_t *circ;
807

Nick Mathewson's avatar
Nick Mathewson committed
808
  strlcpy(search.address, address, sizeof(search.address));
809

810
  resolve = HT_FIND(cache_map, &cache_root, &search);
811
  if (!resolve || resolve->state != CACHE_STATE_PENDING) {
812
813
    log_notice(LD_BUG,"Address %s is not pending. Dropping.",
               escaped_safe_str(address));
814
815
816
    return;
  }

817
818
  if (!resolve->pending_connections) {
    /* XXX this should never trigger, but sometimes it does */
819
    /* XXXX020 is the above still true? -NM */
820
    log_warn(LD_BUG,
821
             "Address %s is pending but has no pending connections!",
822
             escaped_safe_str(address));
823
    tor_fragile_assert();
824
825
    return;
  }
Roger Dingledine's avatar
Roger Dingledine committed
826
  tor_assert(resolve->pending_connections);
827

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

Nick Mathewson's avatar
Nick Mathewson committed
850
  tmp = HT_REMOVE(cache_map, &cache_root, resolve);
851
852
853
  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).",
854
855
            resolve->address, (void*)resolve,
            tmp ? tmp->address : "NULL", (void*)tmp);
856
  }
Nick Mathewson's avatar
Nick Mathewson committed
857
  tor_assert(tmp == resolve);
858
859

  resolve->state = CACHE_STATE_DONE;
860
861
}

862
/** Helper: adds an entry to the DNS cache mapping <b>address</b> to the ipv4
863
864
 * 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
865
866
 * DNS_RESOLVE_{FAILED_TRANSIENT|FAILED_PERMANENT|SUCCEEDED}.
 **/
867
static void
868
869
add_answer_to_cache(const char *address, int is_reverse, uint32_t addr,
                    const char *hostname, char outcome, uint32_t ttl)
870
871
872
873
874
{
  cached_resolve_t *resolve;
  if (outcome == DNS_RESOLVE_FAILED_TRANSIENT)
    return;

875
876
877
878
  //log_notice(LD_EXIT, "Adding to cache: %s -> %s (%lx, %s), %d",
  //           address, is_reverse?"(reverse)":"", (unsigned long)addr,
  //           hostname?hostname:"NULL",(int)outcome);

879
880
881
882
883
  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));
884
  resolve->is_reverse = is_reverse;
885
  if (is_reverse) {
886
887
888
889
890
891
892
    if (outcome == DNS_RESOLVE_SUCCEEDED) {
      tor_assert(hostname);
      resolve->result.hostname = tor_strdup(hostname);
    } else {
      tor_assert(! hostname);
      resolve->result.hostname = NULL;
    }
893
894
895
896
  } else {
    tor_assert(!hostname);
    resolve->result.addr = addr;
  }
897
898
899
900
901
902
  resolve->ttl = ttl;
  assert_resolve_ok(resolve);
  HT_INSERT(cache_map, &cache_root, resolve);
  set_expiry(resolve, time(NULL) + dns_get_expiry_ttl(ttl));
}

903
904
/** 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. */