nihilist/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-11-24 04:13:28 +01:00
Code Issues Packages Projects Releases Wiki Activity

Break files apart into more modules

Browse Source 
* \file circuitbuild.c
 * \brief The actual details of building circuits.

 * \file circuitlist.c
 * \brief Manage the global circuit list.

 * \file circuituse.c
 * \brief Launch the right sort of circuits, attach streams to them.

 * \file connection_edge.c
 * \brief Handle edge streams.

 * \file onion.c
 * \brief Functions to queue create cells, and handle onionskin
 * parsing and creation.

 * \file relay.c
 * \brief Handle relay cell encryption/decryption, plus packaging and
 * receiving from circuits.


svn:r1863
This commit is contained in:
Roger Dingledine 2004-05-13 07:24:49 +00:00
parent 6c68187e9f
commit ef561c0e42
11 changed files with 3110 additions and 3037 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/or/Makefile.am
View File

@ -4,7 +4,8 @@ noinst_PROGRAMS = test
bin_PROGRAMS = tor
tor_SOURCES = buffers.c circuit.c command.c config.c \
tor_SOURCES = buffers.c circuitbuild.c circuitlist.c \
circuituse.c command.c config.c \
connection.c connection_edge.c connection_or.c \
cpuworker.c directory.c dirserv.c dns.c main.c \
onion.c relay.c rendcommon.c rendclient.c rendmid.c \
@ -13,7 +14,8 @@ tor_SOURCES = buffers.c circuit.c command.c config.c \
tor_LDADD = ../common/libor.a
test_SOURCES = buffers.c circuit.c command.c config.c \
test_SOURCES = buffers.c circuitbuild.c circuitlist.c \
circuituse.c command.c config.c \
connection.c connection_edge.c connection_or.c \
cpuworker.c directory.c dirserv.c dns.c main.c \
onion.c relay.c rendcommon.c rendclient.c rendmid.c \

1736
src/or/circuit.c
View File

File diff suppressed because it is too large Load Diff

1099
src/or/circuitbuild.c Normal file
View File

File diff suppressed because it is too large Load Diff

500
src/or/circuitlist.c Normal file
View File

@ -0,0 +1,500 @@
/* Copyright 2001 Matej Pfajfar, 2001-2004 Roger Dingledine. */
/* See LICENSE for licensing information */
/* $Id$ */
/**
* \file circuitlist.c
* \brief Manage the global circuit list.
**/
#include "or.h"
extern or_options_t options; /* command-line and config-file options */
/********* START VARIABLES **********/
/** A global list of all circuits at this hop. */
circuit_t *global_circuitlist=NULL;
/** Array of strings to make circ-\>state human-readable */
char *circuit_state_to_string[] = {
"doing handshakes", /* 0 */
"processing the onion", /* 1 */
"connecting to firsthop", /* 2 */
"open" /* 3 */
};
/********* END VARIABLES ************/
static void circuit_free(circuit_t *circ);
static void circuit_free_cpath(crypt_path_t *cpath);
/** Add <b>circ</b> to the global list of circuits. This is called only from
* within circuit_new.
*/
static void circuit_add(circuit_t *circ) {
if(!global_circuitlist) { /* first one */
global_circuitlist = circ;
circ->next = NULL;
} else {
circ->next = global_circuitlist;
global_circuitlist = circ;
}
}
/** Detach from the global circuit list, and deallocate, all
* circuits that have been marked for close.
*/
void circuit_close_all_marked(void)
{
circuit_t *tmp,*m;
while (global_circuitlist && global_circuitlist->marked_for_close) {
tmp = global_circuitlist->next;
circuit_free(global_circuitlist);
global_circuitlist = tmp;
}
tmp = global_circuitlist;
while (tmp && tmp->next) {
if (tmp->next->marked_for_close) {
m = tmp->next->next;
circuit_free(tmp->next);
tmp->next = m;
/* Need to check new tmp->next; don't advance tmp. */
} else {
/* Advance tmp. */
tmp = tmp->next;
}
}
}
/** Allocate space for a new circuit, initializing with <b>p_circ_id</b>
* and <b>p_conn</b>. Add it to the global circuit list.
*/
circuit_t *circuit_new(uint16_t p_circ_id, connection_t *p_conn) {
circuit_t *circ;
circ = tor_malloc_zero(sizeof(circuit_t));
circ->magic = CIRCUIT_MAGIC;
circ->timestamp_created = time(NULL);
circ->p_circ_id = p_circ_id;
circ->p_conn = p_conn;
circ->state = CIRCUIT_STATE_ONIONSKIN_PENDING;
/* CircIDs */
circ->p_circ_id = p_circ_id;
/* circ->n_circ_id remains 0 because we haven't identified the next hop yet */
circ->package_window = CIRCWINDOW_START;
circ->deliver_window = CIRCWINDOW_START;
circ->next_stream_id = crypto_pseudo_rand_int(1<<16);
circuit_add(circ);
return circ;
}
/** Deallocate space associated with circ.
*/
static void circuit_free(circuit_t *circ) {
tor_assert(circ);
tor_assert(circ->magic == CIRCUIT_MAGIC);
if (circ->n_crypto)
crypto_free_cipher_env(circ->n_crypto);
if (circ->p_crypto)
crypto_free_cipher_env(circ->p_crypto);
if (circ->n_digest)
crypto_free_digest_env(circ->n_digest);
if (circ->p_digest)
crypto_free_digest_env(circ->p_digest);
if(circ->build_state) {
tor_free(circ->build_state->chosen_exit);
if (circ->build_state->pending_final_cpath)
circuit_free_cpath_node(circ->build_state->pending_final_cpath);
}
tor_free(circ->build_state);
circuit_free_cpath(circ->cpath);
if (circ->rend_splice) {
circ->rend_splice->rend_splice = NULL;
}
memset(circ, 0xAA, sizeof(circuit_t)); /* poison memory */
free(circ);
}
/** Deallocate space associated with the linked list <b>cpath</b>. */
static void circuit_free_cpath(crypt_path_t *cpath) {
crypt_path_t *victim, *head=cpath;
if(!cpath)
return;
/* it's a doubly linked list, so we have to notice when we've
* gone through it once. */
while(cpath->next && cpath->next != head) {
victim = cpath;
cpath = victim->next;
circuit_free_cpath_node(victim);
}
circuit_free_cpath_node(cpath);
}
/** Deallocate space associated with the cpath node <b>victim</b>. */
/* XXX rewrite so the call from circuitbuild isn't necessary */
void circuit_free_cpath_node(crypt_path_t *victim) {
if(victim->f_crypto)
crypto_free_cipher_env(victim->f_crypto);
if(victim->b_crypto)
crypto_free_cipher_env(victim->b_crypto);
if(victim->f_digest)
crypto_free_digest_env(victim->f_digest);
if(victim->b_digest)
crypto_free_digest_env(victim->b_digest);
if(victim->handshake_state)
crypto_dh_free(victim->handshake_state);
free(victim);
}
/** Return a circ such that:
* - circ-\>n_circ_id or circ-\>p_circ_id is equal to <b>circ_id</b>, and
* - circ is attached to <b>conn</b>, either as p_conn, n-conn, or
* in p_streams or n_streams.
* Return NULL if no such circuit exists.
*/
circuit_t *circuit_get_by_circ_id_conn(uint16_t circ_id, connection_t *conn) {
circuit_t *circ;
connection_t *tmpconn;
for(circ=global_circuitlist;circ;circ = circ->next) {
if (circ->marked_for_close)
continue;
if(circ->p_circ_id == circ_id) {
if(circ->p_conn == conn)
return circ;
for(tmpconn = circ->p_streams; tmpconn; tmpconn = tmpconn->next_stream) {
if(tmpconn == conn)
return circ;
}
}
if(circ->n_circ_id == circ_id) {
if(circ->n_conn == conn)
return circ;
for(tmpconn = circ->n_streams; tmpconn; tmpconn = tmpconn->next_stream) {
if(tmpconn == conn)
return circ;
}
for(tmpconn = circ->resolving_streams; tmpconn; tmpconn = tmpconn->next_stream) {
if(tmpconn == conn)
return circ;
}
}
}
return NULL;
}
/** Return a circ such that circ is attached to <b>conn</b>, either as
* p_conn, n-conn, or in p_streams or n_streams.
*
* Return NULL if no such circuit exists.
*/
circuit_t *circuit_get_by_conn(connection_t *conn) {
circuit_t *circ;
connection_t *tmpconn;
for(circ=global_circuitlist;circ;circ = circ->next) {
if (circ->marked_for_close)
continue;
if(circ->p_conn == conn)
return circ;
if(circ->n_conn == conn)
return circ;
for(tmpconn = circ->p_streams; tmpconn; tmpconn=tmpconn->next_stream)
if(tmpconn == conn)
return circ;
for(tmpconn = circ->n_streams; tmpconn; tmpconn=tmpconn->next_stream)
if(tmpconn == conn)
return circ;
for(tmpconn = circ->resolving_streams; tmpconn; tmpconn=tmpconn->next_stream)
if(tmpconn == conn)
return circ;
}
return NULL;
}
/** Return a circ such that:
* - circ-\>rend_query is equal to <b>rend_query</b>, and
* - circ-\>purpose is equal to <b>purpose</b>.
*
* Return NULL if no such circuit exists.
*/
circuit_t *circuit_get_by_rend_query_and_purpose(const char *rend_query, uint8_t purpose) {
circuit_t *circ;
for (circ = global_circuitlist; circ; circ = circ->next) {
if (!circ->marked_for_close &&
circ->purpose == purpose &&
!rend_cmp_service_ids(rend_query, circ->rend_query))
return circ;
}
return NULL;
}
/** Return the first circuit in global_circuitlist after <b>start</b> whose
* rend_pk_digest field is <b>digest</b> and whose purpose is <b>purpose</b>. Returns
* NULL if no circuit is found. If <b>start</b> is NULL, begin at the start of
* the list.
*/
circuit_t *
circuit_get_next_by_pk_and_purpose(circuit_t *start,
const char *digest, uint8_t purpose)
{
circuit_t *circ;
if (start == NULL)
circ = global_circuitlist;
else
circ = start->next;
for( ; circ; circ = circ->next) {
if (circ->marked_for_close)
continue;
if (circ->purpose != purpose)
continue;
if (!memcmp(circ->rend_pk_digest, digest, DIGEST_LEN))
return circ;
}
return NULL;
}
/** Return the circuit waiting for a rendezvous with the provided cookie.
* Return NULL if no such circuit is found.
*/
circuit_t *circuit_get_rendezvous(const char *cookie)
{
circuit_t *circ;
for (circ = global_circuitlist; circ; circ = circ->next) {
if (! circ->marked_for_close &&
circ->purpose == CIRCUIT_PURPOSE_REND_POINT_WAITING &&
! memcmp(circ->rend_cookie, cookie, REND_COOKIE_LEN) )
return circ;
}
return NULL;
}
/** Count the number of circs originating here that aren't open, and
* that have the specified <b>purpose</b>. */
int circuit_count_building(uint8_t purpose) {
circuit_t *circ;
int num=0;
for(circ=global_circuitlist;circ;circ = circ->next) {
if(CIRCUIT_IS_ORIGIN(circ) &&
circ->state != CIRCUIT_STATE_OPEN &&
circ->purpose == purpose &&
!circ->marked_for_close)
num++;
}
return num;
}
/** Return the circuit that is open, has specified <b>purpose</b>,
* has a timestamp_dirty value of 0, and was created most recently,
* or NULL if no circuit fits this description.
*/
circuit_t *
circuit_get_youngest_clean_open(uint8_t purpose) {
circuit_t *circ;
circuit_t *youngest=NULL;
for(circ=global_circuitlist;circ;circ = circ->next) {
if(CIRCUIT_IS_ORIGIN(circ) && circ->state == CIRCUIT_STATE_OPEN &&
!circ->marked_for_close && circ->purpose == purpose &&
!circ->timestamp_dirty &&
(!youngest || youngest->timestamp_created < circ->timestamp_created))
youngest = circ;
}
return youngest;
}
/** Mark <b>circ</b> to be closed next time we call
* circuit_close_all_marked(). Do any cleanup needed:
* - If state is onionskin_pending, remove circ from the onion_pending
* list.
* - If circ isn't open yet, call circuit_build_failed() if we're
* the origin, and in case call circuit_rep_hist_note_result()
* to note stats.
* - If purpose is C_INTRODUCE_ACK_WAIT, remove the intro point we
* just tried from our list of intro points for that service
* descriptor.
* - Send appropriate destroys and edge_destroys for conns and
* streams attached to circ.
* - If circ->rend_splice is set (we are the midpoint of a joined
* rendezvous stream), then mark the other circuit to close as well.
*/
int _circuit_mark_for_close(circuit_t *circ) {
connection_t *conn;
assert_circuit_ok(circ);
if (circ->marked_for_close)
return -1;
if(circ->state == CIRCUIT_STATE_ONIONSKIN_PENDING) {
onion_pending_remove(circ);
}
/* If the circuit ever became OPEN, we sent it to the reputation history
* module then. If it isn't OPEN, we send it there now to remember which
* links worked and which didn't.
*/
if (circ->state != CIRCUIT_STATE_OPEN) {
if(CIRCUIT_IS_ORIGIN(circ))
circuit_build_failed(circ); /* take actions if necessary */
circuit_rep_hist_note_result(circ);
}
if (circ->purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT) {
tor_assert(circ->state == CIRCUIT_STATE_OPEN);
/* treat this like getting a nack from it */
log_fn(LOG_INFO,"Failed intro circ %s to %s (awaiting ack). Removing from descriptor.",
circ->rend_query, circ->build_state->chosen_exit);
rend_client_remove_intro_point(circ->build_state->chosen_exit, circ->rend_query);
}
if(circ->n_conn)
connection_send_destroy(circ->n_circ_id, circ->n_conn);
for(conn=circ->n_streams; conn; conn=conn->next_stream)
connection_edge_destroy(circ->n_circ_id, conn);
while(circ->resolving_streams) {
conn = circ->resolving_streams;
circ->resolving_streams = conn->next_stream;
log_fn(LOG_INFO,"Freeing resolving-conn.");
connection_free(conn);
}
if(circ->p_conn)
connection_send_destroy(circ->p_circ_id, circ->p_conn);
for(conn=circ->p_streams; conn; conn=conn->next_stream)
connection_edge_destroy(circ->p_circ_id, conn);
circ->marked_for_close = 1;
if (circ->rend_splice && !circ->rend_splice->marked_for_close) {
/* do this after marking this circuit, to avoid infinite recursion. */
circuit_mark_for_close(circ->rend_splice);
circ->rend_splice = NULL;
}
return 0;
}
/** Verify that cpath layer <b>cp</b> has all of its invariants
* correct. Trigger an assert if anything is invalid.
*/
void assert_cpath_layer_ok(const crypt_path_t *cp)
{
tor_assert(cp->f_crypto);
tor_assert(cp->b_crypto);
// tor_assert(cp->addr); /* these are zero for rendezvous extra-hops */
// tor_assert(cp->port);
switch(cp->state)
{
case CPATH_STATE_CLOSED:
case CPATH_STATE_OPEN:
tor_assert(!cp->handshake_state);
break;
case CPATH_STATE_AWAITING_KEYS:
tor_assert(cp->handshake_state);
break;
default:
tor_assert(0);
}
tor_assert(cp->package_window >= 0);
tor_assert(cp->deliver_window >= 0);
}
/** Verify that cpath <b>cp</b> has all of its invariants
* correct. Trigger an assert if anything is invalid.
*/
static void
assert_cpath_ok(const crypt_path_t *cp)
{
while(cp->prev)
cp = cp->prev;
while(cp->next) {
assert_cpath_layer_ok(cp);
/* layers must be in sequence of: "open* awaiting? closed*" */
if (cp->prev) {
if (cp->prev->state == CPATH_STATE_OPEN) {
tor_assert(cp->state == CPATH_STATE_CLOSED ||
cp->state == CPATH_STATE_AWAITING_KEYS);
} else {
tor_assert(cp->state == CPATH_STATE_CLOSED);
}
}
cp = cp->next;
}
}
/** Verify that circuit <b>c</b> has all of its invariants
* correct. Trigger an assert if anything is invalid.
*/
void assert_circuit_ok(const circuit_t *c)
{
connection_t *conn;
tor_assert(c);
tor_assert(c->magic == CIRCUIT_MAGIC);
tor_assert(c->purpose >= _CIRCUIT_PURPOSE_MIN &&
c->purpose <= _CIRCUIT_PURPOSE_MAX);
if (c->n_conn)
tor_assert(c->n_conn->type == CONN_TYPE_OR);
if (c->p_conn)
tor_assert(c->p_conn->type == CONN_TYPE_OR);
for (conn = c->p_streams; conn; conn = conn->next_stream)
tor_assert(conn->type == CONN_TYPE_AP);
for (conn = c->n_streams; conn; conn = conn->next_stream)
tor_assert(conn->type == CONN_TYPE_EXIT);
tor_assert(c->deliver_window >= 0);
tor_assert(c->package_window >= 0);
if (c->state == CIRCUIT_STATE_OPEN) {
if (c->cpath) {
tor_assert(CIRCUIT_IS_ORIGIN(c));
tor_assert(!c->n_crypto);
tor_assert(!c->p_crypto);
tor_assert(!c->n_digest);
tor_assert(!c->p_digest);
} else {
tor_assert(!CIRCUIT_IS_ORIGIN(c));
tor_assert(c->n_crypto);
tor_assert(c->p_crypto);
tor_assert(c->n_digest);
tor_assert(c->p_digest);
}
}
if (c->cpath) {
assert_cpath_ok(c->cpath);
}
if (c->purpose == CIRCUIT_PURPOSE_REND_ESTABLISHED) {
if (!c->marked_for_close) {
tor_assert(c->rend_splice);
tor_assert(c->rend_splice->rend_splice == c);
}
tor_assert(c->rend_splice != c);
} else {
tor_assert(!c->rend_splice);
}
}
/*
Local Variables:
mode:c
indent-tabs-mode:nil
c-basic-offset:2
End:
*/

821
src/or/circuituse.c Normal file
View File

@ -0,0 +1,821 @@
/* Copyright 2001 Matej Pfajfar, 2001-2004 Roger Dingledine. */
/* See LICENSE for licensing information */
/* $Id$ */
/**
* \file circuituse.c
* \brief Launch the right sort of circuits, attach streams to them.
**/
#include "or.h"
extern or_options_t options; /* command-line and config-file options */
/********* START VARIABLES **********/
extern circuit_t *global_circuitlist; /* from circuitlist.c */
/********* END VARIABLES ************/
static void circuit_expire_old_circuits(void);
static void circuit_increment_failure_count(void);
/* Return 1 if <b>circ</b> could be returned by circuit_get_best().
* Else return 0.
*/
static int circuit_is_acceptable(circuit_t *circ,
connection_t *conn,
int must_be_open,
uint8_t purpose,
time_t now)
{
routerinfo_t *exitrouter;
if (!CIRCUIT_IS_ORIGIN(circ))
return 0; /* this circ doesn't start at us */
if (must_be_open && (circ->state != CIRCUIT_STATE_OPEN || !circ->n_conn))
return 0; /* ignore non-open circs */
if (circ->marked_for_close)
return 0;
/* if this circ isn't our purpose, skip. */
if(purpose == CIRCUIT_PURPOSE_C_REND_JOINED && !must_be_open) {
if(circ->purpose != CIRCUIT_PURPOSE_C_ESTABLISH_REND &&
circ->purpose != CIRCUIT_PURPOSE_C_REND_READY &&
circ->purpose != CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED &&
circ->purpose != CIRCUIT_PURPOSE_C_REND_JOINED)
return 0;
} else if (purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT && !must_be_open) {
if (circ->purpose != CIRCUIT_PURPOSE_C_INTRODUCING &&
circ->purpose != CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT)
return 0;
} else {
if(purpose != circ->purpose)
return 0;
}
if(purpose == CIRCUIT_PURPOSE_C_GENERAL)
if(circ->timestamp_dirty &&
circ->timestamp_dirty+options.NewCircuitPeriod < now)
return 0;
if(conn) {
/* decide if this circ is suitable for this conn */
/* for rend circs, circ->cpath->prev is not the last router in the
* circuit, it's the magical extra bob hop. so just check the nickname
* of the one we meant to finish at.
*/
exitrouter = router_get_by_nickname(circ->build_state->chosen_exit);
if(!exitrouter) {
log_fn(LOG_INFO,"Skipping broken circ (exit router vanished)");
return 0; /* this circuit is screwed and doesn't know it yet */
}
if(purpose == CIRCUIT_PURPOSE_C_GENERAL) {
if(connection_ap_can_use_exit(conn, exitrouter) == ADDR_POLICY_REJECTED) {
/* can't exit from this router */
return 0;
}
} else { /* not general */
if(rend_cmp_service_ids(conn->rend_query, circ->rend_query) &&
(circ->rend_query[0] || purpose != CIRCUIT_PURPOSE_C_REND_JOINED)) {
/* this circ is not for this conn, and it's not suitable
* for cannibalizing either */
return 0;
}
}
}
return 1;
}
/* Return 1 if circuit <b>a</b> is better than circuit <b>b</b> for
* <b>purpose</b>, and return 0 otherwise. Used by circuit_get_best.
*/
static int circuit_is_better(circuit_t *a, circuit_t *b, uint8_t purpose)
{
switch(purpose) {
case CIRCUIT_PURPOSE_C_GENERAL:
/* if it's used but less dirty it's best;
* else if it's more recently created it's best
*/
if(b->timestamp_dirty) {
if(a->timestamp_dirty &&
a->timestamp_dirty > b->timestamp_dirty)
return 1;
} else {
if(a->timestamp_dirty ||
a->timestamp_created > b->timestamp_created)
return 1;
}
break;
case CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT:
/* the closer it is to ack_wait the better it is */
if(a->purpose > b->purpose)
return 1;
break;
case CIRCUIT_PURPOSE_C_REND_JOINED:
/* the closer it is to rend_joined the better it is */
if(a->purpose > b->purpose)
return 1;
break;
}
return 0;
}
/** Find the best circ that conn can use, preferably one which is
* dirty. Circ must not be too old.
*
* Conn must be defined.
*
* If must_be_open, ignore circs not in CIRCUIT_STATE_OPEN.
*
* circ_purpose specifies what sort of circuit we must have.
* It can be C_GENERAL, C_INTRODUCE_ACK_WAIT, or C_REND_JOINED.
*
* If it's REND_JOINED and must_be_open==0, then return the closest
* rendezvous-purposed circuit that you can find.
*
* If it's INTRODUCE_ACK_WAIT and must_be_open==0, then return the
* closest introduce-purposed circuit that you can find.
*/
static circuit_t *
circuit_get_best(connection_t *conn, int must_be_open, uint8_t purpose)
{
circuit_t *circ, *best=NULL;
time_t now = time(NULL);
tor_assert(conn);
tor_assert(purpose == CIRCUIT_PURPOSE_C_GENERAL ||
purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT ||
purpose == CIRCUIT_PURPOSE_C_REND_JOINED);
for (circ=global_circuitlist;circ;circ = circ->next) {
if (!circuit_is_acceptable(circ,conn,must_be_open,purpose,now))
continue;
/* now this is an acceptable circ to hand back. but that doesn't
* mean it's the *best* circ to hand back. try to decide.
*/
if(!best || circuit_is_better(circ,best,purpose))
best = circ;
}
return best;
}
/** Circuits that were born at the end of their second might be expired
* after 30.1 seconds; circuits born at the beginning might be expired
* after closer to 31 seconds.
*/
#define MIN_SECONDS_BEFORE_EXPIRING_CIRC 30
/** Close all circuits that start at us, aren't open, and were born
* at least MIN_SECONDS_BEFORE_EXPIRING_CIRC seconds ago.
*/
void circuit_expire_building(time_t now) {
circuit_t *victim, *circ = global_circuitlist;
while(circ) {
victim = circ;
circ = circ->next;
if(!CIRCUIT_IS_ORIGIN(victim))
continue; /* didn't originate here */
if(victim->marked_for_close)
continue; /* don't mess with marked circs */
if(victim->timestamp_created + MIN_SECONDS_BEFORE_EXPIRING_CIRC > now)
continue; /* it's young still, don't mess with it */
/* some debug logs, to help track bugs */
if(victim->purpose >= CIRCUIT_PURPOSE_C_INTRODUCING &&
victim->purpose <= CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED) {
if(!victim->timestamp_dirty)
log_fn(LOG_DEBUG,"Considering %sopen purp %d to %s (circid %d). (clean).",
victim->state == CIRCUIT_STATE_OPEN ? "" : "non",
victim->purpose, victim->build_state->chosen_exit,
victim->n_circ_id);
else
log_fn(LOG_DEBUG,"Considering %sopen purp %d to %s (circid %d). %d secs since dirty.",
victim->state == CIRCUIT_STATE_OPEN ? "" : "non",
victim->purpose, victim->build_state->chosen_exit,
victim->n_circ_id,
(int)(now - victim->timestamp_dirty));
}
/* if circ is !open, or if it's open but purpose is a non-finished
* intro or rend, then mark it for close */
if(victim->state != CIRCUIT_STATE_OPEN ||
victim->purpose == CIRCUIT_PURPOSE_C_ESTABLISH_REND ||
victim->purpose == CIRCUIT_PURPOSE_C_INTRODUCING ||
victim->purpose == CIRCUIT_PURPOSE_S_ESTABLISH_INTRO ||
/* it's a rend_ready circ, but it's already picked a query */
(victim->purpose == CIRCUIT_PURPOSE_C_REND_READY &&
victim->rend_query[0]) ||
/* c_rend_ready circs measure age since timestamp_dirty,
* because that's set when they switch purposes
*/
/* rend and intro circs become dirty each time they
* make an introduction attempt. so timestamp_dirty
* will reflect the time since the last attempt.
*/
((victim->purpose == CIRCUIT_PURPOSE_C_REND_READY ||
victim->purpose == CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED ||
victim->purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT) &&
victim->timestamp_dirty + MIN_SECONDS_BEFORE_EXPIRING_CIRC > now)) {
if(victim->n_conn)
log_fn(LOG_INFO,"Abandoning circ %s:%d:%d (state %d:%s, purpose %d)",
victim->n_conn->address, victim->n_port, victim->n_circ_id,
victim->state, circuit_state_to_string[victim->state], victim->purpose);
else
log_fn(LOG_INFO,"Abandoning circ %d (state %d:%s, purpose %d)", victim->n_circ_id,
victim->state, circuit_state_to_string[victim->state], victim->purpose);
circuit_log_path(LOG_INFO,victim);
circuit_mark_for_close(victim);
}
}
}
/** How many circuits do we want simultaneously in-progress to handle
* a given stream?
*/
#define MIN_CIRCUITS_HANDLING_STREAM 2
/** Return 1 if at least MIN_CIRCUITS_HANDLING_STREAM non-open
* general-purpose circuits will have an acceptable exit node for
* conn. Else return 0.
*/
int circuit_stream_is_being_handled(connection_t *conn) {
circuit_t *circ;
routerinfo_t *exitrouter;
int num=0;
time_t now = time(NULL);
for(circ=global_circuitlist;circ;circ = circ->next) {
if(CIRCUIT_IS_ORIGIN(circ) && circ->state != CIRCUIT_STATE_OPEN &&
!circ->marked_for_close && circ->purpose == CIRCUIT_PURPOSE_C_GENERAL &&
(!circ->timestamp_dirty ||
circ->timestamp_dirty + options.NewCircuitPeriod < now)) {
exitrouter = router_get_by_nickname(circ->build_state->chosen_exit);
if(exitrouter && connection_ap_can_use_exit(conn, exitrouter) != ADDR_POLICY_REJECTED)
if(++num >= MIN_CIRCUITS_HANDLING_STREAM)
return 1;
}
}
return 0;
}
/** Build a new test circuit every 5 minutes */
#define TESTING_CIRCUIT_INTERVAL 300
/** This function is called once a second. Its job is to make sure
* all services we offer have enough circuits available. Some
* services just want enough circuits for current tasks, whereas
* others want a minimum set of idle circuits hanging around.
*/
void circuit_build_needed_circs(time_t now) {
static long time_to_new_circuit = 0;
circuit_t *circ;
/* launch a new circ for any pending streams that need one */
connection_ap_attach_pending();
/* make sure any hidden services have enough intro points */
rend_services_introduce();
circ = circuit_get_youngest_clean_open(CIRCUIT_PURPOSE_C_GENERAL);
if(time_to_new_circuit < now) {
circuit_reset_failure_count();
time_to_new_circuit = now + options.NewCircuitPeriod;
if(options.SocksPort)
client_dns_clean();
circuit_expire_old_circuits();
if(options.RunTesting && circ &&
circ->timestamp_created + TESTING_CIRCUIT_INTERVAL < now) {
log_fn(LOG_INFO,"Creating a new testing circuit.");
circuit_launch_new(CIRCUIT_PURPOSE_C_GENERAL, NULL);
}
}
/** How many simultaneous in-progress general-purpose circuits do we
* want to be building at once, if there are no open general-purpose
* circuits?
*/
#define CIRCUIT_MIN_BUILDING_GENERAL 3
/* if there's no open circ, and less than 3 are on the way,
* go ahead and try another. */
if(!circ && circuit_count_building(CIRCUIT_PURPOSE_C_GENERAL)
< CIRCUIT_MIN_BUILDING_GENERAL) {
circuit_launch_new(CIRCUIT_PURPOSE_C_GENERAL, NULL);
}
/* XXX count idle rendezvous circs and build more */
}
/** If the stream <b>conn</b> is a member of any of the linked
* lists of <b>circ</b>, then remove it from the list.
*/
void circuit_detach_stream(circuit_t *circ, connection_t *conn) {
connection_t *prevconn;
tor_assert(circ && conn);
if(conn == circ->p_streams) {
circ->p_streams = conn->next_stream;
return;
}
if(conn == circ->n_streams) {
circ->n_streams = conn->next_stream;
return;
}
if(conn == circ->resolving_streams) {
circ->resolving_streams = conn->next_stream;
return;
}
for(prevconn = circ->p_streams;
prevconn && prevconn->next_stream && prevconn->next_stream != conn;
prevconn = prevconn->next_stream)
;
if(prevconn && prevconn->next_stream) {
prevconn->next_stream = conn->next_stream;
return;
}
for(prevconn = circ->n_streams;
prevconn && prevconn->next_stream && prevconn->next_stream != conn;
prevconn = prevconn->next_stream)
;
if(prevconn && prevconn->next_stream) {
prevconn->next_stream = conn->next_stream;
return;
}
for(prevconn = circ->resolving_streams;
prevconn && prevconn->next_stream && prevconn->next_stream != conn;
prevconn = prevconn->next_stream)
;
if(prevconn && prevconn->next_stream) {
prevconn->next_stream = conn->next_stream;
return;
}
log_fn(LOG_ERR,"edge conn not in circuit's list?");
tor_assert(0); /* should never get here */
}
/** Notify the global circuit list that <b>conn</b> is about to be
* removed and then freed.
*
* If it's an OR conn, then mark-for-close all the circuits that use
* that conn.
*
* If it's an edge conn, then detach it from its circ, so we don't
* try to reference it later.
*/
void circuit_about_to_close_connection(connection_t *conn) {
/* currently, we assume it's too late to flush conn's buf here.
* down the road, maybe we'll consider that eof doesn't mean can't-write
*/
circuit_t *circ;
switch(conn->type) {
case CONN_TYPE_OR:
/* We must close all the circuits on it. */
while((circ = circuit_get_by_conn(conn))) {
if(circ->n_conn == conn) /* it's closing in front of us */
circ->n_conn = NULL;
if(circ->p_conn == conn) /* it's closing behind us */
circ->p_conn = NULL;
circuit_mark_for_close(circ);
}
return;
case CONN_TYPE_AP:
case CONN_TYPE_EXIT:
/* It's an edge conn. Need to remove it from the linked list of
* conn's for this circuit. Confirm that 'end' relay command has
* been sent. But don't kill the circuit.
*/
circ = circuit_get_by_conn(conn);
if(!circ)
return;
circuit_detach_stream(circ, conn);
} /* end switch */
}
/** Don't keep more than 10 unused open circuits around. */
#define MAX_UNUSED_OPEN_CIRCUITS 10
/** Find each circuit that has been dirty for too long, and has
* no streams on it: mark it for close.
*
* Also, if there are more than MAX_UNUSED_OPEN_CIRCUITS open and
* unused circuits, then mark the excess circs for close.
*/
static void
circuit_expire_old_circuits(void)
{
circuit_t *circ;
time_t now = time(NULL);
smartlist_t *unused_open_circs;
int i;
unused_open_circs = smartlist_create();
for (circ = global_circuitlist; circ; circ = circ->next) {
if (circ->marked_for_close)
continue;
/* If the circuit has been dirty for too long, and there are no streams
* on it, mark it for close.
*/
if (circ->timestamp_dirty &&
circ->timestamp_dirty + options.NewCircuitPeriod < now &&
!circ->p_conn && /* we're the origin */
!circ->p_streams /* nothing attached */ ) {
log_fn(LOG_DEBUG,"Closing n_circ_id %d (dirty %d secs ago, purp %d)",circ->n_circ_id,
(int)(now - circ->timestamp_dirty), circ->purpose);
/* (only general and purpose_c circs can get dirty) */
tor_assert(!circ->n_streams);
tor_assert(circ->purpose <= CIRCUIT_PURPOSE_C_REND_JOINED);
circuit_mark_for_close(circ);
} else if (!circ->timestamp_dirty && CIRCUIT_IS_ORIGIN(circ) &&
circ->state == CIRCUIT_STATE_OPEN &&
circ->purpose == CIRCUIT_PURPOSE_C_GENERAL) {
/* Also, gather a list of open unused general circuits that we created.
* Because we add elements to the front of global_circuitlist,
* the last elements of unused_open_circs will be the oldest
* ones.
*/
smartlist_add(unused_open_circs, circ);
}
}
for (i = MAX_UNUSED_OPEN_CIRCUITS; i < smartlist_len(unused_open_circs); ++i) {
circuit_t *circ = smartlist_get(unused_open_circs, i);
log_fn(LOG_DEBUG,"Expiring excess clean circ (n_circ_id %d, purp %d)",
circ->n_circ_id, circ->purpose);
circuit_mark_for_close(circ);
}
smartlist_free(unused_open_circs);
}
/** The circuit <b>circ</b> has just become open. Take the next
* step: for rendezvous circuits, we pass circ to the appropriate
* function in rendclient or rendservice. For general circuits, we
* call connection_ap_attach_pending, which looks for pending streams
* that could use circ.
*/
void circuit_has_opened(circuit_t *circ) {
switch(circ->purpose) {
case CIRCUIT_PURPOSE_C_ESTABLISH_REND:
rend_client_rendcirc_has_opened(circ);
break;
case CIRCUIT_PURPOSE_C_INTRODUCING:
rend_client_introcirc_has_opened(circ);
break;
case CIRCUIT_PURPOSE_C_GENERAL:
/* Tell any AP connections that have been waiting for a new
* circuit that one is ready. */
connection_ap_attach_pending();
break;
case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO:
/* at Bob, waiting for introductions */
rend_service_intro_has_opened(circ);
break;
case CIRCUIT_PURPOSE_S_CONNECT_REND:
/* at Bob, connecting to rend point */
rend_service_rendezvous_has_opened(circ);
break;
default:
log_fn(LOG_ERR,"unhandled purpose %d",circ->purpose);
tor_assert(0);
}
}
/*~ Called whenever a circuit could not be successfully built.
*/
void circuit_build_failed(circuit_t *circ) {
/* we should examine circ and see if it failed because of
* the last hop or an earlier hop. then use this info below.
*/
int failed_at_last_hop = 0;
/* If the last hop isn't open, and the second-to-last is, we failed
* at the last hop. */
if (circ->cpath &&
circ->cpath->prev->state != CPATH_STATE_OPEN &&
circ->cpath->prev->prev->state == CPATH_STATE_OPEN) {
failed_at_last_hop = 1;
}
switch(circ->purpose) {
case CIRCUIT_PURPOSE_C_GENERAL:
if (circ->state != CIRCUIT_STATE_OPEN) {
/* If we never built the circuit, note it as a failure. */
/* Note that we can't just check circ->cpath here, because if
* circuit-building failed immediately, it won't be set yet. */
circuit_increment_failure_count();
}
break;
case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO:
/* at Bob, waiting for introductions */
if (circ->state != CIRCUIT_STATE_OPEN) {
circuit_increment_failure_count();
}
/* no need to care here, because bob will rebuild intro
* points periodically. */
break;
case CIRCUIT_PURPOSE_C_INTRODUCING:
/* at Alice, connecting to intro point */
/* Don't increment failure count, since Bob may have picked
* the introduction point maliciously */
/* Alice will pick a new intro point when this one dies, if
* the stream in question still cares. No need to act here. */
break;
case CIRCUIT_PURPOSE_C_ESTABLISH_REND:
/* at Alice, waiting for Bob */
if (circ->state != CIRCUIT_STATE_OPEN) {
circuit_increment_failure_count();
}
/* Alice will pick a new rend point when this one dies, if
* the stream in question still cares. No need to act here. */
break;
case CIRCUIT_PURPOSE_S_CONNECT_REND:
/* at Bob, connecting to rend point */
/* Don't increment failure count, since Alice may have picked
* the rendezvous point maliciously */
if (failed_at_last_hop) {
log_fn(LOG_INFO,"Couldn't connect to Alice's chosen rend point %s. Sucks to be Alice.", circ->build_state->chosen_exit);
} else {
log_fn(LOG_INFO,"Couldn't connect to Alice's chosen rend point %s, because an earlier node failed.",
circ->build_state->chosen_exit);
rend_service_relaunch_rendezvous(circ);
}
break;
default:
/* Other cases are impossible, since this function is only called with
* unbuilt circuits. */
tor_assert(0);
}
}
/** Number of consecutive failures so far; should only be touched by
* circuit_launch_new and circuit_*_failure_count.
*/
static int n_circuit_failures = 0;
/** Don't retry launching a new circuit if we try this many times with no
* success. */
#define MAX_CIRCUIT_FAILURES 5
/** Launch a new circuit and return a pointer to it. Return NULL if you failed. */
circuit_t *circuit_launch_new(uint8_t purpose, const char *exit_nickname) {
if (n_circuit_failures > MAX_CIRCUIT_FAILURES) {
/* too many failed circs in a row. don't try. */
// log_fn(LOG_INFO,"%d failures so far, not trying.",n_circuit_failures);
return NULL;
}
/* try a circ. if it fails, circuit_mark_for_close will increment n_circuit_failures */
return circuit_establish_circuit(purpose, exit_nickname);
}
/** Record another failure at opening a general circuit. When we have
* too many, we'll stop trying for the remainder of this minute.
*/
static void circuit_increment_failure_count(void) {
++n_circuit_failures;
log_fn(LOG_DEBUG,"n_circuit_failures now %d.",n_circuit_failures);
}
/** Reset the failure count for opening general circuits. This means
* we will try MAX_CIRCUIT_FAILURES times more (if necessary) before
* stopping again.
*/
void circuit_reset_failure_count(void) {
n_circuit_failures = 0;
}
/** Find an open circ that we're happy with: return 1. If there isn't
* one, and there isn't one on the way, launch one and return 0. If it
* will never work, return -1.
*
* Write the found or in-progress or launched circ into *circp.
*/
static int
circuit_get_open_circ_or_launch(connection_t *conn,
uint8_t desired_circuit_purpose,
circuit_t **circp) {
circuit_t *circ;
uint32_t addr;
tor_assert(conn);
tor_assert(circp);
tor_assert(conn->state == AP_CONN_STATE_CIRCUIT_WAIT);
circ = circuit_get_best(conn, 1, desired_circuit_purpose);
if(circ) {
*circp = circ;
return 1; /* we're happy */
}
if(!connection_edge_is_rendezvous_stream(conn)) { /* general purpose circ */
addr = client_dns_lookup_entry(conn->socks_request->address);
if(router_exit_policy_all_routers_reject(addr, conn->socks_request->port)) {
log_fn(LOG_WARN,"No Tor server exists that allows exit to %s:%d. Rejecting.",
conn->socks_request->address, conn->socks_request->port);
return -1;
}
}
/* is one already on the way? */
circ = circuit_get_best(conn, 0, desired_circuit_purpose);
if(!circ) {
char *exitname=NULL;
uint8_t new_circ_purpose;
if(desired_circuit_purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT) {
/* need to pick an intro point */
exitname = rend_client_get_random_intro(conn->rend_query);
if(!exitname) {
log_fn(LOG_WARN,"Couldn't get an intro point for '%s'. Closing conn.",
conn->rend_query);
return -1;
}
if(!router_get_by_nickname(exitname)) {
log_fn(LOG_WARN,"Advertised intro point '%s' is not known. Closing.", exitname);
return -1;
}
/* XXX if we failed, then refetch the descriptor */
log_fn(LOG_INFO,"Chose %s as intro point for %s.", exitname, conn->rend_query);
}
if(desired_circuit_purpose == CIRCUIT_PURPOSE_C_REND_JOINED)
new_circ_purpose = CIRCUIT_PURPOSE_C_ESTABLISH_REND;
else if(desired_circuit_purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT)
new_circ_purpose = CIRCUIT_PURPOSE_C_INTRODUCING;
else
new_circ_purpose = desired_circuit_purpose;
circ = circuit_launch_new(new_circ_purpose, exitname);
tor_free(exitname);
if(circ &&
(desired_circuit_purpose != CIRCUIT_PURPOSE_C_GENERAL)) {
/* then write the service_id into circ */
strcpy(circ->rend_query, conn->rend_query);
}
}
if(!circ)
log_fn(LOG_INFO,"No safe circuit (purpose %d) ready for edge connection; delaying.",
desired_circuit_purpose);
*circp = circ;
return 0;
}
/** Attach the AP stream <b>apconn</b> to circ's linked list of
* p_streams. Also set apconn's cpath_layer to the last hop in
* circ's cpath.
*/
static void link_apconn_to_circ(connection_t *apconn, circuit_t *circ) {
/* add it into the linked list of streams on this circuit */
log_fn(LOG_DEBUG,"attaching new conn to circ. n_circ_id %d.", circ->n_circ_id);
apconn->next_stream = circ->p_streams;
/* assert_connection_ok(conn, time(NULL)); */
circ->p_streams = apconn;
tor_assert(CIRCUIT_IS_ORIGIN(circ) && circ->cpath && circ->cpath->prev);
tor_assert(circ->cpath->prev->state == CPATH_STATE_OPEN);
apconn->cpath_layer = circ->cpath->prev;
}
/** Try to find a safe live circuit for CONN_TYPE_AP connection conn. If
* we don't find one: if conn cannot be handled by any known nodes,
* warn and return -1 (conn needs to die);
* else launch new circuit (if necessary) and return 0.
* Otherwise, associate conn with a safe live circuit, do the
* right next step, and return 1.
*/
int connection_ap_handshake_attach_circuit(connection_t *conn) {
int retval;
int conn_age;
tor_assert(conn);
tor_assert(conn->type == CONN_TYPE_AP);
tor_assert(conn->state == AP_CONN_STATE_CIRCUIT_WAIT);
tor_assert(conn->socks_request);
conn_age = time(NULL) - conn->timestamp_created;
if(conn_age > 60) {
/* XXX make this cleaner than '60' */
log_fn(LOG_WARN,"Giving up on unattached conn (%d sec old).", conn_age);
return -1;
}
if(!connection_edge_is_rendezvous_stream(conn)) { /* we're a general conn */
circuit_t *circ=NULL;
/* find the circuit that we should use, if there is one. */
retval = circuit_get_open_circ_or_launch(conn, CIRCUIT_PURPOSE_C_GENERAL, &circ);
if(retval < 1)
return retval;
/* We have found a suitable circuit for our conn. Hurray. */
log_fn(LOG_DEBUG,"Attaching apconn to general circ %d (stream %d sec old).",
circ->n_circ_id, conn_age);
/* here, print the circ's path. so people can figure out which circs are sucking. */
circuit_log_path(LOG_INFO,circ);
if(!circ->timestamp_dirty)
circ->timestamp_dirty = time(NULL);
link_apconn_to_circ(conn, circ);
connection_ap_handshake_send_begin(conn, circ);
return 1;
} else { /* we're a rendezvous conn */
circuit_t *rendcirc=NULL, *introcirc=NULL;
tor_assert(!conn->cpath_layer);
/* start by finding a rendezvous circuit for us */
retval = circuit_get_open_circ_or_launch(conn, CIRCUIT_PURPOSE_C_REND_JOINED, &rendcirc);
if(retval < 0) return -1; /* failed */
tor_assert(rendcirc);
if(retval > 0) {
/* one is already established, attach */
log_fn(LOG_INFO,"rend joined circ %d already here. attaching. (stream %d sec old)",
rendcirc->n_circ_id, conn_age);
link_apconn_to_circ(conn, rendcirc);
if(connection_ap_handshake_send_begin(conn, rendcirc) < 0)
return 0; /* already marked, let them fade away */
return 1;
}
if(rendcirc->purpose == CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED) {
log_fn(LOG_INFO,"pending-join circ %d already here, with intro ack. Stalling. (stream %d sec old)", rendcirc->n_circ_id, conn_age);
return 0;
}
/* it's on its way. find an intro circ. */
retval = circuit_get_open_circ_or_launch(conn, CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT, &introcirc);
if(retval < 0) return -1; /* failed */
tor_assert(introcirc);
if(retval > 0) {
/* one has already sent the intro. keep waiting. */
log_fn(LOG_INFO,"Intro circ %d present and awaiting ack (rend %d). Stalling. (stream %d sec old)",
introcirc->n_circ_id, rendcirc->n_circ_id, conn_age);
return 0;
}
/* now both rendcirc and introcirc are defined, and neither is finished */
if(rendcirc->purpose == CIRCUIT_PURPOSE_C_REND_READY) {
log_fn(LOG_INFO,"ready rend circ %d already here (no intro-ack yet on intro %d). (stream %d sec old)",
rendcirc->n_circ_id, introcirc->n_circ_id, conn_age);
/* look around for any new intro circs that should introduce */
tor_assert(introcirc->purpose == CIRCUIT_PURPOSE_C_INTRODUCING);
if(introcirc->state == CIRCUIT_STATE_OPEN) {
log_fn(LOG_INFO,"found open intro circ %d (rend %d); sending introduction. (stream %d sec old)",
introcirc->n_circ_id, rendcirc->n_circ_id, conn_age);
/* XXX here we should cannibalize the rend circ if it's a zero service id */
if(rend_client_send_introduction(introcirc, rendcirc) < 0) {
return -1;
}
rendcirc->timestamp_dirty = time(NULL);
introcirc->timestamp_dirty = time(NULL);
assert_circuit_ok(rendcirc);
assert_circuit_ok(introcirc);
return 0;
}
}
log_fn(LOG_INFO,"Intro (%d) and rend (%d) circs are not both ready. Stalling conn. (%d sec old)", introcirc->n_circ_id, rendcirc->n_circ_id, conn_age);
return 0;
}
}
/*
Local Variables:
mode:c
indent-tabs-mode:nil
c-basic-offset:2
End:
*/

716
src/or/connection_edge.c
View File

@ -4,7 +4,7 @@
/**
* \file connection_edge.c
* \brief Handle edge streams and relay cells.
* \brief Handle edge streams.
**/
#include "or.h"
@ -15,38 +15,6 @@ extern char *conn_state_to_string[][_CONN_TYPE_MAX+1]; /* from connection.c */
static int connection_ap_handshake_process_socks(connection_t *conn);
static int connection_exit_begin_conn(cell_t *cell, circuit_t *circ);
static void connection_edge_consider_sending_sendme(connection_t *conn);
static uint32_t client_dns_lookup_entry(const char *address);
static void client_dns_set_entry(const char *address, uint32_t val);
static int client_dns_incr_failures(const char *address);
/** Pack the relay_header_t host-order structure <b>src</b> into
* network-order in the buffer <b>dest</b>. See tor-spec.txt for details
* about the wire format.
*/
void relay_header_pack(char *dest, const relay_header_t *src) {
*(uint8_t*)(dest) = src->command;
set_uint16(dest+1, htons(src->recognized));
set_uint16(dest+3, htons(src->stream_id));
memcpy(dest+5, src->integrity, 4);
set_uint16(dest+9, htons(src->length));
}
/** Unpack the network-order buffer <b>src</b> into a host-order
* relay_header_t structure <b>dest</b>.
*/
void relay_header_unpack(relay_header_t *dest, const char *src) {
dest->command = *(uint8_t*)(src);
dest->recognized = ntohs(get_uint16(src+1));
dest->stream_id = ntohs(get_uint16(src+3));
memcpy(dest->integrity, src+5, 4);
dest->length = ntohs(get_uint16(src+9));
}
/** Handle new bytes on conn->inbuf, or notification of eof.
*
* If there was an EOF, then send an end and mark the connection
@ -142,33 +110,6 @@ int connection_edge_destroy(uint16_t circ_id, connection_t *conn) {
return 0;
}
/** Translate the <b>payload</b> of length <b>length</b>, which
* came from a relay 'end' cell, into a static const string describing
* why the stream is closing.
*/
static const char *
connection_edge_end_reason(char *payload, uint16_t length) {
if(length < 1) {
log_fn(LOG_WARN,"End cell arrived with length 0. Should be at least 1.");
return "MALFORMED";
}
if(*payload < _MIN_END_STREAM_REASON || *payload > _MAX_END_STREAM_REASON) {
log_fn(LOG_WARN,"Reason for ending (%d) not recognized.",*payload);
return "MALFORMED";
}
switch(*payload) {
case END_STREAM_REASON_MISC: return "misc error";
case END_STREAM_REASON_RESOLVEFAILED: return "resolve failed";
case END_STREAM_REASON_CONNECTFAILED: return "connect failed";
case END_STREAM_REASON_EXITPOLICY: return "exit policy failed";
case END_STREAM_REASON_DESTROY: return "destroyed";
case END_STREAM_REASON_DONE: return "closed normally";
case END_STREAM_REASON_TIMEOUT: return "gave up (timeout)";
}
tor_assert(0);
return "";
}
/** Send a relay end cell from stream <b>conn</b> to conn's circuit,
* with a destination of cpath_layer. (If cpath_layer is NULL, the
* destination is the circuit's origin.) Mark the relay end cell as
@ -210,338 +151,6 @@ connection_edge_end(connection_t *conn, char reason, crypt_path_t *cpath_layer)
return 0;
}
/** Make a relay cell out of <b>relay_command</b> and <b>payload</b>, and
* send it onto the open circuit <b>circ</b>. <b>fromconn</b> is the stream
* that's sending the relay cell, or NULL if it's a control cell.
* <b>cpath_layer</b> is NULL for OR->OP cells, or the destination hop
* for OP->OR cells.
*
* If you can't send the cell, mark the circuit for close and
* return -1. Else return 0.
*/
int connection_edge_send_command(connection_t *fromconn, circuit_t *circ,
int relay_command, const char *payload,
int payload_len, crypt_path_t *cpath_layer) {
cell_t cell;
relay_header_t rh;
int cell_direction;
if(!circ) {
log_fn(LOG_WARN,"no circ. Closing conn.");
tor_assert(fromconn);
fromconn->has_sent_end = 1; /* no circ to send to */
connection_mark_for_close(fromconn);
return -1;
}
memset(&cell, 0, sizeof(cell_t));
cell.command = CELL_RELAY;
if(cpath_layer) {
cell.circ_id = circ->n_circ_id;
cell_direction = CELL_DIRECTION_OUT;
} else {
cell.circ_id = circ->p_circ_id;
cell_direction = CELL_DIRECTION_IN;
}
memset(&rh, 0, sizeof(rh));
rh.command = relay_command;
if(fromconn)
rh.stream_id = fromconn->stream_id; /* else it's 0 */
rh.length = payload_len;
relay_header_pack(cell.payload, &rh);
if(payload_len)
memcpy(cell.payload+RELAY_HEADER_SIZE, payload, payload_len);
log_fn(LOG_DEBUG,"delivering %d cell %s.", relay_command,
cell_direction == CELL_DIRECTION_OUT ? "forward" : "backward");
if(circuit_package_relay_cell(&cell, circ, cell_direction, cpath_layer) < 0) {
log_fn(LOG_WARN,"circuit_package_relay_cell failed. Closing.");
circuit_mark_for_close(circ);
return -1;
}
return 0;
}
/** How many times will I retry a stream that fails due to DNS
* resolve failure?
*/
#define MAX_RESOLVE_FAILURES 3
/** An incoming relay cell has arrived from circuit <b>circ</b> to
* stream <b>conn</b>.
*
* The arguments here are the same as in
* connection_edge_process_relay_cell() below; this function is called
* from there when <b>conn</b> is defined and not in an open state.
*/
static int
connection_edge_process_relay_cell_not_open(
relay_header_t *rh, cell_t *cell, circuit_t *circ,
connection_t *conn, crypt_path_t *layer_hint) {
uint32_t addr;
int reason;
if(rh->command == RELAY_COMMAND_END) {
reason = *(cell->payload+RELAY_HEADER_SIZE);
/* We have to check this here, since we aren't connected yet. */
if (rh->length >= 5 && reason == END_STREAM_REASON_EXITPOLICY) {
log_fn(LOG_INFO,"Address %s refused due to exit policy. Retrying.",
conn->socks_request->address);
addr = ntohl(get_uint32(cell->payload+RELAY_HEADER_SIZE+1));
client_dns_set_entry(conn->socks_request->address, addr);
conn->state = AP_CONN_STATE_CIRCUIT_WAIT;
circuit_detach_stream(circ,conn);
if(connection_ap_handshake_attach_circuit(conn) >= 0)
return 0;
log_fn(LOG_INFO,"Giving up on retrying (from exitpolicy); conn can't be handled.");
/* else, conn will get closed below */
} else if (rh->length && reason == END_STREAM_REASON_RESOLVEFAILED) {
if (client_dns_incr_failures(conn->socks_request->address)
< MAX_RESOLVE_FAILURES) {
/* We haven't retried too many times; reattach the connection. */
conn->state = AP_CONN_STATE_CIRCUIT_WAIT;
circuit_detach_stream(circ,conn);
if(connection_ap_handshake_attach_circuit(conn) >= 0)
return 0;
/* else, conn will get closed below */
log_fn(LOG_INFO,"Giving up on retrying (from resolvefailed); conn can't be handled.");
} else {
log_fn(LOG_WARN,"Have tried resolving address %s at %d different places. Giving up.",
conn->socks_request->address, MAX_RESOLVE_FAILURES);
}
}
log_fn(LOG_INFO,"Edge got end (%s) before we're connected. Marking for close.",
connection_edge_end_reason(cell->payload+RELAY_HEADER_SIZE, rh->length));
if(CIRCUIT_IS_ORIGIN(circ))
circuit_log_path(LOG_INFO,circ);
conn->has_sent_end = 1; /* we just got an 'end', don't need to send one */
connection_mark_for_close(conn);
return 0;
}
if(conn->type == CONN_TYPE_AP && rh->command == RELAY_COMMAND_CONNECTED) {
if(conn->state != AP_CONN_STATE_CONNECT_WAIT) {
log_fn(LOG_WARN,"Got 'connected' while not in state connect_wait. Dropping.");
return 0;
}
// log_fn(LOG_INFO,"Connected! Notifying application.");
conn->state = AP_CONN_STATE_OPEN;
if (rh->length >= 4) {
addr = ntohl(get_uint32(cell->payload+RELAY_HEADER_SIZE));
client_dns_set_entry(conn->socks_request->address, addr);
}
log_fn(LOG_INFO,"'connected' received after %d seconds.",
(int)(time(NULL) - conn->timestamp_lastread));
circuit_log_path(LOG_INFO,circ);
connection_ap_handshake_socks_reply(conn, NULL, 0, 1);
conn->socks_request->has_finished = 1;
/* handle anything that might have queued */
if (connection_edge_package_raw_inbuf(conn) < 0) {
connection_edge_end(conn, END_STREAM_REASON_MISC, conn->cpath_layer);
connection_mark_for_close(conn);
return 0;
}
return 0;
}
log_fn(LOG_WARN,"Got an unexpected relay command %d, in state %d (%s). Closing.",
rh->command, conn->state, conn_state_to_string[conn->type][conn->state]);
connection_edge_end(conn, END_STREAM_REASON_MISC, conn->cpath_layer);
connection_mark_for_close(conn);
return -1;
}
/** An incoming relay cell has arrived on circuit <b>circ</b>. If
* <b>conn</b> is NULL this is a control cell, else <b>cell</b> is
* destined for <b>conn</b>.
*
* If <b>layer_hint</b> is defined, then we're the origin of the
* circuit, and it specifies the hop that packaged <b>cell</b>.
*
* Return -1 if you want to tear down the circuit, else 0.
*/
int connection_edge_process_relay_cell(cell_t *cell, circuit_t *circ,
connection_t *conn,
crypt_path_t *layer_hint) {
static int num_seen=0;
relay_header_t rh;
tor_assert(cell && circ);
relay_header_unpack(&rh, cell->payload);
// log_fn(LOG_DEBUG,"command %d stream %d", rh.command, rh.stream_id);
num_seen++;
log_fn(LOG_DEBUG,"Now seen %d relay cells here.", num_seen);
/* either conn is NULL, in which case we've got a control cell, or else
* conn points to the recognized stream. */
if(conn &&
conn->state != AP_CONN_STATE_OPEN &&
conn->state != EXIT_CONN_STATE_OPEN) {
return connection_edge_process_relay_cell_not_open(
&rh, cell, circ, conn, layer_hint);
}
switch(rh.command) {
case RELAY_COMMAND_DROP:
log_fn(LOG_INFO,"Got a relay-level padding cell. Dropping.");
return 0;
case RELAY_COMMAND_BEGIN:
if (layer_hint &&
circ->purpose != CIRCUIT_PURPOSE_S_REND_JOINED) {
log_fn(LOG_WARN,"relay begin request unsupported at AP. Dropping.");
return 0;
}
if(conn) {
log_fn(LOG_WARN,"begin cell for known stream. Dropping.");
return 0;
}
connection_exit_begin_conn(cell, circ);
return 0;
case RELAY_COMMAND_DATA:
++stats_n_data_cells_received;
if((layer_hint && --layer_hint->deliver_window < 0) ||
(!layer_hint && --circ->deliver_window < 0)) {
log_fn(LOG_WARN,"(relay data) circ deliver_window below 0. Killing.");
connection_edge_end(conn, END_STREAM_REASON_MISC, conn->cpath_layer);
connection_mark_for_close(conn);
return -1;
}
log_fn(LOG_DEBUG,"circ deliver_window now %d.", layer_hint ?
layer_hint->deliver_window : circ->deliver_window);
circuit_consider_sending_sendme(circ, layer_hint);
if(!conn) {
log_fn(LOG_INFO,"data cell dropped, unknown stream.");
return 0;
}
if(--conn->deliver_window < 0) { /* is it below 0 after decrement? */
log_fn(LOG_WARN,"(relay data) conn deliver_window below 0. Killing.");
return -1; /* somebody's breaking protocol. kill the whole circuit. */
}
stats_n_data_bytes_received += rh.length;
connection_write_to_buf(cell->payload + RELAY_HEADER_SIZE,
rh.length, conn);
connection_edge_consider_sending_sendme(conn);
return 0;
case RELAY_COMMAND_END:
if(!conn) {
log_fn(LOG_INFO,"end cell (%s) dropped, unknown stream.",
connection_edge_end_reason(cell->payload+RELAY_HEADER_SIZE, rh.length));
return 0;
}
/* XXX add to this log_fn the exit node's nickname? */
log_fn(LOG_INFO,"end cell (%s) for stream %d. Removing stream.",
connection_edge_end_reason(cell->payload+RELAY_HEADER_SIZE, rh.length),
conn->stream_id);
#ifdef HALF_OPEN
conn->done_sending = 1;
shutdown(conn->s, 1); /* XXX check return; refactor NM */
if (conn->done_receiving) {
/* We just *got* an end; no reason to send one. */
conn->has_sent_end = 1;
connection_mark_for_close(conn);
conn->hold_open_until_flushed = 1;
}
#else
/* We just *got* an end; no reason to send one. */
conn->has_sent_end = 1;
connection_mark_for_close(conn);
conn->hold_open_until_flushed = 1;
#endif
return 0;
case RELAY_COMMAND_EXTEND:
if(conn) {
log_fn(LOG_WARN,"'extend' for non-zero stream. Dropping.");
return 0;
}
return circuit_extend(cell, circ);
case RELAY_COMMAND_EXTENDED:
if(!layer_hint) {
log_fn(LOG_WARN,"'extended' unsupported at non-origin. Dropping.");
return 0;
}
log_fn(LOG_DEBUG,"Got an extended cell! Yay.");
if(circuit_finish_handshake(circ, cell->payload+RELAY_HEADER_SIZE) < 0) {
log_fn(LOG_WARN,"circuit_finish_handshake failed.");
return -1;
}
if (circuit_send_next_onion_skin(circ)<0) {
log_fn(LOG_INFO,"circuit_send_next_onion_skin() failed.");
return -1;
}
return 0;
case RELAY_COMMAND_TRUNCATE:
if(layer_hint) {
log_fn(LOG_WARN,"'truncate' unsupported at origin. Dropping.");
return 0;
}
if(circ->n_conn) {
connection_send_destroy(circ->n_circ_id, circ->n_conn);
circ->n_conn = NULL;
}
log_fn(LOG_DEBUG, "Processed 'truncate', replying.");
connection_edge_send_command(NULL, circ, RELAY_COMMAND_TRUNCATED,
NULL, 0, NULL);
return 0;
case RELAY_COMMAND_TRUNCATED:
if(!layer_hint) {
log_fn(LOG_WARN,"'truncated' unsupported at non-origin. Dropping.");
return 0;
}
circuit_truncated(circ, layer_hint);
return 0;
case RELAY_COMMAND_CONNECTED:
if(conn) {
log_fn(LOG_WARN,"'connected' unsupported while open. Closing circ.");
return -1;
}
log_fn(LOG_INFO,"'connected' received, no conn attached anymore. Ignoring.");
return 0;
case RELAY_COMMAND_SENDME:
if(!conn) {
if(layer_hint) {
layer_hint->package_window += CIRCWINDOW_INCREMENT;
log_fn(LOG_DEBUG,"circ-level sendme at origin, packagewindow %d.",
layer_hint->package_window);
circuit_resume_edge_reading(circ, layer_hint);
} else {
circ->package_window += CIRCWINDOW_INCREMENT;
log_fn(LOG_DEBUG,"circ-level sendme at non-origin, packagewindow %d.",
circ->package_window);
circuit_resume_edge_reading(circ, layer_hint);
}
return 0;
}
conn->package_window += STREAMWINDOW_INCREMENT;
log_fn(LOG_DEBUG,"stream-level sendme, packagewindow now %d.", conn->package_window);
connection_start_reading(conn);
connection_edge_package_raw_inbuf(conn); /* handle whatever might still be on the inbuf */
return 0;
case RELAY_COMMAND_ESTABLISH_INTRO:
case RELAY_COMMAND_ESTABLISH_RENDEZVOUS:
case RELAY_COMMAND_INTRODUCE1:
case RELAY_COMMAND_INTRODUCE2:
case RELAY_COMMAND_INTRODUCE_ACK:
case RELAY_COMMAND_RENDEZVOUS1:
case RELAY_COMMAND_RENDEZVOUS2:
case RELAY_COMMAND_INTRO_ESTABLISHED:
case RELAY_COMMAND_RENDEZVOUS_ESTABLISHED:
rend_process_relay_cell(circ, rh.command, rh.length,
cell->payload+RELAY_HEADER_SIZE);
return 0;
}
log_fn(LOG_WARN,"unknown relay command %d.",rh.command);
return -1;
}
/** Connection <b>conn</b> has finished writing and has no bytes left on
* its outbuf.
*
@ -609,84 +218,6 @@ int connection_edge_finished_connecting(connection_t *conn)
return connection_edge_process_inbuf(conn); /* in case the server has written anything */
}
uint64_t stats_n_data_cells_packaged = 0;
uint64_t stats_n_data_bytes_packaged = 0;
uint64_t stats_n_data_cells_received = 0;
uint64_t stats_n_data_bytes_received = 0;
/** While conn->inbuf has an entire relay payload of bytes on it,
* and the appropriate package windows aren't empty, grab a cell
* and send it down the circuit.
*
* Return -1 if conn should be marked for close, else return 0.
*/
int connection_edge_package_raw_inbuf(connection_t *conn) {
int amount_to_process, length;
char payload[CELL_PAYLOAD_SIZE];
circuit_t *circ;
tor_assert(conn);
tor_assert(!connection_speaks_cells(conn));
repeat_connection_edge_package_raw_inbuf:
circ = circuit_get_by_conn(conn);
if(!circ) {
log_fn(LOG_INFO,"conn has no circuits! Closing.");
return -1;
}
if(circuit_consider_stop_edge_reading(circ, conn->cpath_layer))
return 0;
if(conn->package_window <= 0) {
log_fn(LOG_WARN,"called with package_window %d. Tell Roger.", conn->package_window);
connection_stop_reading(conn);
return 0;
}
amount_to_process = buf_datalen(conn->inbuf);
if(!amount_to_process)
return 0;
if(amount_to_process > RELAY_PAYLOAD_SIZE) {
length = RELAY_PAYLOAD_SIZE;
} else {
length = amount_to_process;
}
stats_n_data_bytes_packaged += length;
stats_n_data_cells_packaged += 1;
connection_fetch_from_buf(payload, length, conn);
log_fn(LOG_DEBUG,"(%d) Packaging %d bytes (%d waiting).", conn->s, length,
(int)buf_datalen(conn->inbuf));
if(connection_edge_send_command(conn, circ, RELAY_COMMAND_DATA,
payload, length, conn->cpath_layer) < 0)
return 0; /* circuit is closed, don't continue */
if(!conn->cpath_layer) { /* non-rendezvous exit */
tor_assert(circ->package_window > 0);
circ->package_window--;
} else { /* we're an AP, or an exit on a rendezvous circ */
tor_assert(conn->cpath_layer->package_window > 0);
conn->cpath_layer->package_window--;
}
if(--conn->package_window <= 0) { /* is it 0 after decrement? */
connection_stop_reading(conn);
log_fn(LOG_DEBUG,"conn->package_window reached 0.");
circuit_consider_stop_edge_reading(circ, conn->cpath_layer);
return 0; /* don't process the inbuf any more */
}
log_fn(LOG_DEBUG,"conn->package_window is now %d",conn->package_window);
/* handle more if there's more, or return 0 if there isn't */
goto repeat_connection_edge_package_raw_inbuf;
}
/** How many times do we retry a general-purpose stream (detach it from
* one circuit and try another, after we wait a while with no 'connected'
* cell) before giving up?
@ -795,37 +326,6 @@ void connection_ap_attach_pending(void)
}
}
/** Called when we've just received a relay data cell, or when
* we've just finished flushing all bytes to stream <b>conn</b>.
*
* If conn->outbuf is not too full, and our deliver window is
* low, send back a suitable number of stream-level sendme cells.
*/
static void connection_edge_consider_sending_sendme(connection_t *conn) {
circuit_t *circ;
if(connection_outbuf_too_full(conn))
return;
circ = circuit_get_by_conn(conn);
if(!circ) {
/* this can legitimately happen if the destroy has already
* arrived and torn down the circuit */
log_fn(LOG_INFO,"No circuit associated with conn. Skipping.");
return;
}
while(conn->deliver_window < STREAMWINDOW_START - STREAMWINDOW_INCREMENT) {
log_fn(LOG_DEBUG,"Outbuf %d, Queueing stream sendme.", conn->outbuf_flushlen);
conn->deliver_window += STREAMWINDOW_INCREMENT;
if(connection_edge_send_command(conn, circ, RELAY_COMMAND_SENDME,
NULL, 0, conn->cpath_layer) < 0) {
log_fn(LOG_WARN,"connection_edge_send_command failed. Returning.");
return; /* the circuit's closed, don't continue */
}
}
}
/** connection_edge_process_inbuf() found a conn in state
* socks_wait. See if conn->inbuf has the right bytes to proceed with
* the socks handshake.
@ -908,212 +408,6 @@ static int connection_ap_handshake_process_socks(connection_t *conn) {
return 0;
}
/** Find an open circ that we're happy with: return 1. If there isn't
* one, and there isn't one on the way, launch one and return 0. If it
* will never work, return -1.
*
* Write the found or in-progress or launched circ into *circp.
*/
static int
circuit_get_open_circ_or_launch(connection_t *conn,
uint8_t desired_circuit_purpose,
circuit_t **circp) {
circuit_t *circ;
uint32_t addr;
tor_assert(conn);
tor_assert(circp);
tor_assert(conn->state == AP_CONN_STATE_CIRCUIT_WAIT);
circ = circuit_get_best(conn, 1, desired_circuit_purpose);
if(circ) {
*circp = circ;
return 1; /* we're happy */
}
if(!connection_edge_is_rendezvous_stream(conn)) { /* general purpose circ */
addr = client_dns_lookup_entry(conn->socks_request->address);
if(router_exit_policy_all_routers_reject(addr, conn->socks_request->port)) {
log_fn(LOG_WARN,"No Tor server exists that allows exit to %s:%d. Rejecting.",
conn->socks_request->address, conn->socks_request->port);
return -1;
}
}
/* is one already on the way? */
circ = circuit_get_best(conn, 0, desired_circuit_purpose);
if(!circ) {
char *exitname=NULL;
uint8_t new_circ_purpose;
if(desired_circuit_purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT) {
/* need to pick an intro point */
exitname = rend_client_get_random_intro(conn->rend_query);
if(!exitname) {
log_fn(LOG_WARN,"Couldn't get an intro point for '%s'. Closing conn.",
conn->rend_query);
return -1;
}
if(!router_get_by_nickname(exitname)) {
log_fn(LOG_WARN,"Advertised intro point '%s' is not known. Closing.", exitname);
return -1;
}
/* XXX if we failed, then refetch the descriptor */
log_fn(LOG_INFO,"Chose %s as intro point for %s.", exitname, conn->rend_query);
}
if(desired_circuit_purpose == CIRCUIT_PURPOSE_C_REND_JOINED)
new_circ_purpose = CIRCUIT_PURPOSE_C_ESTABLISH_REND;
else if(desired_circuit_purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT)
new_circ_purpose = CIRCUIT_PURPOSE_C_INTRODUCING;
else
new_circ_purpose = desired_circuit_purpose;
circ = circuit_launch_new(new_circ_purpose, exitname);
tor_free(exitname);
if(circ &&
(desired_circuit_purpose != CIRCUIT_PURPOSE_C_GENERAL)) {
/* then write the service_id into circ */
strcpy(circ->rend_query, conn->rend_query);
}
}
if(!circ)
log_fn(LOG_INFO,"No safe circuit (purpose %d) ready for edge connection; delaying.",
desired_circuit_purpose);
*circp = circ;
return 0;
}
/** Attach the AP stream <b>apconn</b> to circ's linked list of
* p_streams. Also set apconn's cpath_layer to the last hop in
* circ's cpath.
*/
void link_apconn_to_circ(connection_t *apconn, circuit_t *circ) {
/* add it into the linked list of streams on this circuit */
log_fn(LOG_DEBUG,"attaching new conn to circ. n_circ_id %d.", circ->n_circ_id);
apconn->next_stream = circ->p_streams;
/* assert_connection_ok(conn, time(NULL)); */
circ->p_streams = apconn;
tor_assert(CIRCUIT_IS_ORIGIN(circ) && circ->cpath && circ->cpath->prev);
tor_assert(circ->cpath->prev->state == CPATH_STATE_OPEN);
apconn->cpath_layer = circ->cpath->prev;
}
/** Try to find a safe live circuit for CONN_TYPE_AP connection conn. If
* we don't find one: if conn cannot be handled by any known nodes,
* warn and return -1 (conn needs to die);
* else launch new circuit (if necessary) and return 0.
* Otherwise, associate conn with a safe live circuit, do the
* right next step, and return 1.
*/
int connection_ap_handshake_attach_circuit(connection_t *conn) {
int retval;
int conn_age;
tor_assert(conn);
tor_assert(conn->type == CONN_TYPE_AP);
tor_assert(conn->state == AP_CONN_STATE_CIRCUIT_WAIT);
tor_assert(conn->socks_request);
conn_age = time(NULL) - conn->timestamp_created;
if(conn_age > 60) {
/* XXX make this cleaner than '60' */
log_fn(LOG_WARN,"Giving up on unattached conn (%d sec old).", conn_age);
return -1;
}
if(!connection_edge_is_rendezvous_stream(conn)) { /* we're a general conn */
circuit_t *circ=NULL;
/* find the circuit that we should use, if there is one. */
retval = circuit_get_open_circ_or_launch(conn, CIRCUIT_PURPOSE_C_GENERAL, &circ);
if(retval < 1)
return retval;
/* We have found a suitable circuit for our conn. Hurray. */
log_fn(LOG_DEBUG,"Attaching apconn to general circ %d (stream %d sec old).",
circ->n_circ_id, conn_age);
/* here, print the circ's path. so people can figure out which circs are sucking. */
circuit_log_path(LOG_INFO,circ);
if(!circ->timestamp_dirty)
circ->timestamp_dirty = time(NULL);
link_apconn_to_circ(conn, circ);
connection_ap_handshake_send_begin(conn, circ);
return 1;
} else { /* we're a rendezvous conn */
circuit_t *rendcirc=NULL, *introcirc=NULL;
tor_assert(!conn->cpath_layer);
/* start by finding a rendezvous circuit for us */
retval = circuit_get_open_circ_or_launch(conn, CIRCUIT_PURPOSE_C_REND_JOINED, &rendcirc);
if(retval < 0) return -1; /* failed */
tor_assert(rendcirc);
if(retval > 0) {
/* one is already established, attach */
log_fn(LOG_INFO,"rend joined circ %d already here. attaching. (stream %d sec old)",
rendcirc->n_circ_id, conn_age);
link_apconn_to_circ(conn, rendcirc);
if(connection_ap_handshake_send_begin(conn, rendcirc) < 0)
return 0; /* already marked, let them fade away */
return 1;
}
if(rendcirc->purpose == CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED) {
log_fn(LOG_INFO,"pending-join circ %d already here, with intro ack. Stalling. (stream %d sec old)", rendcirc->n_circ_id, conn_age);
return 0;
}
/* it's on its way. find an intro circ. */
retval = circuit_get_open_circ_or_launch(conn, CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT, &introcirc);
if(retval < 0) return -1; /* failed */
tor_assert(introcirc);
if(retval > 0) {
/* one has already sent the intro. keep waiting. */
log_fn(LOG_INFO,"Intro circ %d present and awaiting ack (rend %d). Stalling. (stream %d sec old)",
introcirc->n_circ_id, rendcirc->n_circ_id, conn_age);
return 0;
}
/* now both rendcirc and introcirc are defined, and neither is finished */
if(rendcirc->purpose == CIRCUIT_PURPOSE_C_REND_READY) {
log_fn(LOG_INFO,"ready rend circ %d already here (no intro-ack yet on intro %d). (stream %d sec old)",
rendcirc->n_circ_id, introcirc->n_circ_id, conn_age);
/* look around for any new intro circs that should introduce */
tor_assert(introcirc->purpose == CIRCUIT_PURPOSE_C_INTRODUCING);
if(introcirc->state == CIRCUIT_STATE_OPEN) {
log_fn(LOG_INFO,"found open intro circ %d (rend %d); sending introduction. (stream %d sec old)",
introcirc->n_circ_id, rendcirc->n_circ_id, conn_age);
/* XXX here we should cannibalize the rend circ if it's a zero service id */
if(rend_client_send_introduction(introcirc, rendcirc) < 0) {
return -1;
}
rendcirc->timestamp_dirty = time(NULL);
introcirc->timestamp_dirty = time(NULL);
assert_circuit_ok(rendcirc);
assert_circuit_ok(introcirc);
return 0;
}
}
log_fn(LOG_INFO,"Intro (%d) and rend (%d) circs are not both ready. Stalling conn. (%d sec old)", introcirc->n_circ_id, rendcirc->n_circ_id, conn_age);
return 0;
}
}
/** Iterate over the two bytes of stream_id until we get one that is not
* already in use; return it. Return 0 if can't get a unique stream_id.
*/
@ -1303,7 +597,7 @@ void connection_ap_handshake_socks_reply(connection_t *conn, char *reply,
*
* Return -1 if we want to tear down <b>circ</b>. Else return 0.
*/
static int connection_exit_begin_conn(cell_t *cell, circuit_t *circ) {
int connection_exit_begin_conn(cell_t *cell, circuit_t *circ) {
connection_t *n_stream;
relay_header_t rh;
char *colon;
@ -1537,7 +831,7 @@ _get_or_create_ent(const char *address)
/** Return the IP associated with <b>address</b>, if we know it
* and it's still fresh enough. Otherwise return 0.
*/
static uint32_t client_dns_lookup_entry(const char *address)
uint32_t client_dns_lookup_entry(const char *address)
{
struct client_dns_entry *ent;
struct in_addr in;
@ -1574,7 +868,7 @@ static uint32_t client_dns_lookup_entry(const char *address)
* Increment the number of resolve failures we have on record
* for it, and then return that number.
*/
static int client_dns_incr_failures(const char *address)
int client_dns_incr_failures(const char *address)
{
struct client_dns_entry *ent;
ent = _get_or_create_ent(address);
@ -1589,7 +883,7 @@ static int client_dns_incr_failures(const char *address)
* so we can more correctly choose a router that will allow <b>address</b>
* to exit from him.
*/
static void client_dns_set_entry(const char *address, uint32_t val)
void client_dns_set_entry(const char *address, uint32_t val)
{
struct client_dns_entry *ent;
struct in_addr in;

524
src/or/onion.c
View File

@ -4,42 +4,14 @@
/**
* \file onion.c
* \brief Functions to handle onion parsing/creation and handle cpaths.
* \brief Functions to queue create cells, and handle onionskin
* parsing and creation.
**/
#include "or.h"
/* prototypes for smartlist operations from routerlist.h
* They're here to prevent precedence issues with the .h files
*/
void router_add_running_routers_to_smartlist(smartlist_t *sl);
void add_nickname_list_to_smartlist(smartlist_t *sl, char *list);
extern or_options_t options; /**< command-line and config-file options */
static int count_acceptable_routers(smartlist_t *routers);
/** Decide whether the first bit of the circuit ID will be
* 0 or 1, to avoid conflicts where each side randomly chooses
* the same circuit ID.
*
* Return CIRC_ID_TYPE_LOWER if local_nick is NULL, or if
* local_nick is lexographically smaller than remote_nick.
* Else return CIRC_ID_TYPE_HIGHER.
*/
int decide_circ_id_type(char *local_nick, char *remote_nick) {
int result;
tor_assert(remote_nick);
if(!local_nick)
return CIRC_ID_TYPE_LOWER;
result = strcasecmp(local_nick, remote_nick);
tor_assert(result);
if(result < 0)
return CIRC_ID_TYPE_LOWER;
return CIRC_ID_TYPE_HIGHER;
}
struct onion_queue_t {
circuit_t *circ;
struct onion_queue_t *next;
@ -140,498 +112,6 @@ void onion_pending_remove(circuit_t *circ) {
free(victim);
}
/** Given a response payload and keys, initialize, then send a created
* cell back.
*/
int onionskin_answer(circuit_t *circ, unsigned char *payload, unsigned char *keys) {
cell_t cell;
crypt_path_t *tmp_cpath;
tmp_cpath = tor_malloc_zero(sizeof(crypt_path_t));
memset(&cell, 0, sizeof(cell_t));
cell.command = CELL_CREATED;
cell.circ_id = circ->p_circ_id;
circ->state = CIRCUIT_STATE_OPEN;
log_fn(LOG_DEBUG,"Entering.");
memcpy(cell.payload, payload, ONIONSKIN_REPLY_LEN);
log_fn(LOG_INFO,"init digest forward 0x%.8x, backward 0x%.8x.",
(unsigned int)*(uint32_t*)(keys), (unsigned int)*(uint32_t*)(keys+20));
if (circuit_init_cpath_crypto(tmp_cpath, keys, 0)<0) {
log_fn(LOG_WARN,"Circuit initialization failed");
tor_free(tmp_cpath);
return -1;
}
circ->n_digest = tmp_cpath->f_digest;
circ->n_crypto = tmp_cpath->f_crypto;
circ->p_digest = tmp_cpath->b_digest;
circ->p_crypto = tmp_cpath->b_crypto;
tor_free(tmp_cpath);
memcpy(circ->handshake_digest, cell.payload+DH_KEY_LEN, DIGEST_LEN);
connection_or_write_cell_to_buf(&cell, circ->p_conn);
log_fn(LOG_DEBUG,"Finished sending 'created' cell.");
return 0;
}
extern int has_fetched_directory; /**< from main.c */
/** Choose a length for a circuit of purpose <b>purpose</b>.
* Default length is 3 + the number of endpoints that would give something
* away. If the routerlist <b>routers</b> doesn't have enough routers
* to handle the desired path length, return as large a path length as
* is feasible, except if it's less than 2, in which case return -1.
*/
static int new_route_len(double cw, uint8_t purpose, smartlist_t *routers) {
int num_acceptable_routers;
int routelen;
tor_assert((cw >= 0) && (cw < 1) && routers); /* valid parameters */
#ifdef TOR_PERF
routelen = 2;
#else
if(purpose == CIRCUIT_PURPOSE_C_GENERAL)
routelen = 3;
else if(purpose == CIRCUIT_PURPOSE_C_INTRODUCING)
routelen = 4;
else if(purpose == CIRCUIT_PURPOSE_C_ESTABLISH_REND)
routelen = 3;
else if(purpose == CIRCUIT_PURPOSE_S_ESTABLISH_INTRO)
routelen = 3;
else if(purpose == CIRCUIT_PURPOSE_S_CONNECT_REND)
routelen = 4;
else {
log_fn(LOG_WARN,"Unhandled purpose %d", purpose);
return -1;
}
#endif
#if 0
for(routelen = 3; ; routelen++) { /* 3, increment until coinflip says we're done */
if (crypto_pseudo_rand_int(255) >= cw*255) /* don't extend */
break;
}
#endif
log_fn(LOG_DEBUG,"Chosen route length %d (%d routers available).",routelen,
smartlist_len(routers));
num_acceptable_routers = count_acceptable_routers(routers);
if(num_acceptable_routers < 2) {
log_fn(LOG_INFO,"Not enough acceptable routers (%d). Discarding this circuit.",
num_acceptable_routers);
return -1;
}
if(num_acceptable_routers < routelen) {
log_fn(LOG_INFO,"Not enough routers: cutting routelen from %d to %d.",
routelen, num_acceptable_routers);
routelen = num_acceptable_routers;
}
return routelen;
}
/** Return a pointer to a suitable router to be the exit node for the
* general-purpose circuit we're about to build.
*
* Look through the connection array, and choose a router that maximizes
* the number of pending streams that can exit from this router.
*
* Return NULL if we can't find any suitable routers.
*/
static routerinfo_t *choose_good_exit_server_general(routerlist_t *dir)
{
int *n_supported;
int i, j;
int n_pending_connections = 0;
connection_t **carray;
int n_connections;
int best_support = -1;
int n_best_support=0;
smartlist_t *sl, *preferredexits, *excludedexits;
routerinfo_t *router;
get_connection_array(&carray, &n_connections);
/* Count how many connections are waiting for a circuit to be built.
* We use this for log messages now, but in the future we may depend on it.
*/
for (i = 0; i < n_connections; ++i) {
if (carray[i]->type == CONN_TYPE_AP &&
carray[i]->state == AP_CONN_STATE_CIRCUIT_WAIT &&
!carray[i]->marked_for_close &&
!circuit_stream_is_being_handled(carray[i]))
++n_pending_connections;
}
log_fn(LOG_DEBUG, "Choosing exit node; %d connections are pending",
n_pending_connections);
/* Now we count, for each of the routers in the directory, how many
* of the pending connections could possibly exit from that
* router (n_supported[i]). (We can't be sure about cases where we
* don't know the IP address of the pending connection.)
*/
n_supported = tor_malloc(sizeof(int)*smartlist_len(dir->routers));
for (i = 0; i < smartlist_len(dir->routers); ++i) { /* iterate over routers */
router = smartlist_get(dir->routers, i);
if(router_is_me(router)) {
n_supported[i] = -1;
log_fn(LOG_DEBUG,"Skipping node %s -- it's me.", router->nickname);
/* XXX there's probably a reverse predecessor attack here, but
* it's slow. should we take this out? -RD
*/
continue;
}
if(!router->is_running) {
n_supported[i] = -1;
log_fn(LOG_DEBUG,"Skipping node %s (index %d) -- directory says it's not running.",
router->nickname, i);
continue; /* skip routers that are known to be down */
}
if(router_exit_policy_rejects_all(router)) {
n_supported[i] = -1;
log_fn(LOG_DEBUG,"Skipping node %s (index %d) -- it rejects all.",
router->nickname, i);
continue; /* skip routers that reject all */
}
n_supported[i] = 0;
for (j = 0; j < n_connections; ++j) { /* iterate over connections */
if (carray[j]->type != CONN_TYPE_AP ||
carray[j]->state != AP_CONN_STATE_CIRCUIT_WAIT ||
carray[j]->marked_for_close ||
circuit_stream_is_being_handled(carray[j]))
continue; /* Skip everything but APs in CIRCUIT_WAIT */
switch (connection_ap_can_use_exit(carray[j], router))
{
case ADDR_POLICY_REJECTED:
log_fn(LOG_DEBUG,"%s (index %d) would reject this stream.",
router->nickname, i);
break; /* would be rejected; try next connection */
case ADDR_POLICY_ACCEPTED:
case ADDR_POLICY_UNKNOWN:
++n_supported[i];
log_fn(LOG_DEBUG,"%s is supported. n_supported[%d] now %d.",
router->nickname, i, n_supported[i]);
}
} /* End looping over connections. */
if (n_supported[i] > best_support) {
/* If this router is better than previous ones, remember its index
* and goodness, and start counting how many routers are this good. */
best_support = n_supported[i]; n_best_support=1;
log_fn(LOG_DEBUG,"%s is new best supported option so far.",
router->nickname);
} else if (n_supported[i] == best_support) {
/* If this router is _as good_ as the best one, just increment the
* count of equally good routers.*/
++n_best_support;
}
}
log_fn(LOG_INFO, "Found %d servers that might support %d/%d pending connections.",
n_best_support, best_support, n_pending_connections);
preferredexits = smartlist_create();
add_nickname_list_to_smartlist(preferredexits,options.ExitNodes);
excludedexits = smartlist_create();
add_nickname_list_to_smartlist(excludedexits,options.ExcludeNodes);
sl = smartlist_create();
/* If any routers definitely support any pending connections, choose one
* at random. */
if (best_support > 0) {
for (i = 0; i < smartlist_len(dir->routers); i++)
if (n_supported[i] == best_support)
smartlist_add(sl, smartlist_get(dir->routers, i));
smartlist_subtract(sl,excludedexits);
if (smartlist_overlap(sl,preferredexits))
smartlist_intersect(sl,preferredexits);
router = smartlist_choose(sl);
} else {
/* Either there are no pending connections, or no routers even seem to
* possibly support any of them. Choose a router at random. */
if (best_support == -1) {
log(LOG_WARN, "All routers are down or middleman -- choosing a doomed exit at random.");
}
for(i = 0; i < smartlist_len(dir->routers); i++)
if(n_supported[i] != -1)
smartlist_add(sl, smartlist_get(dir->routers, i));
smartlist_subtract(sl,excludedexits);
if (smartlist_overlap(sl,preferredexits))
smartlist_intersect(sl,preferredexits);
router = smartlist_choose(sl);
}
smartlist_free(preferredexits);
smartlist_free(excludedexits);
smartlist_free(sl);
tor_free(n_supported);
if(router) {
log_fn(LOG_INFO, "Chose exit server '%s'", router->nickname);
return router;
}
log_fn(LOG_WARN, "No exit routers seem to be running; can't choose an exit.");
return NULL;
}
/** Return a pointer to a suitable router to be the exit node for the
* circuit of purpose <b>purpose</b> that we're about to build (or NULL
* if no router is suitable).
*
* For general-purpose circuits, pass it off to
* choose_good_exit_server_general()
*
* For client-side rendezvous circuits, choose a random node, weighted
* toward the preferences in 'options'.
*/
static routerinfo_t *choose_good_exit_server(uint8_t purpose, routerlist_t *dir)
{
routerinfo_t *r;
switch(purpose) {
case CIRCUIT_PURPOSE_C_GENERAL:
return choose_good_exit_server_general(dir);
case CIRCUIT_PURPOSE_C_ESTABLISH_REND:
r = router_choose_random_node(dir, options.RendNodes, options.RendExcludeNodes, NULL);
return r;
default:
log_fn(LOG_WARN,"unhandled purpose %d", purpose);
tor_assert(0);
}
return NULL; /* never reached */
}
/** Allocate a cpath_build_state_t, populate it based on
* <b>purpose</b> and <b>exit_nickname</b> (if specified), and
* return it.
*/
cpath_build_state_t *onion_new_cpath_build_state(uint8_t purpose,
const char *exit_nickname) {
routerlist_t *rl;
int r;
cpath_build_state_t *info;
routerinfo_t *exit;
router_get_routerlist(&rl);
r = new_route_len(options.PathlenCoinWeight, purpose, rl->routers);
if (r < 0)
return NULL;
info = tor_malloc_zero(sizeof(cpath_build_state_t));
info->desired_path_len = r;
if(exit_nickname) { /* the circuit-builder pre-requested one */
log_fn(LOG_INFO,"Using requested exit node '%s'", exit_nickname);
info->chosen_exit = tor_strdup(exit_nickname);
} else { /* we have to decide one */
exit = choose_good_exit_server(purpose, rl);
if(!exit) {
log_fn(LOG_WARN,"failed to choose an exit server");
tor_free(info);
return NULL;
}
info->chosen_exit = tor_strdup(exit->nickname);
}
return info;
}
/** Return the number of routers in <b>routers</b> that are currently up
* and available for building circuits through. Count sets of twins only
* once.
*/
static int count_acceptable_routers(smartlist_t *routers) {
int i, j, n;
int num=0;
connection_t *conn;
routerinfo_t *r, *r2;
n = smartlist_len(routers);
for(i=0;i<n;i++) {
r = smartlist_get(routers, i);
log_fn(LOG_DEBUG,"Contemplating whether router %d (%s) is a new option...",
i, r->nickname);
if(r->is_running == 0) {
log_fn(LOG_DEBUG,"Nope, the directory says %d is not running.",i);
goto next_i_loop;
}
if(options.ORPort) {
conn = connection_exact_get_by_addr_port(r->addr, r->or_port);
if(!conn || conn->type != CONN_TYPE_OR || conn->state != OR_CONN_STATE_OPEN) {
log_fn(LOG_DEBUG,"Nope, %d is not connected.",i);
goto next_i_loop;
}
}
for(j=0;j<i;j++) {
r2 = smartlist_get(routers, j);
if(!crypto_pk_cmp_keys(r->onion_pkey, r2->onion_pkey)) {
/* these guys are twins. so we've already counted him. */
log_fn(LOG_DEBUG,"Nope, %d is a twin of %d.",i,j);
goto next_i_loop;
}
}
num++;
log_fn(LOG_DEBUG,"I like %d. num_acceptable_routers now %d.",i, num);
next_i_loop:
; /* C requires an explicit statement after the label */
}
return num;
}
/** Go through smartlist <b>sl</b> of routers, and remove all elements that
* have the same onion key as twin.
*/
static void remove_twins_from_smartlist(smartlist_t *sl, routerinfo_t *twin) {
int i;
routerinfo_t *r;
if(twin == NULL)
return;
for(i=0; i < smartlist_len(sl); i++) {
r = smartlist_get(sl,i);
if (!crypto_pk_cmp_keys(r->onion_pkey, twin->onion_pkey)) {
smartlist_del(sl,i--);
}
}
}
/** Add <b>new_hop</b> to the end of the doubly-linked-list <b>head_ptr</b>.
*
* This function is used to extend cpath by another hop.
*/
void onion_append_to_cpath(crypt_path_t **head_ptr, crypt_path_t *new_hop)
{
if (*head_ptr) {
new_hop->next = (*head_ptr);
new_hop->prev = (*head_ptr)->prev;
(*head_ptr)->prev->next = new_hop;
(*head_ptr)->prev = new_hop;
} else {
*head_ptr = new_hop;
new_hop->prev = new_hop->next = new_hop;
}
}
/** Choose a suitable next hop in the cpath <b>head_ptr</b>,
* based on <b>state</b>. Add the hop info to head_ptr, and return a
* pointer to the chosen router in <b>router_out</b>.
*/
int onion_extend_cpath(crypt_path_t **head_ptr, cpath_build_state_t
*state, routerinfo_t **router_out)
{
int cur_len;
crypt_path_t *cpath, *hop;
routerinfo_t *r;
routerinfo_t *choice;
int i;
smartlist_t *sl, *excludednodes;
tor_assert(head_ptr);
tor_assert(router_out);
if (!*head_ptr) {
cur_len = 0;
} else {
cur_len = 1;
for (cpath = *head_ptr; cpath->next != *head_ptr; cpath = cpath->next) {
++cur_len;
}
}
if (cur_len >= state->desired_path_len) {
log_fn(LOG_DEBUG, "Path is complete: %d steps long",
state->desired_path_len);
return 1;
}
log_fn(LOG_DEBUG, "Path is %d long; we want %d", cur_len,
state->desired_path_len);
excludednodes = smartlist_create();
add_nickname_list_to_smartlist(excludednodes,options.ExcludeNodes);
if(cur_len == state->desired_path_len - 1) { /* Picking last node */
log_fn(LOG_DEBUG, "Contemplating last hop: choice already made: %s",
state->chosen_exit);
choice = router_get_by_nickname(state->chosen_exit);
smartlist_free(excludednodes);
if(!choice) {
log_fn(LOG_WARN,"Our chosen exit %s is no longer in the directory? Discarding this circuit.",
state->chosen_exit);
return -1;
}
} else if(cur_len == 0) { /* picking first node */
/* try the nodes in EntryNodes first */
sl = smartlist_create();
add_nickname_list_to_smartlist(sl,options.EntryNodes);
/* XXX one day, consider picking chosen_exit knowing what's in EntryNodes */
remove_twins_from_smartlist(sl,router_get_by_nickname(state->chosen_exit));
remove_twins_from_smartlist(sl,router_get_my_routerinfo());
smartlist_subtract(sl,excludednodes);
choice = smartlist_choose(sl);
smartlist_free(sl);
if(!choice) {
sl = smartlist_create();
router_add_running_routers_to_smartlist(sl);
remove_twins_from_smartlist(sl,router_get_by_nickname(state->chosen_exit));
remove_twins_from_smartlist(sl,router_get_my_routerinfo());
smartlist_subtract(sl,excludednodes);
choice = smartlist_choose(sl);
smartlist_free(sl);
}
smartlist_free(excludednodes);
if(!choice) {
log_fn(LOG_WARN,"No acceptable routers while picking entry node. Discarding this circuit.");
return -1;
}
} else {
log_fn(LOG_DEBUG, "Contemplating intermediate hop: random choice.");
sl = smartlist_create();
router_add_running_routers_to_smartlist(sl);
remove_twins_from_smartlist(sl,router_get_by_nickname(state->chosen_exit));
remove_twins_from_smartlist(sl,router_get_my_routerinfo());
for (i = 0, cpath = *head_ptr; i < cur_len; ++i, cpath=cpath->next) {
r = router_get_by_addr_port(cpath->addr, cpath->port);
tor_assert(r);
remove_twins_from_smartlist(sl,r);
}
smartlist_subtract(sl,excludednodes);
choice = smartlist_choose(sl);
smartlist_free(sl);
smartlist_free(excludednodes);
if(!choice) {
log_fn(LOG_WARN,"No acceptable routers while picking intermediate node. Discarding this circuit.");
return -1;
}
}
log_fn(LOG_DEBUG,"Chose router %s for hop %d (exit is %s)",
choice->nickname, cur_len, state->chosen_exit);
hop = tor_malloc_zero(sizeof(crypt_path_t));
/* link hop into the cpath, at the end. */
onion_append_to_cpath(head_ptr, hop);
hop->state = CPATH_STATE_CLOSED;
hop->port = choice->or_port;
hop->addr = choice->addr;
hop->package_window = CIRCWINDOW_START;
hop->deliver_window = CIRCWINDOW_START;
log_fn(LOG_DEBUG, "Extended circuit path with %s for hop %d",
choice->nickname, cur_len);
*router_out = choice;
return 0;
}
/*----------------------------------------------------------------------*/
/** Given a router's 128 byte public key,

120
src/or/or.h
View File

@ -614,6 +614,8 @@ struct crypt_path_t {
* at this step? */
};
#define CPATH_KEY_MATERIAL_LEN (20*2+16*2)
#define DH_KEY_LEN DH_BYTES
#define ONIONSKIN_CHALLENGE_LEN (PKCS1_OAEP_PADDING_OVERHEAD+\
CIPHER_KEY_LEN+\
@ -859,11 +861,36 @@ int fetch_from_buf_socks(buf_t *buf, socks_request_t *req);
void assert_buf_ok(buf_t *buf);
/********************************* circuit.c ***************************/
/********************************* circuitbuild.c **********************/
void circuit_log_path(int severity, circuit_t *circ);
void circuit_rep_hist_note_result(circuit_t *circ);
void circuit_dump_by_conn(connection_t *conn, int severity);
circuit_t *circuit_establish_circuit(uint8_t purpose,
const char *exit_nickname);
void circuit_n_conn_open(connection_t *or_conn);
int circuit_send_next_onion_skin(circuit_t *circ);
int circuit_extend(cell_t *cell, circuit_t *circ);
int circuit_init_cpath_crypto(crypt_path_t *cpath, char *key_data, int reverse);
int circuit_finish_handshake(circuit_t *circ, char *reply);
int circuit_truncated(circuit_t *circ, crypt_path_t *layer);
int onionskin_answer(circuit_t *circ, unsigned char *payload, unsigned char *keys);
void onion_append_to_cpath(crypt_path_t **head_ptr, crypt_path_t *new_hop);
/********************************* circuitlist.c ***********************/
extern char *circuit_state_to_string[];
circuit_t *circuit_new(uint16_t p_circ_id, connection_t *p_conn);
void circuit_close_all_marked(void);
circuit_t *circuit_new(uint16_t p_circ_id, connection_t *p_conn);
void circuit_free_cpath_node(crypt_path_t *victim);
circuit_t *circuit_get_by_circ_id_conn(uint16_t circ_id, connection_t *conn);
circuit_t *circuit_get_by_conn(connection_t *conn);
circuit_t *circuit_get_by_rend_query_and_purpose(const char *rend_query, uint8_t purpose);
circuit_t *circuit_get_next_by_pk_and_purpose(circuit_t *start,
const char *digest, uint8_t purpose);
circuit_t *circuit_get_rendezvous(const char *cookie);
int circuit_count_building(uint8_t purpose);
circuit_t *circuit_get_youngest_clean_open(uint8_t purpose);
int _circuit_mark_for_close(circuit_t *circ);
#define circuit_mark_for_close(c) \
@ -877,44 +904,26 @@ int _circuit_mark_for_close(circuit_t *circ);
} \
} while (0)
void assert_cpath_layer_ok(const crypt_path_t *cp);
void assert_circuit_ok(const circuit_t *c);
circuit_t *circuit_get_by_circ_id_conn(uint16_t circ_id, connection_t *conn);
circuit_t *circuit_get_by_conn(connection_t *conn);
circuit_t *circuit_get_best(connection_t *conn,
int must_be_open, uint8_t purpose);
circuit_t *circuit_get_by_rend_query_and_purpose(const char *rend_query, uint8_t purpose);
circuit_t *circuit_get_next_by_pk_and_purpose(circuit_t *circuit,
const char *servid, uint8_t purpose);
circuit_t *circuit_get_rendezvous(const char *cookie);
/********************************* circuituse.c ************************/
void circuit_expire_building(time_t now);
int circuit_count_building(uint8_t purpose);
int circuit_stream_is_being_handled(connection_t *conn);
void circuit_build_needed_circs(time_t now);
void circuit_resume_edge_reading(circuit_t *circ, crypt_path_t *layer_hint);
int circuit_consider_stop_edge_reading(circuit_t *circ, crypt_path_t *layer_hint);
void circuit_consider_sending_sendme(circuit_t *circ, crypt_path_t *layer_hint);
void circuit_detach_stream(circuit_t *circ, connection_t *conn);
void circuit_about_to_close_connection(connection_t *conn);
void circuit_log_path(int severity, circuit_t *circ);
void circuit_dump_by_conn(connection_t *conn, int severity);
void circuit_expire_unused_circuits(void);
void circuit_has_opened(circuit_t *circ);
void circuit_build_failed(circuit_t *circ);
circuit_t *circuit_launch_new(uint8_t purpose, const char *exit_nickname);
void circuit_increment_failure_count(void);
void circuit_reset_failure_count(void);
void circuit_n_conn_open(connection_t *or_conn);
int circuit_send_next_onion_skin(circuit_t *circ);
int circuit_extend(cell_t *cell, circuit_t *circ);
#define CPATH_KEY_MATERIAL_LEN (20*2+16*2)
int connection_ap_handshake_attach_circuit(connection_t *conn);
int circuit_init_cpath_crypto(crypt_path_t *cpath, char *key_data,int reverse);
int circuit_finish_handshake(circuit_t *circ, char *reply);
int circuit_truncated(circuit_t *circ, crypt_path_t *layer);
void assert_cpath_ok(const crypt_path_t *c);
void assert_cpath_layer_ok(const crypt_path_t *c);
void assert_circuit_ok(const circuit_t *c);
@ -945,6 +954,7 @@ int getconfig(int argc, char **argv, or_options_t *options);
"Unknown" : conn_type_to_string[(t)])
extern char *conn_type_to_string[];
extern char *conn_state_to_string[][_CONN_TYPE_MAX+1];
connection_t *connection_new(int type);
void connection_free(connection_t *conn);
@ -1006,23 +1016,12 @@ void assert_connection_ok(connection_t *conn, time_t now);
/********************************* connection_edge.c ***************************/
void relay_header_pack(char *dest, const relay_header_t *src);
void relay_header_unpack(relay_header_t *dest, const char *src);
int connection_edge_process_inbuf(connection_t *conn);
int connection_edge_destroy(uint16_t circ_id, connection_t *conn);
int connection_edge_end(connection_t *conn, char reason, crypt_path_t *cpath_layer);
int connection_edge_send_command(connection_t *fromconn, circuit_t *circ,
int relay_command, const char *payload,
int payload_len, crypt_path_t *cpath_layer);
int connection_edge_process_relay_cell(cell_t *cell, circuit_t *circ,
connection_t *conn,
crypt_path_t *layer_hint);
int connection_edge_finished_flushing(connection_t *conn);
int connection_edge_finished_connecting(connection_t *conn);
int connection_edge_package_raw_inbuf(connection_t *conn);
int connection_ap_handshake_attach_circuit(connection_t *conn);
int connection_ap_handshake_send_begin(connection_t *ap_conn, circuit_t *circ);
int connection_ap_make_bridge(char *address, uint16_t port);
@ -1030,18 +1029,17 @@ int connection_ap_make_bridge(char *address, uint16_t port);
void connection_ap_handshake_socks_reply(connection_t *conn, char *reply,
int replylen, char success);
int connection_exit_begin_conn(cell_t *cell, circuit_t *circ);
void connection_exit_connect(connection_t *conn);
int connection_edge_is_rendezvous_stream(connection_t *conn);
int connection_ap_can_use_exit(connection_t *conn, routerinfo_t *exit);
void connection_ap_expire_beginning(void);
void connection_ap_attach_pending(void);
extern uint64_t stats_n_data_cells_packaged;
extern uint64_t stats_n_data_bytes_packaged;
extern uint64_t stats_n_data_cells_received;
extern uint64_t stats_n_data_bytes_received;
void client_dns_init(void);
uint32_t client_dns_lookup_entry(const char *address);
int client_dns_incr_failures(const char *address);
void client_dns_set_entry(const char *address, uint32_t val);
void client_dns_clean(void);
/********************************* connection_or.c ***************************/
@ -1077,6 +1075,7 @@ int connection_dir_finished_flushing(connection_t *conn);
int connection_dir_finished_connecting(connection_t *conn);
/********************************* dirserv.c ***************************/
int dirserv_add_own_fingerprint(const char *nickname, crypto_pk_env_t *pk);
int dirserv_parse_fingerprint_file(const char *fname);
int dirserv_router_fingerprint_is_known(const routerinfo_t *router);
@ -1123,19 +1122,10 @@ int main(int argc, char *argv[]);
/********************************* onion.c ***************************/
int decide_circ_id_type(char *local_nick, char *remote_nick);
int onion_pending_add(circuit_t *circ);
circuit_t *onion_next_task(void);
void onion_pending_remove(circuit_t *circ);
int onionskin_answer(circuit_t *circ, unsigned char *payload, unsigned char *keys);
void onion_append_to_cpath(crypt_path_t **head_ptr, crypt_path_t *new_hop);
int onion_extend_cpath(crypt_path_t **head_ptr, cpath_build_state_t *state,
routerinfo_t **router_out);
int onion_skin_create(crypto_pk_env_t *router_key,
crypto_dh_env_t **handshake_state_out,
char *onion_skin_out);
@ -1152,9 +1142,6 @@ int onion_skin_client_handshake(crypto_dh_env_t *handshake_state,
char *key_out,
int key_out_len);
cpath_build_state_t *onion_new_cpath_build_state(uint8_t purpose,
const char *exit_nickname);
/********************************* relay.c ***************************/
extern unsigned long stats_n_relay_cells_relayed;
@ -1165,6 +1152,19 @@ int circuit_receive_relay_cell(cell_t *cell, circuit_t *circ,
int circuit_package_relay_cell(cell_t *cell, circuit_t *circ,
int cell_direction, crypt_path_t *layer_hint);
void relay_header_pack(char *dest, const relay_header_t *src);
void relay_header_unpack(relay_header_t *dest, const char *src);
int connection_edge_send_command(connection_t *fromconn, circuit_t *circ,
int relay_command, const char *payload,
int payload_len, crypt_path_t *cpath_layer);
int connection_edge_package_raw_inbuf(connection_t *conn);
void connection_edge_consider_sending_sendme(connection_t *conn);
extern uint64_t stats_n_data_cells_packaged;
extern uint64_t stats_n_data_bytes_packaged;
extern uint64_t stats_n_data_cells_received;
extern uint64_t stats_n_data_bytes_received;
/********************************* rephist.c ***************************/
void rep_hist_init(void);
@ -1179,8 +1179,8 @@ void rep_hist_dump_stats(time_t now, int severity);
/********************************* rendclient.c ***************************/
void rend_client_introcirc_is_open(circuit_t *circ);
void rend_client_rendcirc_is_open(circuit_t *circ);
void rend_client_introcirc_has_opened(circuit_t *circ);
void rend_client_rendcirc_has_opened(circuit_t *circ);
int rend_client_introduction_acked(circuit_t *circ, const char *request, int request_len);
void rend_client_refetch_renddesc(const char *query);
int rend_client_remove_intro_point(char *failed_intro, const char *query);
@ -1237,9 +1237,9 @@ void rend_services_init(void);
void rend_services_introduce(void);
void rend_services_upload(int force);
void rend_service_intro_is_ready(circuit_t *circuit);
void rend_service_intro_has_opened(circuit_t *circuit);
int rend_service_intro_established(circuit_t *circuit, const char *request, int request_len);
void rend_service_rendezvous_is_ready(circuit_t *circuit);
void rend_service_rendezvous_has_opened(circuit_t *circuit);
int rend_service_introduce(circuit_t *circuit, const char *request, int request_len);
void rend_service_relaunch_rendezvous(circuit_t *oldcirc);
int rend_service_set_connection_addr_port(connection_t *conn, circuit_t *circ);
@ -1277,6 +1277,8 @@ int router_dump_router_to_string(char *s, int maxlen, routerinfo_t *router,
routerinfo_t *router_pick_directory_server(void);
struct smartlist_t;
void add_nickname_list_to_smartlist(struct smartlist_t *sl, const char *list);
void router_add_running_routers_to_smartlist(struct smartlist_t *sl);
routerinfo_t *router_choose_random_node(routerlist_t *dir,
char *preferred, char *excluded,
struct smartlist_t *excludedsmartlist);

617
src/or/relay.c
View File

@ -4,15 +4,33 @@
/**
* \file relay.c
* \brief Handle relay cell encryption/decryption.
* \brief Handle relay cell encryption/decryption, plus packaging and
* receiving from circuits.
**/
#include "or.h"
static int relay_crypt(circuit_t *circ, cell_t *cell, int cell_direction,
crypt_path_t **layer_hint, char *recognized);
static connection_t *relay_lookup_conn(circuit_t *circ, cell_t *cell, int cell_direction)
;
static connection_t *relay_lookup_conn(circuit_t *circ, cell_t *cell, int cell_direction);
static int
connection_edge_process_relay_cell(cell_t *cell, circuit_t *circ,
connection_t *conn,
crypt_path_t *layer_hint);
static void
circuit_consider_sending_sendme(circuit_t *circ, crypt_path_t *layer_hint);
static void
circuit_resume_edge_reading(circuit_t *circ, crypt_path_t *layer_hint);
static int
circuit_resume_edge_reading_helper(connection_t *conn,
circuit_t *circ,
crypt_path_t *layer_hint);
static int
circuit_consider_stop_edge_reading(circuit_t *circ, crypt_path_t *layer_hint);
void connection_edge_consider_sending_sendme(connection_t *conn);
/** Stats: how many relay cells have originated at this hop, or have
* been relayed onward (not recognized at this hop)?
@ -348,3 +366,596 @@ relay_lookup_conn(circuit_t *circ, cell_t *cell, int cell_direction)
return NULL; /* probably a begin relay cell */
}
/** Pack the relay_header_t host-order structure <b>src</b> into
* network-order in the buffer <b>dest</b>. See tor-spec.txt for details
* about the wire format.
*/
void relay_header_pack(char *dest, const relay_header_t *src) {
*(uint8_t*)(dest) = src->command;
set_uint16(dest+1, htons(src->recognized));
set_uint16(dest+3, htons(src->stream_id));
memcpy(dest+5, src->integrity, 4);
set_uint16(dest+9, htons(src->length));
}
/** Unpack the network-order buffer <b>src</b> into a host-order
* relay_header_t structure <b>dest</b>.
*/
void relay_header_unpack(relay_header_t *dest, const char *src) {
dest->command = *(uint8_t*)(src);
dest->recognized = ntohs(get_uint16(src+1));
dest->stream_id = ntohs(get_uint16(src+3));
memcpy(dest->integrity, src+5, 4);
dest->length = ntohs(get_uint16(src+9));
}
/** Make a relay cell out of <b>relay_command</b> and <b>payload</b>, and
* send it onto the open circuit <b>circ</b>. <b>fromconn</b> is the stream
* that's sending the relay cell, or NULL if it's a control cell.
* <b>cpath_layer</b> is NULL for OR->OP cells, or the destination hop
* for OP->OR cells.
*
* If you can't send the cell, mark the circuit for close and
* return -1. Else return 0.
*/
int connection_edge_send_command(connection_t *fromconn, circuit_t *circ,
int relay_command, const char *payload,
int payload_len, crypt_path_t *cpath_layer) {
cell_t cell;
relay_header_t rh;
int cell_direction;
if(!circ) {
log_fn(LOG_WARN,"no circ. Closing conn.");
tor_assert(fromconn);
fromconn->has_sent_end = 1; /* no circ to send to */
connection_mark_for_close(fromconn);
return -1;
}
memset(&cell, 0, sizeof(cell_t));
cell.command = CELL_RELAY;
if(cpath_layer) {
cell.circ_id = circ->n_circ_id;
cell_direction = CELL_DIRECTION_OUT;
} else {
cell.circ_id = circ->p_circ_id;
cell_direction = CELL_DIRECTION_IN;
}
memset(&rh, 0, sizeof(rh));
rh.command = relay_command;
if(fromconn)
rh.stream_id = fromconn->stream_id; /* else it's 0 */
rh.length = payload_len;
relay_header_pack(cell.payload, &rh);
if(payload_len)
memcpy(cell.payload+RELAY_HEADER_SIZE, payload, payload_len);
log_fn(LOG_DEBUG,"delivering %d cell %s.", relay_command,
cell_direction == CELL_DIRECTION_OUT ? "forward" : "backward");
if(circuit_package_relay_cell(&cell, circ, cell_direction, cpath_layer) < 0) {
log_fn(LOG_WARN,"circuit_package_relay_cell failed. Closing.");
circuit_mark_for_close(circ);
return -1;
}
return 0;
}
/** Translate the <b>payload</b> of length <b>length</b>, which
* came from a relay 'end' cell, into a static const string describing
* why the stream is closing.
*/
static const char *
connection_edge_end_reason(char *payload, uint16_t length) {
if(length < 1) {
log_fn(LOG_WARN,"End cell arrived with length 0. Should be at least 1.");
return "MALFORMED";
}
if(*payload < _MIN_END_STREAM_REASON || *payload > _MAX_END_STREAM_REASON) {
log_fn(LOG_WARN,"Reason for ending (%d) not recognized.",*payload);
return "MALFORMED";
}
switch(*payload) {
case END_STREAM_REASON_MISC: return "misc error";
case END_STREAM_REASON_RESOLVEFAILED: return "resolve failed";
case END_STREAM_REASON_CONNECTFAILED: return "connect failed";
case END_STREAM_REASON_EXITPOLICY: return "exit policy failed";
case END_STREAM_REASON_DESTROY: return "destroyed";
case END_STREAM_REASON_DONE: return "closed normally";
case END_STREAM_REASON_TIMEOUT: return "gave up (timeout)";
}
tor_assert(0);
return "";
}
/** How many times will I retry a stream that fails due to DNS
* resolve failure?
*/
#define MAX_RESOLVE_FAILURES 3
/** An incoming relay cell has arrived from circuit <b>circ</b> to
* stream <b>conn</b>.
*
* The arguments here are the same as in
* connection_edge_process_relay_cell() below; this function is called
* from there when <b>conn</b> is defined and not in an open state.
*/
static int
connection_edge_process_relay_cell_not_open(
relay_header_t *rh, cell_t *cell, circuit_t *circ,
connection_t *conn, crypt_path_t *layer_hint) {
uint32_t addr;
int reason;
if(rh->command == RELAY_COMMAND_END) {
reason = *(cell->payload+RELAY_HEADER_SIZE);
/* We have to check this here, since we aren't connected yet. */
if (rh->length >= 5 && reason == END_STREAM_REASON_EXITPOLICY) {
log_fn(LOG_INFO,"Address %s refused due to exit policy. Retrying.",
conn->socks_request->address);
addr = ntohl(get_uint32(cell->payload+RELAY_HEADER_SIZE+1));
client_dns_set_entry(conn->socks_request->address, addr);
conn->state = AP_CONN_STATE_CIRCUIT_WAIT;
circuit_detach_stream(circ,conn);
if(connection_ap_handshake_attach_circuit(conn) >= 0)
return 0;
log_fn(LOG_INFO,"Giving up on retrying (from exitpolicy); conn can't be handled.");
/* else, conn will get closed below */
} else if (rh->length && reason == END_STREAM_REASON_RESOLVEFAILED) {
if (client_dns_incr_failures(conn->socks_request->address)
< MAX_RESOLVE_FAILURES) {
/* We haven't retried too many times; reattach the connection. */
conn->state = AP_CONN_STATE_CIRCUIT_WAIT;
circuit_detach_stream(circ,conn);
if(connection_ap_handshake_attach_circuit(conn) >= 0)
return 0;
/* else, conn will get closed below */
log_fn(LOG_INFO,"Giving up on retrying (from resolvefailed); conn can't be handled.");
} else {
log_fn(LOG_WARN,"Have tried resolving address %s at %d different places. Giving up.",
conn->socks_request->address, MAX_RESOLVE_FAILURES);
}
}
log_fn(LOG_INFO,"Edge got end (%s) before we're connected. Marking for close.",
connection_edge_end_reason(cell->payload+RELAY_HEADER_SIZE, rh->length));
if(CIRCUIT_IS_ORIGIN(circ))
circuit_log_path(LOG_INFO,circ);
conn->has_sent_end = 1; /* we just got an 'end', don't need to send one */
connection_mark_for_close(conn);
return 0;
}
if(conn->type == CONN_TYPE_AP && rh->command == RELAY_COMMAND_CONNECTED) {
if(conn->state != AP_CONN_STATE_CONNECT_WAIT) {
log_fn(LOG_WARN,"Got 'connected' while not in state connect_wait. Dropping.");
return 0;
}
// log_fn(LOG_INFO,"Connected! Notifying application.");
conn->state = AP_CONN_STATE_OPEN;
if (rh->length >= 4) {
addr = ntohl(get_uint32(cell->payload+RELAY_HEADER_SIZE));
client_dns_set_entry(conn->socks_request->address, addr);
}
log_fn(LOG_INFO,"'connected' received after %d seconds.",
(int)(time(NULL) - conn->timestamp_lastread));
circuit_log_path(LOG_INFO,circ);
connection_ap_handshake_socks_reply(conn, NULL, 0, 1);
conn->socks_request->has_finished = 1;
/* handle anything that might have queued */
if (connection_edge_package_raw_inbuf(conn) < 0) {
connection_edge_end(conn, END_STREAM_REASON_MISC, conn->cpath_layer);
connection_mark_for_close(conn);
return 0;
}
return 0;
}
log_fn(LOG_WARN,"Got an unexpected relay command %d, in state %d (%s). Closing.",
rh->command, conn->state, conn_state_to_string[conn->type][conn->state]);
connection_edge_end(conn, END_STREAM_REASON_MISC, conn->cpath_layer);
connection_mark_for_close(conn);
return -1;
}
/** An incoming relay cell has arrived on circuit <b>circ</b>. If
* <b>conn</b> is NULL this is a control cell, else <b>cell</b> is
* destined for <b>conn</b>.
*
* If <b>layer_hint</b> is defined, then we're the origin of the
* circuit, and it specifies the hop that packaged <b>cell</b>.
*
* Return -1 if you want to tear down the circuit, else 0.
*/
static int
connection_edge_process_relay_cell(cell_t *cell, circuit_t *circ,
connection_t *conn,
crypt_path_t *layer_hint)
{
static int num_seen=0;
relay_header_t rh;
tor_assert(cell && circ);
relay_header_unpack(&rh, cell->payload);
// log_fn(LOG_DEBUG,"command %d stream %d", rh.command, rh.stream_id);
num_seen++;
log_fn(LOG_DEBUG,"Now seen %d relay cells here.", num_seen);
/* either conn is NULL, in which case we've got a control cell, or else
* conn points to the recognized stream. */
if(conn &&
conn->state != AP_CONN_STATE_OPEN &&
conn->state != EXIT_CONN_STATE_OPEN) {
return connection_edge_process_relay_cell_not_open(
&rh, cell, circ, conn, layer_hint);
}
switch(rh.command) {
case RELAY_COMMAND_DROP:
log_fn(LOG_INFO,"Got a relay-level padding cell. Dropping.");
return 0;
case RELAY_COMMAND_BEGIN:
if (layer_hint &&
circ->purpose != CIRCUIT_PURPOSE_S_REND_JOINED) {
log_fn(LOG_WARN,"relay begin request unsupported at AP. Dropping.");
return 0;
}
if(conn) {
log_fn(LOG_WARN,"begin cell for known stream. Dropping.");
return 0;
}
connection_exit_begin_conn(cell, circ);
return 0;
case RELAY_COMMAND_DATA:
++stats_n_data_cells_received;
if((layer_hint && --layer_hint->deliver_window < 0) ||
(!layer_hint && --circ->deliver_window < 0)) {
log_fn(LOG_WARN,"(relay data) circ deliver_window below 0. Killing.");
connection_edge_end(conn, END_STREAM_REASON_MISC, conn->cpath_layer);
connection_mark_for_close(conn);
return -1;
}
log_fn(LOG_DEBUG,"circ deliver_window now %d.", layer_hint ?
layer_hint->deliver_window : circ->deliver_window);
circuit_consider_sending_sendme(circ, layer_hint);
if(!conn) {
log_fn(LOG_INFO,"data cell dropped, unknown stream.");
return 0;
}
if(--conn->deliver_window < 0) { /* is it below 0 after decrement? */
log_fn(LOG_WARN,"(relay data) conn deliver_window below 0. Killing.");
return -1; /* somebody's breaking protocol. kill the whole circuit. */
}
stats_n_data_bytes_received += rh.length;
connection_write_to_buf(cell->payload + RELAY_HEADER_SIZE,
rh.length, conn);
connection_edge_consider_sending_sendme(conn);
return 0;
case RELAY_COMMAND_END:
if(!conn) {
log_fn(LOG_INFO,"end cell (%s) dropped, unknown stream.",
connection_edge_end_reason(cell->payload+RELAY_HEADER_SIZE, rh.length));
return 0;
}
/* XXX add to this log_fn the exit node's nickname? */
log_fn(LOG_INFO,"end cell (%s) for stream %d. Removing stream.",
connection_edge_end_reason(cell->payload+RELAY_HEADER_SIZE, rh.length),
conn->stream_id);
#ifdef HALF_OPEN
conn->done_sending = 1;
shutdown(conn->s, 1); /* XXX check return; refactor NM */
if (conn->done_receiving) {
/* We just *got* an end; no reason to send one. */
conn->has_sent_end = 1;
connection_mark_for_close(conn);
conn->hold_open_until_flushed = 1;
}
#else
/* We just *got* an end; no reason to send one. */
conn->has_sent_end = 1;
connection_mark_for_close(conn);
conn->hold_open_until_flushed = 1;
#endif
return 0;
case RELAY_COMMAND_EXTEND:
if(conn) {
log_fn(LOG_WARN,"'extend' for non-zero stream. Dropping.");
return 0;
}
return circuit_extend(cell, circ);
case RELAY_COMMAND_EXTENDED:
if(!layer_hint) {
log_fn(LOG_WARN,"'extended' unsupported at non-origin. Dropping.");
return 0;
}
log_fn(LOG_DEBUG,"Got an extended cell! Yay.");
if(circuit_finish_handshake(circ, cell->payload+RELAY_HEADER_SIZE) < 0) {
log_fn(LOG_WARN,"circuit_finish_handshake failed.");
return -1;
}
if (circuit_send_next_onion_skin(circ)<0) {
log_fn(LOG_INFO,"circuit_send_next_onion_skin() failed.");
return -1;
}
return 0;
case RELAY_COMMAND_TRUNCATE:
if(layer_hint) {
log_fn(LOG_WARN,"'truncate' unsupported at origin. Dropping.");
return 0;
}
if(circ->n_conn) {
connection_send_destroy(circ->n_circ_id, circ->n_conn);
circ->n_conn = NULL;
}
log_fn(LOG_DEBUG, "Processed 'truncate', replying.");
connection_edge_send_command(NULL, circ, RELAY_COMMAND_TRUNCATED,
NULL, 0, NULL);
return 0;
case RELAY_COMMAND_TRUNCATED:
if(!layer_hint) {
log_fn(LOG_WARN,"'truncated' unsupported at non-origin. Dropping.");
return 0;
}
circuit_truncated(circ, layer_hint);
return 0;
case RELAY_COMMAND_CONNECTED:
if(conn) {
log_fn(LOG_WARN,"'connected' unsupported while open. Closing circ.");
return -1;
}
log_fn(LOG_INFO,"'connected' received, no conn attached anymore. Ignoring.");
return 0;
case RELAY_COMMAND_SENDME:
if(!conn) {
if(layer_hint) {
layer_hint->package_window += CIRCWINDOW_INCREMENT;
log_fn(LOG_DEBUG,"circ-level sendme at origin, packagewindow %d.",
layer_hint->package_window);
circuit_resume_edge_reading(circ, layer_hint);
} else {
circ->package_window += CIRCWINDOW_INCREMENT;
log_fn(LOG_DEBUG,"circ-level sendme at non-origin, packagewindow %d.",
circ->package_window);
circuit_resume_edge_reading(circ, layer_hint);
}
return 0;
}
conn->package_window += STREAMWINDOW_INCREMENT;
log_fn(LOG_DEBUG,"stream-level sendme, packagewindow now %d.", conn->package_window);
connection_start_reading(conn);
connection_edge_package_raw_inbuf(conn); /* handle whatever might still be on the inbuf */
return 0;
case RELAY_COMMAND_ESTABLISH_INTRO:
case RELAY_COMMAND_ESTABLISH_RENDEZVOUS:
case RELAY_COMMAND_INTRODUCE1:
case RELAY_COMMAND_INTRODUCE2:
case RELAY_COMMAND_INTRODUCE_ACK:
case RELAY_COMMAND_RENDEZVOUS1:
case RELAY_COMMAND_RENDEZVOUS2:
case RELAY_COMMAND_INTRO_ESTABLISHED:
case RELAY_COMMAND_RENDEZVOUS_ESTABLISHED:
rend_process_relay_cell(circ, rh.command, rh.length,
cell->payload+RELAY_HEADER_SIZE);
return 0;
}
log_fn(LOG_WARN,"unknown relay command %d.",rh.command);
return -1;
}
uint64_t stats_n_data_cells_packaged = 0;
uint64_t stats_n_data_bytes_packaged = 0;
uint64_t stats_n_data_cells_received = 0;
uint64_t stats_n_data_bytes_received = 0;
/** While conn->inbuf has an entire relay payload of bytes on it,
* and the appropriate package windows aren't empty, grab a cell
* and send it down the circuit.
*
* Return -1 if conn should be marked for close, else return 0.
*/
int connection_edge_package_raw_inbuf(connection_t *conn) {
int amount_to_process, length;
char payload[CELL_PAYLOAD_SIZE];
circuit_t *circ;
tor_assert(conn);
tor_assert(!connection_speaks_cells(conn));
repeat_connection_edge_package_raw_inbuf:
circ = circuit_get_by_conn(conn);
if(!circ) {
log_fn(LOG_INFO,"conn has no circuits! Closing.");
return -1;
}
if(circuit_consider_stop_edge_reading(circ, conn->cpath_layer))
return 0;
if(conn->package_window <= 0) {
log_fn(LOG_WARN,"called with package_window %d. Tell Roger.", conn->package_window);
connection_stop_reading(conn);
return 0;
}
amount_to_process = buf_datalen(conn->inbuf);
if(!amount_to_process)
return 0;
if(amount_to_process > RELAY_PAYLOAD_SIZE) {
length = RELAY_PAYLOAD_SIZE;
} else {
length = amount_to_process;
}
stats_n_data_bytes_packaged += length;
stats_n_data_cells_packaged += 1;
connection_fetch_from_buf(payload, length, conn);
log_fn(LOG_DEBUG,"(%d) Packaging %d bytes (%d waiting).", conn->s, length,
(int)buf_datalen(conn->inbuf));
if(connection_edge_send_command(conn, circ, RELAY_COMMAND_DATA,
payload, length, conn->cpath_layer) < 0)
return 0; /* circuit is closed, don't continue */
if(!conn->cpath_layer) { /* non-rendezvous exit */
tor_assert(circ->package_window > 0);
circ->package_window--;
} else { /* we're an AP, or an exit on a rendezvous circ */
tor_assert(conn->cpath_layer->package_window > 0);
conn->cpath_layer->package_window--;
}
if(--conn->package_window <= 0) { /* is it 0 after decrement? */
connection_stop_reading(conn);
log_fn(LOG_DEBUG,"conn->package_window reached 0.");
circuit_consider_stop_edge_reading(circ, conn->cpath_layer);
return 0; /* don't process the inbuf any more */
}
log_fn(LOG_DEBUG,"conn->package_window is now %d",conn->package_window);
/* handle more if there's more, or return 0 if there isn't */
goto repeat_connection_edge_package_raw_inbuf;
}
/** Called when we've just received a relay data cell, or when
* we've just finished flushing all bytes to stream <b>conn</b>.
*
* If conn->outbuf is not too full, and our deliver window is
* low, send back a suitable number of stream-level sendme cells.
*/
void connection_edge_consider_sending_sendme(connection_t *conn) {
circuit_t *circ;
if(connection_outbuf_too_full(conn))
return;
circ = circuit_get_by_conn(conn);
if(!circ) {
/* this can legitimately happen if the destroy has already
* arrived and torn down the circuit */
log_fn(LOG_INFO,"No circuit associated with conn. Skipping.");
return;
}
while(conn->deliver_window < STREAMWINDOW_START - STREAMWINDOW_INCREMENT) {
log_fn(LOG_DEBUG,"Outbuf %d, Queueing stream sendme.", conn->outbuf_flushlen);
conn->deliver_window += STREAMWINDOW_INCREMENT;
if(connection_edge_send_command(conn, circ, RELAY_COMMAND_SENDME,
NULL, 0, conn->cpath_layer) < 0) {
log_fn(LOG_WARN,"connection_edge_send_command failed. Returning.");
return; /* the circuit's closed, don't continue */
}
}
}
/** The circuit <b>circ</b> has received a circuit-level sendme
* (on hop <b>layer_hint</b>, if we're the OP). Go through all the
* attached streams and let them resume reading and packaging, if
* their stream windows allow it.
*/
static void
circuit_resume_edge_reading(circuit_t *circ, crypt_path_t *layer_hint)
{
log_fn(LOG_DEBUG,"resuming");
/* have to check both n_streams and p_streams, to handle rendezvous */
if(circuit_resume_edge_reading_helper(circ->n_streams, circ, layer_hint) >= 0)
circuit_resume_edge_reading_helper(circ->p_streams, circ, layer_hint);
}
/** A helper function for circuit_resume_edge_reading() above.
* The arguments are the same, except that <b>conn</b> is the head
* of a linked list of edge streams that should each be considered.
*/
static int
circuit_resume_edge_reading_helper(connection_t *conn,
circuit_t *circ,
crypt_path_t *layer_hint) {
for( ; conn; conn=conn->next_stream) {
if((!layer_hint && conn->package_window > 0) ||
(layer_hint && conn->package_window > 0 && conn->cpath_layer == layer_hint)) {
connection_start_reading(conn);
/* handle whatever might still be on the inbuf */
connection_edge_package_raw_inbuf(conn);
/* If the circuit won't accept any more data, return without looking
* at any more of the streams. Any connections that should be stopped
* have already been stopped by connection_edge_package_raw_inbuf. */
if(circuit_consider_stop_edge_reading(circ, layer_hint))
return -1;
}
}
return 0;
}
/** Check if the package window for <b>circ</b> is empty (at
* hop <b>layer_hint</b> if it's defined).
*
* If yes, tell edge streams to stop reading and return -1.
* Else return 0.
*/
static int
circuit_consider_stop_edge_reading(circuit_t *circ, crypt_path_t *layer_hint)
{
connection_t *conn = NULL;
log_fn(LOG_DEBUG,"considering");
if(!layer_hint && circ->package_window <= 0) {
log_fn(LOG_DEBUG,"yes, not-at-origin. stopped.");
for(conn = circ->n_streams; conn; conn=conn->next_stream)
connection_stop_reading(conn);
return -1;
} else if(layer_hint && layer_hint->package_window <= 0) {
log_fn(LOG_DEBUG,"yes, at-origin. stopped.");
for(conn = circ->n_streams; conn; conn=conn->next_stream)
if(conn->cpath_layer == layer_hint)
connection_stop_reading(conn);
for(conn = circ->p_streams; conn; conn=conn->next_stream)
if(conn->cpath_layer == layer_hint)
connection_stop_reading(conn);
return -1;
}
return 0;
}
/** Check if the deliver_window for circuit <b>circ</b> (at hop
* <b>layer_hint</b> if it's defined) is low enough that we should
* send a circuit-level sendme back down the circuit. If so, send
* enough sendmes that the window would be overfull if we sent any
* more.
*/
static void
circuit_consider_sending_sendme(circuit_t *circ, crypt_path_t *layer_hint)
{
// log_fn(LOG_INFO,"Considering: layer_hint is %s",
// layer_hint ? "defined" : "null");
while((layer_hint ? layer_hint->deliver_window : circ->deliver_window) <
CIRCWINDOW_START - CIRCWINDOW_INCREMENT) {
log_fn(LOG_DEBUG,"Queueing circuit sendme.");
if(layer_hint)
layer_hint->deliver_window += CIRCWINDOW_INCREMENT;
else
circ->deliver_window += CIRCWINDOW_INCREMENT;
if(connection_edge_send_command(NULL, circ, RELAY_COMMAND_SENDME,
NULL, 0, layer_hint) < 0) {
log_fn(LOG_WARN,"connection_edge_send_command failed. Circuit's closed.");
return; /* the circuit's closed, don't continue */
}
}
}

4
src/or/rendclient.c
View File

@ -12,7 +12,7 @@
/** Called when we've established a circuit to an introduction point:
* send the introduction request. */
void
rend_client_introcirc_is_open(circuit_t *circ)
rend_client_introcirc_has_opened(circuit_t *circ)
{
tor_assert(circ->purpose == CIRCUIT_PURPOSE_C_INTRODUCING);
tor_assert(CIRCUIT_IS_ORIGIN(circ) && circ->cpath);
@ -133,7 +133,7 @@ err:
/** Called when a rendezvous circuit is open; sends a establish
* rendezvous circuit as appropriate. */
void
rend_client_rendcirc_is_open(circuit_t *circ)
rend_client_rendcirc_has_opened(circuit_t *circ)
{
tor_assert(circ->purpose == CIRCUIT_PURPOSE_C_ESTABLISH_REND);
tor_assert(CIRCUIT_IS_ORIGIN(circ));

4
src/or/rendservice.c
View File

@ -530,7 +530,7 @@ rend_service_launch_establish_intro(rend_service_t *service, const char *nicknam
* sends a RELAY_ESTABLISH_INTRO cell.
*/
void
rend_service_intro_is_ready(circuit_t *circuit)
rend_service_intro_has_opened(circuit_t *circuit)
{
rend_service_t *service;
int len, r;
@ -618,7 +618,7 @@ rend_service_intro_established(circuit_t *circuit, const char *request, int requ
* RELAY_COMMAND_RENDEZVOUS1 cell.
*/
void
rend_service_rendezvous_is_ready(circuit_t *circuit)
rend_service_rendezvous_has_opened(circuit_t *circuit)
{
rend_service_t *service;
char buf[RELAY_PAYLOAD_SIZE];