major overhaul: dns slave subsystem, topics
on startup, it forks off a master dns handler, which forks off dns
slaves (like the apache model). slaves as spawned as load increases,
and then reused. excess slaves are not ever killed, currently.
implemented topics. each topic has a receive window in each direction
at each edge of the circuit, and sends sendme's at the data level, as
per before. each circuit also has receive windows in each direction at
each hop; an edge sends a circuit-level sendme as soon as enough data
cells have arrived (regardless of whether the data cells were flushed
to the exit conns). removed the 'connected' cell type, since it's now
a topic command within data cells.
at the edge of the circuit, there can be multiple connections associated
with a single circuit. you find them via the linked list conn->next_topic.
currently each new ap connection starts its own circuit, so we ought
to see comparable performance to what we had before. but that's only
because i haven't written the code to reattach to old circuits. please
try to break it as-is, and then i'll make it reuse the same circuit and
we'll try to break that.
svn:r152
2003-01-26 10:02:24 +01:00
|
|
|
/* Copyright 2003 Roger Dingledine. */
|
|
|
|
/* See LICENSE for licensing information */
|
|
|
|
/* $Id$ */
|
|
|
|
|
2003-06-24 07:17:09 +02:00
|
|
|
/* See http://elvin.dstc.com/ListArchive/elvin-dev/archive/2001/09/msg00027.html
|
|
|
|
* for some approaches to asynchronous dns. We will want to switch once one of
|
|
|
|
* them becomes more commonly available.
|
|
|
|
*/
|
|
|
|
|
major overhaul: dns slave subsystem, topics
on startup, it forks off a master dns handler, which forks off dns
slaves (like the apache model). slaves as spawned as load increases,
and then reused. excess slaves are not ever killed, currently.
implemented topics. each topic has a receive window in each direction
at each edge of the circuit, and sends sendme's at the data level, as
per before. each circuit also has receive windows in each direction at
each hop; an edge sends a circuit-level sendme as soon as enough data
cells have arrived (regardless of whether the data cells were flushed
to the exit conns). removed the 'connected' cell type, since it's now
a topic command within data cells.
at the edge of the circuit, there can be multiple connections associated
with a single circuit. you find them via the linked list conn->next_topic.
currently each new ap connection starts its own circuit, so we ought
to see comparable performance to what we had before. but that's only
because i haven't written the code to reattach to old circuits. please
try to break it as-is, and then i'll make it reuse the same circuit and
we'll try to break that.
svn:r152
2003-01-26 10:02:24 +01:00
|
|
|
#include "or.h"
|
2003-06-17 16:31:05 +02:00
|
|
|
#include "tree.h"
|
major overhaul: dns slave subsystem, topics
on startup, it forks off a master dns handler, which forks off dns
slaves (like the apache model). slaves as spawned as load increases,
and then reused. excess slaves are not ever killed, currently.
implemented topics. each topic has a receive window in each direction
at each edge of the circuit, and sends sendme's at the data level, as
per before. each circuit also has receive windows in each direction at
each hop; an edge sends a circuit-level sendme as soon as enough data
cells have arrived (regardless of whether the data cells were flushed
to the exit conns). removed the 'connected' cell type, since it's now
a topic command within data cells.
at the edge of the circuit, there can be multiple connections associated
with a single circuit. you find them via the linked list conn->next_topic.
currently each new ap connection starts its own circuit, so we ought
to see comparable performance to what we had before. but that's only
because i haven't written the code to reattach to old circuits. please
try to break it as-is, and then i'll make it reuse the same circuit and
we'll try to break that.
svn:r152
2003-01-26 10:02:24 +01:00
|
|
|
|
2004-03-29 21:57:50 +02:00
|
|
|
extern or_options_t options; /* command-line and config-file options */
|
|
|
|
|
2003-02-14 08:53:55 +01:00
|
|
|
#define MAX_ADDRESSLEN 256
|
|
|
|
|
2003-06-17 16:31:05 +02:00
|
|
|
#define MAX_DNSWORKERS 50
|
|
|
|
#define MIN_DNSWORKERS 3
|
2003-06-25 02:31:41 +02:00
|
|
|
#define MAX_IDLE_DNSWORKERS 10
|
major overhaul: dns slave subsystem, topics
on startup, it forks off a master dns handler, which forks off dns
slaves (like the apache model). slaves as spawned as load increases,
and then reused. excess slaves are not ever killed, currently.
implemented topics. each topic has a receive window in each direction
at each edge of the circuit, and sends sendme's at the data level, as
per before. each circuit also has receive windows in each direction at
each hop; an edge sends a circuit-level sendme as soon as enough data
cells have arrived (regardless of whether the data cells were flushed
to the exit conns). removed the 'connected' cell type, since it's now
a topic command within data cells.
at the edge of the circuit, there can be multiple connections associated
with a single circuit. you find them via the linked list conn->next_topic.
currently each new ap connection starts its own circuit, so we ought
to see comparable performance to what we had before. but that's only
because i haven't written the code to reattach to old circuits. please
try to break it as-is, and then i'll make it reuse the same circuit and
we'll try to break that.
svn:r152
2003-01-26 10:02:24 +01:00
|
|
|
|
2004-03-12 19:45:42 +01:00
|
|
|
#define DNS_RESOLVE_FAILED_TRANSIENT 1
|
|
|
|
#define DNS_RESOLVE_FAILED_PERMANENT 2
|
|
|
|
#define DNS_RESOLVE_SUCCEEDED 3
|
|
|
|
|
2003-08-21 01:05:22 +02:00
|
|
|
int num_dnsworkers=0;
|
|
|
|
int num_dnsworkers_busy=0;
|
2003-02-14 08:53:55 +01:00
|
|
|
|
|
|
|
struct pending_connection_t {
|
|
|
|
struct connection_t *conn;
|
|
|
|
struct pending_connection_t *next;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct cached_resolve {
|
|
|
|
SPLAY_ENTRY(cached_resolve) node;
|
2003-12-14 08:40:47 +01:00
|
|
|
char address[MAX_ADDRESSLEN]; /* the hostname to be resolved */
|
|
|
|
uint32_t addr; /* in host order. I know I'm horrible for assuming ipv4 */
|
2003-02-14 08:53:55 +01:00
|
|
|
char state; /* 0 is pending; 1 means answer is valid; 2 means resolve failed */
|
|
|
|
#define CACHE_STATE_PENDING 0
|
|
|
|
#define CACHE_STATE_VALID 1
|
|
|
|
#define CACHE_STATE_FAILED 2
|
|
|
|
uint32_t expire; /* remove untouched items from cache after some time? */
|
|
|
|
struct pending_connection_t *pending_connections;
|
|
|
|
struct cached_resolve *next;
|
|
|
|
};
|
|
|
|
|
2004-03-12 19:45:42 +01:00
|
|
|
static void purge_expired_resolves(uint32_t now);
|
|
|
|
static int assign_to_dnsworker(connection_t *exitconn);
|
|
|
|
static void dns_purge_resolve(struct cached_resolve *resolve);
|
|
|
|
static void dns_found_answer(char *address, uint32_t addr, char outcome);
|
|
|
|
int dnsworker_main(void *data);
|
|
|
|
static int spawn_dnsworker(void);
|
|
|
|
static void spawn_enough_dnsworkers(void);
|
|
|
|
|
2003-12-14 08:40:47 +01:00
|
|
|
static SPLAY_HEAD(cache_tree, cached_resolve) cache_root;
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2003-12-14 08:40:47 +01:00
|
|
|
static int compare_cached_resolves(struct cached_resolve *a,
|
|
|
|
struct cached_resolve *b) {
|
2003-02-14 08:53:55 +01:00
|
|
|
/* make this smarter one day? */
|
2003-12-14 08:40:47 +01:00
|
|
|
return strncasecmp(a->address, b->address, MAX_ADDRESSLEN);
|
2003-02-14 08:53:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SPLAY_PROTOTYPE(cache_tree, cached_resolve, node, compare_cached_resolves);
|
|
|
|
SPLAY_GENERATE(cache_tree, cached_resolve, node, compare_cached_resolves);
|
|
|
|
|
2003-06-17 16:31:05 +02:00
|
|
|
static void init_cache_tree(void) {
|
2003-02-14 08:53:55 +01:00
|
|
|
SPLAY_INIT(&cache_root);
|
|
|
|
}
|
|
|
|
|
2003-06-17 16:31:05 +02:00
|
|
|
void dns_init(void) {
|
|
|
|
init_cache_tree();
|
2003-08-21 01:05:22 +02:00
|
|
|
spawn_enough_dnsworkers();
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2003-06-25 09:19:30 +02:00
|
|
|
static struct cached_resolve *oldest_cached_resolve = NULL; /* linked list, */
|
|
|
|
static struct cached_resolve *newest_cached_resolve = NULL; /* oldest to newest */
|
|
|
|
|
2003-08-14 05:52:51 +02:00
|
|
|
static void purge_expired_resolves(uint32_t now) {
|
|
|
|
struct cached_resolve *resolve;
|
|
|
|
|
|
|
|
/* this is fast because the linked list
|
|
|
|
* oldest_cached_resolve is ordered by when they came in.
|
|
|
|
*/
|
|
|
|
while(oldest_cached_resolve && (oldest_cached_resolve->expire < now)) {
|
|
|
|
resolve = oldest_cached_resolve;
|
2003-12-15 22:35:52 +01:00
|
|
|
log(LOG_DEBUG,"Forgetting old cached resolve (expires %lu)", (unsigned long)resolve->expire);
|
2004-02-28 23:13:58 +01:00
|
|
|
if(resolve->state == CACHE_STATE_PENDING) {
|
|
|
|
log_fn(LOG_WARN,"Expiring a dns resolve that's still pending. Forgot to cull it?");
|
|
|
|
/* XXX if resolve->pending_connections is used, then we're probably
|
|
|
|
* introducing bugs by closing resolve without notifying those streams.
|
|
|
|
*/
|
|
|
|
}
|
2003-08-14 05:52:51 +02:00
|
|
|
oldest_cached_resolve = resolve->next;
|
|
|
|
if(!oldest_cached_resolve) /* if there are no more, */
|
|
|
|
newest_cached_resolve = NULL; /* then make sure the list's tail knows that too */
|
|
|
|
SPLAY_REMOVE(cache_tree, &cache_root, resolve);
|
2004-03-04 19:43:44 +01:00
|
|
|
tor_free(resolve);
|
2003-08-14 05:52:51 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-12-17 10:20:29 +01:00
|
|
|
/* See if we have a cache entry for 'exitconn->address'. if so,
|
2003-08-14 05:52:51 +02:00
|
|
|
* if resolve valid, put it into exitconn->addr and return 1.
|
|
|
|
* If resolve failed, return -1.
|
2003-02-14 08:53:55 +01:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
int dns_resolve(connection_t *exitconn) {
|
|
|
|
struct cached_resolve *resolve;
|
2003-02-18 02:35:55 +01:00
|
|
|
struct cached_resolve search;
|
2003-02-14 08:53:55 +01:00
|
|
|
struct pending_connection_t *pending_connection;
|
2004-03-28 23:16:52 +02:00
|
|
|
struct in_addr in;
|
2003-06-25 09:19:30 +02:00
|
|
|
uint32_t now = time(NULL);
|
2004-02-25 08:31:46 +01:00
|
|
|
assert_connection_ok(exitconn, 0);
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2004-03-29 21:51:39 +02:00
|
|
|
/* XXX leave disabled for dirservers so we can find the conn-munging bug */
|
|
|
|
if(!options.DirPort) {
|
|
|
|
/* first check if exitconn->address is an IP. If so, we already
|
|
|
|
* know the answer. */
|
|
|
|
if (tor_inet_aton(exitconn->address, &in) != 0) {
|
|
|
|
exitconn->addr = ntohl(in.s_addr);
|
|
|
|
return 1;
|
|
|
|
}
|
2004-03-28 23:16:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* then take this opportunity to see if there are any expired
|
|
|
|
* resolves in the tree. */
|
2003-08-14 05:52:51 +02:00
|
|
|
purge_expired_resolves(now);
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2003-12-14 08:40:47 +01:00
|
|
|
/* now check the tree to see if 'address' is already there. */
|
|
|
|
strncpy(search.address, exitconn->address, MAX_ADDRESSLEN);
|
2003-12-17 10:20:29 +01:00
|
|
|
search.address[MAX_ADDRESSLEN-1] = 0;
|
2003-02-18 02:35:55 +01:00
|
|
|
resolve = SPLAY_FIND(cache_tree, &cache_root, &search);
|
2003-03-04 05:36:37 +01:00
|
|
|
if(resolve) { /* already there */
|
2003-02-14 08:53:55 +01:00
|
|
|
switch(resolve->state) {
|
|
|
|
case CACHE_STATE_PENDING:
|
|
|
|
/* add us to the pending list */
|
2003-05-20 08:41:23 +02:00
|
|
|
pending_connection = tor_malloc(sizeof(struct pending_connection_t));
|
2003-02-14 08:53:55 +01:00
|
|
|
pending_connection->conn = exitconn;
|
2003-02-18 02:35:55 +01:00
|
|
|
pending_connection->next = resolve->pending_connections;
|
|
|
|
resolve->pending_connections = pending_connection;
|
2003-11-08 05:02:05 +01:00
|
|
|
log_fn(LOG_DEBUG,"Connection (fd %d) waiting for pending DNS resolve of '%s'",
|
|
|
|
exitconn->s, exitconn->address);
|
2003-02-18 02:35:55 +01:00
|
|
|
return 0;
|
2003-02-14 08:53:55 +01:00
|
|
|
case CACHE_STATE_VALID:
|
2003-12-14 08:40:47 +01:00
|
|
|
exitconn->addr = resolve->addr;
|
2003-11-08 05:02:05 +01:00
|
|
|
log_fn(LOG_DEBUG,"Connection (fd %d) found cached answer for '%s'",
|
|
|
|
exitconn->s, exitconn->address);
|
2003-08-14 05:52:51 +02:00
|
|
|
return 1;
|
2003-02-14 08:53:55 +01:00
|
|
|
case CACHE_STATE_FAILED:
|
|
|
|
return -1;
|
|
|
|
}
|
2003-12-14 01:12:02 +01:00
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
/* not there, need to add it */
|
|
|
|
resolve = tor_malloc_zero(sizeof(struct cached_resolve));
|
|
|
|
resolve->state = CACHE_STATE_PENDING;
|
2003-12-14 08:40:47 +01:00
|
|
|
resolve->expire = now + MAX_DNS_ENTRY_AGE;
|
|
|
|
strncpy(resolve->address, exitconn->address, MAX_ADDRESSLEN);
|
2003-12-17 10:20:29 +01:00
|
|
|
resolve->address[MAX_ADDRESSLEN-1] = 0;
|
2003-12-14 01:12:02 +01:00
|
|
|
|
|
|
|
/* add us to the pending list */
|
|
|
|
pending_connection = tor_malloc(sizeof(struct pending_connection_t));
|
|
|
|
pending_connection->conn = exitconn;
|
2004-03-04 19:43:44 +01:00
|
|
|
pending_connection->next = NULL;
|
2003-12-14 01:12:02 +01:00
|
|
|
resolve->pending_connections = pending_connection;
|
|
|
|
|
|
|
|
/* add us to the linked list of resolves */
|
|
|
|
if (!oldest_cached_resolve) {
|
|
|
|
oldest_cached_resolve = resolve;
|
|
|
|
} else {
|
|
|
|
newest_cached_resolve->next = resolve;
|
2003-02-14 08:53:55 +01:00
|
|
|
}
|
2003-12-14 01:12:02 +01:00
|
|
|
newest_cached_resolve = resolve;
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2003-12-14 01:12:02 +01:00
|
|
|
SPLAY_INSERT(cache_tree, &cache_root, resolve);
|
|
|
|
return assign_to_dnsworker(exitconn);
|
2003-02-14 08:53:55 +01:00
|
|
|
}
|
|
|
|
|
2003-08-21 01:05:22 +02:00
|
|
|
static int assign_to_dnsworker(connection_t *exitconn) {
|
2003-02-14 08:53:55 +01:00
|
|
|
connection_t *dnsconn;
|
|
|
|
unsigned char len;
|
2003-06-17 16:31:05 +02:00
|
|
|
|
2003-08-21 01:05:22 +02:00
|
|
|
spawn_enough_dnsworkers(); /* respawn here, to be sure there are enough */
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2003-06-17 16:31:05 +02:00
|
|
|
dnsconn = connection_get_by_type_state(CONN_TYPE_DNSWORKER, DNSWORKER_STATE_IDLE);
|
2003-02-14 08:53:55 +01:00
|
|
|
|
|
|
|
if(!dnsconn) {
|
2003-10-10 03:48:32 +02:00
|
|
|
log_fn(LOG_WARN,"no idle dns workers. Failing.");
|
2004-02-28 23:23:44 +01:00
|
|
|
dns_cancel_pending_resolve(exitconn->address);
|
2003-06-25 02:31:41 +02:00
|
|
|
return -1;
|
2003-02-14 08:53:55 +01:00
|
|
|
}
|
|
|
|
|
2003-11-08 05:02:05 +01:00
|
|
|
log_fn(LOG_DEBUG, "Connection (fd %d) needs to resolve '%s'; assigning to DNSWorker (fd %d)",
|
|
|
|
exitconn->s, exitconn->address, dnsconn->s);
|
|
|
|
|
2004-03-04 19:43:44 +01:00
|
|
|
tor_free(dnsconn->address);
|
2003-10-04 05:29:09 +02:00
|
|
|
dnsconn->address = tor_strdup(exitconn->address);
|
2003-06-17 16:31:05 +02:00
|
|
|
dnsconn->state = DNSWORKER_STATE_BUSY;
|
2003-08-21 01:05:22 +02:00
|
|
|
num_dnsworkers_busy++;
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2003-06-17 16:31:05 +02:00
|
|
|
len = strlen(dnsconn->address);
|
2003-10-04 04:38:18 +02:00
|
|
|
connection_write_to_buf(&len, 1, dnsconn);
|
|
|
|
connection_write_to_buf(dnsconn->address, len, dnsconn);
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2003-08-21 01:05:22 +02:00
|
|
|
// log_fn(LOG_DEBUG,"submitted '%s'", exitconn->address);
|
2003-02-14 08:53:55 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-02-28 23:23:44 +01:00
|
|
|
void connection_dns_remove(connection_t *conn)
|
|
|
|
{
|
|
|
|
struct pending_connection_t *pend, *victim;
|
|
|
|
struct cached_resolve search;
|
|
|
|
struct cached_resolve *resolve;
|
|
|
|
|
|
|
|
strncpy(search.address, conn->address, MAX_ADDRESSLEN);
|
|
|
|
search.address[MAX_ADDRESSLEN-1] = 0;
|
|
|
|
|
|
|
|
resolve = SPLAY_FIND(cache_tree, &cache_root, &search);
|
|
|
|
if(!resolve) {
|
|
|
|
log_fn(LOG_WARN,"Address '%s' is not pending. Dropping.", conn->address);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(resolve->pending_connections);
|
|
|
|
assert_connection_ok(conn,0);
|
|
|
|
|
|
|
|
pend = resolve->pending_connections;
|
|
|
|
|
|
|
|
if(pend->conn == conn) {
|
|
|
|
resolve->pending_connections = pend->next;
|
2004-03-04 19:43:44 +01:00
|
|
|
tor_free(pend);
|
2004-03-04 21:49:38 +01:00
|
|
|
log_fn(LOG_DEBUG, "First connection (fd %d) no longer waiting for resolve of '%s'",
|
2004-02-28 23:23:44 +01:00
|
|
|
conn->s, conn->address);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
for( ; pend->next; pend = pend->next) {
|
|
|
|
if(pend->next->conn == conn) {
|
|
|
|
victim = pend->next;
|
|
|
|
pend->next = victim->next;
|
2004-03-04 19:43:44 +01:00
|
|
|
tor_free(victim);
|
2004-02-28 23:23:44 +01:00
|
|
|
log_fn(LOG_DEBUG, "Connection (fd %d) no longer waiting for resolve of '%s'",
|
|
|
|
conn->s, conn->address);
|
|
|
|
return; /* more are pending */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert(0); /* not reachable unless onlyconn not in pending list */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-03-28 06:54:36 +02:00
|
|
|
void assert_connection_edge_not_dns_pending(connection_t *conn) {
|
|
|
|
struct pending_connection_t *pend;
|
|
|
|
struct cached_resolve *resolve;
|
|
|
|
|
|
|
|
SPLAY_FOREACH(resolve, cache_tree, &cache_root) {
|
|
|
|
for(pend = resolve->pending_connections;
|
|
|
|
pend;
|
|
|
|
pend = pend->next) {
|
|
|
|
assert(pend->conn != conn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-04-09 11:39:42 +02:00
|
|
|
void assert_all_pending_dns_resolves_ok(void) {
|
|
|
|
struct pending_connection_t *pend;
|
|
|
|
struct cached_resolve *resolve;
|
|
|
|
|
|
|
|
SPLAY_FOREACH(resolve, cache_tree, &cache_root) {
|
|
|
|
for(pend = resolve->pending_connections;
|
|
|
|
pend;
|
|
|
|
pend = pend->next) {
|
|
|
|
assert_connection_ok(pend->conn, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-02-28 23:34:47 +01:00
|
|
|
/* Cancel all pending connections. Then cancel the resolve itself,
|
|
|
|
* and remove the 'struct cached_resolve' from the cache.
|
2003-06-27 02:57:04 +02:00
|
|
|
*/
|
2004-02-28 23:23:44 +01:00
|
|
|
void dns_cancel_pending_resolve(char *address) {
|
|
|
|
struct pending_connection_t *pend;
|
2003-06-25 09:19:30 +02:00
|
|
|
struct cached_resolve search;
|
2004-03-12 19:45:42 +01:00
|
|
|
struct cached_resolve *resolve;
|
2004-03-04 21:49:38 +01:00
|
|
|
connection_t *pendconn;
|
2003-06-25 09:19:30 +02:00
|
|
|
|
2003-12-14 08:40:47 +01:00
|
|
|
strncpy(search.address, address, MAX_ADDRESSLEN);
|
2003-12-17 10:20:29 +01:00
|
|
|
search.address[MAX_ADDRESSLEN-1] = 0;
|
2003-06-25 09:19:30 +02:00
|
|
|
|
|
|
|
resolve = SPLAY_FIND(cache_tree, &cache_root, &search);
|
|
|
|
if(!resolve) {
|
2003-12-14 08:40:47 +01:00
|
|
|
log_fn(LOG_WARN,"Address '%s' is not pending. Dropping.", address);
|
2003-06-25 09:19:30 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2003-06-27 02:57:04 +02:00
|
|
|
assert(resolve->pending_connections);
|
2003-06-25 09:19:30 +02:00
|
|
|
|
2004-02-28 23:23:44 +01:00
|
|
|
/* mark all pending connections to fail */
|
|
|
|
log_fn(LOG_DEBUG, "Failing all connections waiting on DNS resolve of '%s'",
|
|
|
|
address);
|
|
|
|
while(resolve->pending_connections) {
|
2003-06-25 09:19:30 +02:00
|
|
|
pend = resolve->pending_connections;
|
2004-03-04 19:43:44 +01:00
|
|
|
/* So that mark_for_close doesn't double-remove the connection. */
|
|
|
|
pend->conn->state = EXIT_CONN_STATE_RESOLVEFAILED;
|
2004-03-04 21:49:38 +01:00
|
|
|
pendconn = pend->conn; /* don't pass complex things to the
|
|
|
|
connection_mark_for_close macro */
|
|
|
|
connection_mark_for_close(pendconn, END_STREAM_REASON_MISC);
|
2004-03-04 19:43:44 +01:00
|
|
|
resolve->pending_connections = pend->next;
|
|
|
|
tor_free(pend);
|
2004-02-28 23:23:44 +01:00
|
|
|
}
|
|
|
|
|
2004-03-12 19:45:42 +01:00
|
|
|
dns_purge_resolve(resolve);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dns_purge_resolve(struct cached_resolve *resolve) {
|
|
|
|
struct cached_resolve *tmp;
|
|
|
|
|
2004-02-28 23:23:44 +01:00
|
|
|
/* remove resolve from the linked list */
|
|
|
|
if(resolve == oldest_cached_resolve) {
|
|
|
|
oldest_cached_resolve = resolve->next;
|
|
|
|
if(oldest_cached_resolve == NULL)
|
|
|
|
newest_cached_resolve = NULL;
|
2003-06-27 02:57:04 +02:00
|
|
|
} else {
|
2004-02-28 23:23:44 +01:00
|
|
|
/* FFFF make it a doubly linked list if this becomes too slow */
|
|
|
|
for(tmp=oldest_cached_resolve; tmp && tmp->next != resolve; tmp=tmp->next) ;
|
|
|
|
assert(tmp); /* it's got to be in the list, or we screwed up somewhere else */
|
|
|
|
tmp->next = resolve->next; /* unlink it */
|
|
|
|
|
|
|
|
if(newest_cached_resolve == resolve)
|
|
|
|
newest_cached_resolve = tmp;
|
2003-06-25 09:19:30 +02:00
|
|
|
}
|
2004-02-28 23:23:44 +01:00
|
|
|
|
|
|
|
/* remove resolve from the tree */
|
|
|
|
SPLAY_REMOVE(cache_tree, &cache_root, resolve);
|
|
|
|
|
2004-03-04 19:43:44 +01:00
|
|
|
tor_free(resolve);
|
2003-06-25 09:19:30 +02:00
|
|
|
}
|
|
|
|
|
2004-03-12 19:45:42 +01:00
|
|
|
static void dns_found_answer(char *address, uint32_t addr, char outcome) {
|
2003-02-14 08:53:55 +01:00
|
|
|
struct pending_connection_t *pend;
|
|
|
|
struct cached_resolve search;
|
|
|
|
struct cached_resolve *resolve;
|
2004-03-04 21:49:38 +01:00
|
|
|
connection_t *pendconn;
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2003-12-14 08:40:47 +01:00
|
|
|
strncpy(search.address, address, MAX_ADDRESSLEN);
|
2003-12-17 10:20:29 +01:00
|
|
|
search.address[MAX_ADDRESSLEN-1] = 0;
|
2003-02-14 08:53:55 +01:00
|
|
|
|
|
|
|
resolve = SPLAY_FIND(cache_tree, &cache_root, &search);
|
|
|
|
if(!resolve) {
|
2003-12-14 08:40:47 +01:00
|
|
|
log_fn(LOG_INFO,"Resolved unasked address '%s'? Dropping.", address);
|
2003-11-08 05:02:05 +01:00
|
|
|
/* XXX Why drop? Just because we don't care now doesn't mean we shouldn't
|
|
|
|
* XXX cache the result for later. */
|
2003-06-25 09:19:30 +02:00
|
|
|
return;
|
2003-02-14 08:53:55 +01:00
|
|
|
}
|
|
|
|
|
2003-11-08 05:02:05 +01:00
|
|
|
if (resolve->state != CACHE_STATE_PENDING) {
|
2003-12-14 08:40:47 +01:00
|
|
|
log_fn(LOG_WARN, "Resolved '%s' which was already resolved; ignoring",
|
|
|
|
address);
|
2004-04-09 11:39:42 +02:00
|
|
|
assert(resolve->pending_connections == NULL);
|
2003-11-08 05:02:05 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Removed this assertion: in fact, we'll sometimes get a double answer
|
|
|
|
* to the same question. This can happen when we ask one worker to resolve
|
|
|
|
* X.Y.Z., then we cancel the request, and then we ask another worker to
|
|
|
|
* resolve X.Y.Z. */
|
|
|
|
/* assert(resolve->state == CACHE_STATE_PENDING); */
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2003-12-14 08:40:47 +01:00
|
|
|
resolve->addr = ntohl(addr);
|
2004-03-12 19:45:42 +01:00
|
|
|
if(outcome == DNS_RESOLVE_SUCCEEDED)
|
2003-02-14 08:53:55 +01:00
|
|
|
resolve->state = CACHE_STATE_VALID;
|
|
|
|
else
|
|
|
|
resolve->state = CACHE_STATE_FAILED;
|
|
|
|
|
|
|
|
while(resolve->pending_connections) {
|
|
|
|
pend = resolve->pending_connections;
|
2004-02-28 22:52:58 +01:00
|
|
|
assert_connection_ok(pend->conn,time(NULL));
|
2003-12-14 08:40:47 +01:00
|
|
|
pend->conn->addr = resolve->addr;
|
2004-04-09 23:06:14 +02:00
|
|
|
/* prevent double-remove */
|
|
|
|
pend->conn->state = EXIT_CONN_STATE_RESOLVEFAILED;
|
2003-12-14 09:32:14 +01:00
|
|
|
if(resolve->state == CACHE_STATE_FAILED) {
|
2004-03-04 21:49:38 +01:00
|
|
|
pendconn = pend->conn; /* don't pass complex things to the
|
|
|
|
connection_mark_for_close macro */
|
|
|
|
connection_mark_for_close(pendconn, END_STREAM_REASON_RESOLVEFAILED);
|
2004-02-22 21:50:20 +01:00
|
|
|
} else {
|
2003-10-22 09:55:44 +02:00
|
|
|
connection_exit_connect(pend->conn);
|
2004-02-22 21:50:20 +01:00
|
|
|
}
|
2004-03-04 19:43:44 +01:00
|
|
|
resolve->pending_connections = pend->next;
|
|
|
|
tor_free(pend);
|
2003-02-14 08:53:55 +01:00
|
|
|
}
|
2004-03-12 19:45:42 +01:00
|
|
|
|
|
|
|
if(outcome == DNS_RESOLVE_FAILED_TRANSIENT) { /* remove from cache */
|
|
|
|
dns_purge_resolve(resolve);
|
|
|
|
}
|
2003-02-14 08:53:55 +01:00
|
|
|
}
|
|
|
|
|
2003-06-17 16:31:05 +02:00
|
|
|
/******************************************************************/
|
|
|
|
|
|
|
|
int connection_dns_finished_flushing(connection_t *conn) {
|
|
|
|
assert(conn && conn->type == CONN_TYPE_DNSWORKER);
|
|
|
|
connection_stop_writing(conn);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int connection_dns_process_inbuf(connection_t *conn) {
|
2004-03-20 10:30:30 +01:00
|
|
|
char success;
|
2003-12-14 08:40:47 +01:00
|
|
|
uint32_t addr;
|
2003-06-17 16:31:05 +02:00
|
|
|
|
|
|
|
assert(conn && conn->type == CONN_TYPE_DNSWORKER);
|
|
|
|
|
|
|
|
if(conn->inbuf_reached_eof) {
|
2004-03-06 02:43:37 +01:00
|
|
|
log_fn(LOG_WARN,"Read eof. Worker died unexpectedly.");
|
2003-08-14 00:38:46 +02:00
|
|
|
if(conn->state == DNSWORKER_STATE_BUSY) {
|
2004-02-28 23:23:44 +01:00
|
|
|
dns_cancel_pending_resolve(conn->address);
|
2003-08-21 01:05:22 +02:00
|
|
|
num_dnsworkers_busy--;
|
2003-08-14 00:38:46 +02:00
|
|
|
}
|
2003-08-21 01:05:22 +02:00
|
|
|
num_dnsworkers--;
|
2004-02-28 05:11:53 +01:00
|
|
|
connection_mark_for_close(conn,0);
|
|
|
|
return 0;
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
assert(conn->state == DNSWORKER_STATE_BUSY);
|
2004-03-12 19:45:42 +01:00
|
|
|
if(buf_datalen(conn->inbuf) < 5) /* entire answer available? */
|
2003-06-17 16:31:05 +02:00
|
|
|
return 0; /* not yet */
|
2004-03-12 19:45:42 +01:00
|
|
|
assert(buf_datalen(conn->inbuf) == 5);
|
2003-06-17 16:31:05 +02:00
|
|
|
|
2004-03-20 10:30:30 +01:00
|
|
|
connection_fetch_from_buf(&success,1,conn);
|
|
|
|
connection_fetch_from_buf((char *)&addr,sizeof(uint32_t),conn);
|
2003-06-17 16:31:05 +02:00
|
|
|
|
2003-11-08 05:02:05 +01:00
|
|
|
log_fn(LOG_DEBUG, "DNSWorker (fd %d) returned answer for '%s'",
|
|
|
|
conn->s, conn->address);
|
|
|
|
|
2004-03-20 10:30:30 +01:00
|
|
|
assert(success >= DNS_RESOLVE_FAILED_TRANSIENT);
|
|
|
|
assert(success <= DNS_RESOLVE_SUCCEEDED);
|
|
|
|
dns_found_answer(conn->address, addr, success);
|
2003-06-17 16:31:05 +02:00
|
|
|
|
2004-03-04 19:43:44 +01:00
|
|
|
tor_free(conn->address);
|
2003-11-13 07:49:25 +01:00
|
|
|
conn->address = tor_strdup("<idle>");
|
2003-06-17 16:31:05 +02:00
|
|
|
conn->state = DNSWORKER_STATE_IDLE;
|
2003-08-21 01:05:22 +02:00
|
|
|
num_dnsworkers_busy--;
|
2003-06-17 16:31:05 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2003-08-12 09:35:17 +02:00
|
|
|
int dnsworker_main(void *data) {
|
2003-12-14 08:40:47 +01:00
|
|
|
char address[MAX_ADDRESSLEN];
|
|
|
|
unsigned char address_len;
|
2004-03-12 19:45:42 +01:00
|
|
|
char answer[5];
|
2003-06-17 16:31:05 +02:00
|
|
|
struct hostent *rent;
|
2003-08-12 09:35:17 +02:00
|
|
|
int *fdarray = data;
|
2003-08-21 01:05:22 +02:00
|
|
|
int fd;
|
2003-08-12 09:35:17 +02:00
|
|
|
|
|
|
|
close(fdarray[0]); /* this is the side of the socketpair the parent uses */
|
|
|
|
fd = fdarray[1]; /* this side is ours */
|
2004-03-12 22:52:15 +01:00
|
|
|
#ifndef MS_WINDOWS
|
2004-01-06 08:53:40 +01:00
|
|
|
connection_free_all(); /* so the child doesn't hold the parent's fd's open */
|
2004-03-12 22:52:15 +01:00
|
|
|
#endif
|
2003-06-17 16:31:05 +02:00
|
|
|
|
|
|
|
for(;;) {
|
|
|
|
|
2004-03-11 07:35:03 +01:00
|
|
|
if(recv(fd, &address_len, 1, 0) != 1) {
|
2004-03-04 22:26:23 +01:00
|
|
|
log_fn(LOG_INFO,"dnsworker exiting because tor process died.");
|
2003-08-12 09:35:17 +02:00
|
|
|
spawn_exit();
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
2003-12-14 08:40:47 +01:00
|
|
|
assert(address_len > 0);
|
2003-06-17 16:31:05 +02:00
|
|
|
|
2004-03-11 07:35:03 +01:00
|
|
|
if(read_all(fd, address, address_len, 1) != address_len) {
|
2003-09-26 12:03:50 +02:00
|
|
|
log_fn(LOG_ERR,"read hostname failed. Child exiting.");
|
2003-08-12 09:35:17 +02:00
|
|
|
spawn_exit();
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
2003-12-14 08:40:47 +01:00
|
|
|
address[address_len] = 0; /* null terminate it */
|
2003-06-17 16:31:05 +02:00
|
|
|
|
2003-12-14 08:40:47 +01:00
|
|
|
rent = gethostbyname(address);
|
2003-06-17 16:31:05 +02:00
|
|
|
if (!rent) {
|
2004-03-12 19:45:42 +01:00
|
|
|
if(h_errno == TRY_AGAIN) { /* transient error -- don't cache it */
|
|
|
|
log_fn(LOG_INFO,"Could not resolve dest addr %s (transient).",address);
|
|
|
|
answer[0] = DNS_RESOLVE_FAILED_TRANSIENT;
|
|
|
|
} else { /* permanent error, can be cached */
|
|
|
|
log_fn(LOG_INFO,"Could not resolve dest addr %s (permanent).",address);
|
|
|
|
answer[0] = DNS_RESOLVE_FAILED_PERMANENT;
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
2004-03-12 19:45:42 +01:00
|
|
|
memset(answer+1,0,4);
|
2003-06-17 16:31:05 +02:00
|
|
|
} else {
|
|
|
|
assert(rent->h_length == 4); /* break to remind us if we move away from ipv4 */
|
2004-03-12 19:45:42 +01:00
|
|
|
answer[0] = DNS_RESOLVE_SUCCEEDED;
|
|
|
|
memcpy(answer+1, rent->h_addr, 4);
|
2003-12-14 08:40:47 +01:00
|
|
|
log_fn(LOG_INFO,"Resolved address '%s'.",address);
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
2004-03-12 19:45:42 +01:00
|
|
|
if(write_all(fd, answer, 5, 1) != 5) {
|
|
|
|
log_fn(LOG_ERR,"writing answer failed. Child exiting.");
|
|
|
|
spawn_exit();
|
|
|
|
}
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
2003-08-12 09:35:17 +02:00
|
|
|
return 0; /* windows wants this function to return an int */
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
|
|
|
|
2003-08-21 01:05:22 +02:00
|
|
|
static int spawn_dnsworker(void) {
|
2003-06-17 16:31:05 +02:00
|
|
|
int fd[2];
|
|
|
|
connection_t *conn;
|
|
|
|
|
2003-08-12 09:43:15 +02:00
|
|
|
if(tor_socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0) {
|
2003-10-15 20:28:32 +02:00
|
|
|
log(LOG_ERR, "Couldn't construct socketpair: %s", strerror(errno));
|
2003-06-17 16:31:05 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2003-08-12 09:35:17 +02:00
|
|
|
spawn_func(dnsworker_main, (void*)fd);
|
2003-08-21 01:05:22 +02:00
|
|
|
log_fn(LOG_DEBUG,"just spawned a worker.");
|
2003-08-12 09:35:17 +02:00
|
|
|
close(fd[1]); /* we don't need the worker's side of the pipe */
|
2003-06-17 16:31:05 +02:00
|
|
|
|
|
|
|
conn = connection_new(CONN_TYPE_DNSWORKER);
|
|
|
|
|
2003-08-12 05:08:41 +02:00
|
|
|
set_socket_nonblocking(fd[0]);
|
2003-06-17 16:31:05 +02:00
|
|
|
|
|
|
|
/* set up conn so it's got all the data we need to remember */
|
|
|
|
conn->s = fd[0];
|
2003-10-18 09:09:09 +02:00
|
|
|
conn->address = tor_strdup("<unused>");
|
2003-06-17 16:31:05 +02:00
|
|
|
|
|
|
|
if(connection_add(conn) < 0) { /* no space, forget it */
|
2003-10-10 03:48:32 +02:00
|
|
|
log_fn(LOG_WARN,"connection_add failed. Giving up.");
|
2003-06-17 16:31:05 +02:00
|
|
|
connection_free(conn); /* this closes fd[0] */
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
conn->state = DNSWORKER_STATE_IDLE;
|
|
|
|
connection_start_reading(conn);
|
|
|
|
|
|
|
|
return 0; /* success */
|
|
|
|
}
|
|
|
|
|
2003-08-21 01:05:22 +02:00
|
|
|
static void spawn_enough_dnsworkers(void) {
|
|
|
|
int num_dnsworkers_needed; /* aim to have 1 more than needed,
|
2003-06-17 16:31:05 +02:00
|
|
|
* but no less than min and no more than max */
|
2003-06-25 02:31:41 +02:00
|
|
|
connection_t *dnsconn;
|
|
|
|
|
2003-11-08 05:02:05 +01:00
|
|
|
/* XXX This may not be the best strategy. Maybe we should queue pending
|
2003-12-14 08:40:47 +01:00
|
|
|
* requests until the old ones finish or time out: otherwise, if
|
|
|
|
* the connection requests come fast enough, we never get any DNS done. -NM
|
|
|
|
* XXX But if we queue them, then the adversary can pile even more
|
|
|
|
* queries onto us, blocking legitimate requests for even longer.
|
|
|
|
* Maybe we should compromise and only kill if it's been at it for
|
|
|
|
* more than, e.g., 2 seconds. -RD
|
2003-11-08 05:02:05 +01:00
|
|
|
*/
|
2003-08-21 01:05:22 +02:00
|
|
|
if(num_dnsworkers_busy == MAX_DNSWORKERS) {
|
2003-06-25 02:31:41 +02:00
|
|
|
/* We always want at least one worker idle.
|
|
|
|
* So find the oldest busy worker and kill it.
|
|
|
|
*/
|
2003-12-14 08:40:47 +01:00
|
|
|
dnsconn = connection_get_by_type_state_lastwritten(CONN_TYPE_DNSWORKER,
|
|
|
|
DNSWORKER_STATE_BUSY);
|
2003-06-25 09:19:30 +02:00
|
|
|
assert(dnsconn);
|
|
|
|
|
2003-12-14 08:40:47 +01:00
|
|
|
log_fn(LOG_WARN, "%d DNS workers are spawned; all are busy. Killing one.",
|
|
|
|
MAX_DNSWORKERS);
|
2003-06-25 02:31:41 +02:00
|
|
|
|
2004-02-27 23:00:26 +01:00
|
|
|
connection_mark_for_close(dnsconn,0);
|
2003-08-21 01:05:22 +02:00
|
|
|
num_dnsworkers_busy--;
|
2003-09-27 23:09:56 +02:00
|
|
|
num_dnsworkers--;
|
2003-06-25 02:31:41 +02:00
|
|
|
}
|
2003-06-17 16:31:05 +02:00
|
|
|
|
2003-08-21 01:05:22 +02:00
|
|
|
if(num_dnsworkers_busy >= MIN_DNSWORKERS)
|
|
|
|
num_dnsworkers_needed = num_dnsworkers_busy+1;
|
2003-06-17 16:31:05 +02:00
|
|
|
else
|
2003-08-21 01:05:22 +02:00
|
|
|
num_dnsworkers_needed = MIN_DNSWORKERS;
|
2003-06-17 16:31:05 +02:00
|
|
|
|
2003-08-21 01:05:22 +02:00
|
|
|
while(num_dnsworkers < num_dnsworkers_needed) {
|
|
|
|
if(spawn_dnsworker() < 0) {
|
2003-10-10 03:48:32 +02:00
|
|
|
log(LOG_WARN,"spawn_enough_dnsworkers(): spawn failed!");
|
2003-06-17 16:31:05 +02:00
|
|
|
return;
|
|
|
|
}
|
2003-08-21 01:05:22 +02:00
|
|
|
num_dnsworkers++;
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
|
|
|
|
2004-01-06 08:53:40 +01:00
|
|
|
while(num_dnsworkers > num_dnsworkers_busy+MAX_IDLE_DNSWORKERS) { /* too many idle? */
|
2003-06-25 02:31:41 +02:00
|
|
|
/* cull excess workers */
|
2003-12-14 05:19:12 +01:00
|
|
|
log_fn(LOG_WARN,"%d of %d dnsworkers are idle. Killing one.",
|
|
|
|
num_dnsworkers-num_dnsworkers_needed, num_dnsworkers);
|
2003-06-25 02:31:41 +02:00
|
|
|
dnsconn = connection_get_by_type_state(CONN_TYPE_DNSWORKER, DNSWORKER_STATE_IDLE);
|
|
|
|
assert(dnsconn);
|
2004-02-27 23:00:26 +01:00
|
|
|
connection_mark_for_close(dnsconn,0);
|
2003-08-21 01:05:22 +02:00
|
|
|
num_dnsworkers--;
|
2003-06-25 02:31:41 +02:00
|
|
|
}
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
|
|
|
|
2003-04-07 04:12:02 +02:00
|
|
|
/*
|
|
|
|
Local Variables:
|
|
|
|
mode:c
|
|
|
|
indent-tabs-mode:nil
|
|
|
|
c-basic-offset:2
|
|
|
|
End:
|
|
|
|
*/
|