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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
2003-08-14 05:52:51 +02:00
|
|
|
static void purge_expired_resolves(uint32_t now);
|
2003-08-21 01:05:22 +02:00
|
|
|
static int assign_to_dnsworker(connection_t *exitconn);
|
2003-06-25 09:19:30 +02:00
|
|
|
static void dns_found_answer(char *question, uint32_t answer);
|
2003-08-12 09:35:17 +02:00
|
|
|
int dnsworker_main(void *data);
|
2003-08-21 01:05:22 +02:00
|
|
|
static int spawn_dnsworker(void);
|
|
|
|
static void spawn_enough_dnsworkers(void);
|
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;
|
|
|
|
char question[MAX_ADDRESSLEN]; /* the hostname to be resolved */
|
|
|
|
uint32_t answer; /* in host order. I know I'm horrible for assuming ipv4 */
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
|
|
|
SPLAY_HEAD(cache_tree, cached_resolve) cache_root;
|
|
|
|
|
|
|
|
static int compare_cached_resolves(struct cached_resolve *a, struct cached_resolve *b) {
|
|
|
|
/* make this smarter one day? */
|
|
|
|
return strncasecmp(a->question, b->question, MAX_ADDRESSLEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
log(LOG_DEBUG,"Forgetting old cached resolve (expires %d)", resolve->expire);
|
|
|
|
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);
|
|
|
|
free(resolve);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-06-17 16:31:05 +02:00
|
|
|
/* See if the question 'exitconn->address' has been answered. 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;
|
2003-06-25 09:19:30 +02:00
|
|
|
uint32_t now = time(NULL);
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2003-06-25 09:19:30 +02:00
|
|
|
/* first take this opportunity to see if there are any expired
|
2003-08-14 05:52:51 +02:00
|
|
|
resolves in the tree.*/
|
|
|
|
purge_expired_resolves(now);
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2003-06-25 09:19:30 +02:00
|
|
|
/* now check the tree to see if 'question' is already there. */
|
|
|
|
strncpy(search.question, exitconn->address, MAX_ADDRESSLEN);
|
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;
|
|
|
|
return 0;
|
2003-02-14 08:53:55 +01:00
|
|
|
case CACHE_STATE_VALID:
|
|
|
|
exitconn->addr = resolve->answer;
|
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-03-04 05:36:37 +01:00
|
|
|
} else { /* need to add it */
|
2003-05-20 08:41:23 +02:00
|
|
|
resolve = tor_malloc(sizeof(struct cached_resolve));
|
2003-02-18 02:35:55 +01:00
|
|
|
memset(resolve, 0, sizeof(struct cached_resolve));
|
|
|
|
resolve->state = CACHE_STATE_PENDING;
|
2003-06-25 09:19:30 +02:00
|
|
|
resolve->expire = now + 100; /* XXX for testing. when we're confident, switch it back */
|
|
|
|
// resolve->expire = now + 86400; /* now + 1 day */
|
2003-02-18 02:35:55 +01:00
|
|
|
strncpy(resolve->question, exitconn->address, MAX_ADDRESSLEN);
|
2003-02-14 08:53:55 +01:00
|
|
|
|
|
|
|
/* 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-02-14 08:53:55 +01:00
|
|
|
|
2003-06-25 09:19:30 +02:00
|
|
|
/* add us to the linked list of resolves */
|
|
|
|
if (!oldest_cached_resolve) {
|
|
|
|
oldest_cached_resolve = resolve;
|
|
|
|
} else {
|
|
|
|
newest_cached_resolve->next = resolve;
|
|
|
|
}
|
|
|
|
newest_cached_resolve = resolve;
|
|
|
|
|
2003-02-18 02:35:55 +01:00
|
|
|
SPLAY_INSERT(cache_tree, &cache_root, resolve);
|
2003-08-21 01:05:22 +02:00
|
|
|
return assign_to_dnsworker(exitconn);
|
2003-02-14 08:53:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
assert(0);
|
|
|
|
return 0; /* not reached; keep gcc happy */
|
|
|
|
}
|
|
|
|
|
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-09-26 12:03:50 +02:00
|
|
|
log_fn(LOG_WARNING,"no idle dns workers. Failing.");
|
2003-06-27 02:57:04 +02:00
|
|
|
dns_cancel_pending_resolve(exitconn->address, NULL);
|
2003-06-25 02:31:41 +02:00
|
|
|
return -1;
|
2003-02-14 08:53:55 +01:00
|
|
|
}
|
|
|
|
|
2003-06-17 16:31:05 +02:00
|
|
|
dnsconn->address = strdup(exitconn->address);
|
|
|
|
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);
|
|
|
|
/* FFFF we should have it retry if the first worker bombs out */
|
|
|
|
if(connection_write_to_buf(&len, 1, dnsconn) < 0 ||
|
|
|
|
connection_write_to_buf(dnsconn->address, len, dnsconn) < 0) {
|
2003-09-26 12:03:50 +02:00
|
|
|
log_fn(LOG_WARNING,"Write failed. Closing worker and failing resolve.");
|
2003-06-17 16:31:05 +02:00
|
|
|
dnsconn->marked_for_close = 1;
|
2003-06-27 02:57:04 +02:00
|
|
|
dns_cancel_pending_resolve(exitconn->address, NULL);
|
2003-02-14 08:53:55 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2003-06-27 02:57:04 +02:00
|
|
|
/* if onlyconn is NULL, cancel the whole thing. if onlyconn is defined,
|
|
|
|
* then remove onlyconn from the pending list, and if the pending list
|
|
|
|
* is now empty, cancel the whole thing.
|
|
|
|
*/
|
|
|
|
void dns_cancel_pending_resolve(char *question, connection_t *onlyconn) {
|
|
|
|
struct pending_connection_t *pend, *victim;
|
2003-06-25 09:19:30 +02:00
|
|
|
struct cached_resolve search;
|
|
|
|
struct cached_resolve *resolve, *tmp;
|
|
|
|
|
|
|
|
strncpy(search.question, question, MAX_ADDRESSLEN);
|
|
|
|
|
|
|
|
resolve = SPLAY_FIND(cache_tree, &cache_root, &search);
|
|
|
|
if(!resolve) {
|
2003-09-26 12:03:50 +02:00
|
|
|
log_fn(LOG_WARNING,"Question '%s' is not pending. Dropping.", question);
|
2003-06-25 09:19:30 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(resolve->state == CACHE_STATE_PENDING);
|
2003-06-27 02:57:04 +02:00
|
|
|
assert(resolve->pending_connections);
|
2003-06-25 09:19:30 +02:00
|
|
|
|
2003-06-27 02:57:04 +02:00
|
|
|
if(onlyconn) {
|
2003-06-25 09:19:30 +02:00
|
|
|
pend = resolve->pending_connections;
|
2003-06-27 02:57:04 +02:00
|
|
|
if(pend->conn == onlyconn) {
|
|
|
|
resolve->pending_connections = pend->next;
|
|
|
|
free(pend);
|
|
|
|
if(resolve->pending_connections) /* more pending, don't cancel it */
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
for( ; pend->next; pend = pend->next) {
|
|
|
|
if(pend->next->conn == onlyconn) {
|
|
|
|
victim = pend->next;
|
|
|
|
pend->next = victim->next;
|
|
|
|
free(victim);
|
|
|
|
return; /* more are pending */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert(0); /* not reachable unless onlyconn not in pending list */
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* mark all pending connections to fail */
|
|
|
|
while(resolve->pending_connections) {
|
|
|
|
pend = resolve->pending_connections;
|
2003-09-27 23:09:56 +02:00
|
|
|
/*ENDCLOSE*/ pend->conn->marked_for_close = 1;
|
2003-06-27 02:57:04 +02:00
|
|
|
resolve->pending_connections = pend->next;
|
|
|
|
free(pend);
|
|
|
|
}
|
2003-06-25 09:19:30 +02: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;
|
|
|
|
} else {
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remove resolve from the tree */
|
|
|
|
SPLAY_REMOVE(cache_tree, &cache_root, resolve);
|
|
|
|
|
|
|
|
free(resolve);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dns_found_answer(char *question, uint32_t answer) {
|
2003-02-14 08:53:55 +01:00
|
|
|
struct pending_connection_t *pend;
|
|
|
|
struct cached_resolve search;
|
|
|
|
struct cached_resolve *resolve;
|
|
|
|
|
|
|
|
strncpy(search.question, question, MAX_ADDRESSLEN);
|
|
|
|
|
|
|
|
resolve = SPLAY_FIND(cache_tree, &cache_root, &search);
|
|
|
|
if(!resolve) {
|
2003-09-26 12:03:50 +02:00
|
|
|
log_fn(LOG_WARNING,"Answer to unasked question '%s'? Dropping.", question);
|
2003-06-25 09:19:30 +02:00
|
|
|
return;
|
2003-02-14 08:53:55 +01:00
|
|
|
}
|
|
|
|
|
2003-06-17 16:31:05 +02:00
|
|
|
assert(resolve->state == CACHE_STATE_PENDING);
|
2003-08-26 00:02:42 +02:00
|
|
|
/* XXX sometimes this still gets triggered. :( */
|
2003-02-14 08:53:55 +01:00
|
|
|
|
2003-02-16 03:05:24 +01:00
|
|
|
resolve->answer = ntohl(answer);
|
2003-06-17 16:31:05 +02:00
|
|
|
if(resolve->answer)
|
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;
|
2003-02-16 03:05:24 +01:00
|
|
|
pend->conn->addr = resolve->answer;
|
2003-02-14 08:53:55 +01:00
|
|
|
if(resolve->state == CACHE_STATE_FAILED || connection_exit_connect(pend->conn) < 0) {
|
2003-09-27 23:09:56 +02:00
|
|
|
/*ENDCLOSE*/ pend->conn->marked_for_close = 1;
|
2003-02-14 08:53:55 +01:00
|
|
|
}
|
|
|
|
resolve->pending_connections = pend->next;
|
|
|
|
free(pend);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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) {
|
|
|
|
uint32_t answer;
|
|
|
|
|
|
|
|
assert(conn && conn->type == CONN_TYPE_DNSWORKER);
|
|
|
|
|
|
|
|
if(conn->inbuf_reached_eof) {
|
2003-09-26 12:03:50 +02:00
|
|
|
log_fn(LOG_WARNING,"Read eof. Worker dying.");
|
2003-08-14 00:38:46 +02:00
|
|
|
if(conn->state == DNSWORKER_STATE_BUSY) {
|
2003-06-27 02:57:04 +02:00
|
|
|
dns_cancel_pending_resolve(conn->address, NULL);
|
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--;
|
2003-06-17 16:31:05 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(conn->state == DNSWORKER_STATE_BUSY);
|
2003-09-25 07:17:11 +02:00
|
|
|
if(buf_datalen(conn->inbuf) < 4) /* entire answer available? */
|
2003-06-17 16:31:05 +02:00
|
|
|
return 0; /* not yet */
|
2003-09-25 07:17:11 +02:00
|
|
|
assert(buf_datalen(conn->inbuf) == 4);
|
2003-06-17 16:31:05 +02:00
|
|
|
|
2003-06-25 02:31:41 +02:00
|
|
|
connection_fetch_from_buf((char*)&answer,sizeof(answer),conn);
|
2003-06-17 16:31:05 +02:00
|
|
|
|
|
|
|
dns_found_answer(conn->address, answer);
|
|
|
|
|
|
|
|
free(conn->address);
|
|
|
|
conn->address = NULL;
|
|
|
|
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-06-17 16:31:05 +02:00
|
|
|
char question[MAX_ADDRESSLEN];
|
|
|
|
unsigned char question_len;
|
|
|
|
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 */
|
2003-06-17 16:31:05 +02:00
|
|
|
|
|
|
|
for(;;) {
|
|
|
|
|
|
|
|
if(read(fd, &question_len, 1) != 1) {
|
2003-09-26 12:03:50 +02:00
|
|
|
log_fn(LOG_ERR,"read length failed. Child exiting.");
|
2003-08-12 09:35:17 +02:00
|
|
|
spawn_exit();
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
|
|
|
assert(question_len > 0);
|
|
|
|
|
2003-09-14 04:58:50 +02:00
|
|
|
if(read_all(fd, question, question_len) != question_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
|
|
|
}
|
|
|
|
question[question_len] = 0; /* null terminate it */
|
|
|
|
|
|
|
|
rent = gethostbyname(question);
|
|
|
|
if (!rent) {
|
2003-09-26 12:03:50 +02:00
|
|
|
log_fn(LOG_INFO,"Could not resolve dest addr %s. Returning nulls.",question);
|
2003-08-21 01:05:22 +02:00
|
|
|
if(write_all(fd, "\0\0\0\0", 4) != 4) {
|
2003-09-26 12:03:50 +02:00
|
|
|
log_fn(LOG_ERR,"writing nulls failed. Child exiting.");
|
2003-08-12 09:35:17 +02:00
|
|
|
spawn_exit();
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
assert(rent->h_length == 4); /* break to remind us if we move away from ipv4 */
|
2003-08-21 01:05:22 +02:00
|
|
|
if(write_all(fd, rent->h_addr, 4) != 4) {
|
2003-09-26 12:03:50 +02:00
|
|
|
log_fn(LOG_INFO,"writing answer failed. Child exiting.");
|
2003-08-12 09:35:17 +02:00
|
|
|
spawn_exit();
|
2003-06-17 16:31:05 +02:00
|
|
|
}
|
2003-09-26 12:03:50 +02:00
|
|
|
log_fn(LOG_INFO,"Answered question '%s'.",question);
|
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-06-17 16:31:05 +02:00
|
|
|
perror("socketpair");
|
|
|
|
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-09-16 03:58:46 +02:00
|
|
|
conn->address = strdup("localhost");
|
2003-06-17 16:31:05 +02:00
|
|
|
|
|
|
|
if(connection_add(conn) < 0) { /* no space, forget it */
|
2003-09-26 12:03:50 +02:00
|
|
|
log_fn(LOG_WARNING,"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-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-06-25 09:19:30 +02:00
|
|
|
dnsconn = connection_get_by_type_state_lastwritten(CONN_TYPE_DNSWORKER, DNSWORKER_STATE_BUSY);
|
|
|
|
assert(dnsconn);
|
|
|
|
|
|
|
|
/* tell the exit connection that it's failed */
|
2003-06-27 02:57:04 +02:00
|
|
|
dns_cancel_pending_resolve(dnsconn->address, NULL);
|
2003-06-25 02:31:41 +02:00
|
|
|
|
2003-06-25 09:19:30 +02:00
|
|
|
dnsconn->marked_for_close = 1;
|
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-09-26 12:03:50 +02:00
|
|
|
log(LOG_WARNING,"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
|
|
|
}
|
|
|
|
|
2003-08-21 01:05:22 +02:00
|
|
|
while(num_dnsworkers > num_dnsworkers_needed+MAX_IDLE_DNSWORKERS) { /* too many idle? */
|
2003-06-25 02:31:41 +02:00
|
|
|
/* cull excess workers */
|
|
|
|
dnsconn = connection_get_by_type_state(CONN_TYPE_DNSWORKER, DNSWORKER_STATE_IDLE);
|
|
|
|
assert(dnsconn);
|
|
|
|
dnsconn->marked_for_close = 1;
|
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:
|
|
|
|
*/
|