2004-05-07 10:07:41 +02:00
|
|
|
/* Copyright 2001 Matej Pfajfar, 2001-2004 Roger Dingledine. */
|
Implemented link padding and receiver token buckets
Each socket reads at most 'bandwidth' bytes per second sustained, but
can handle bursts of up to 10*bandwidth bytes.
Cells are now sent out at evenly-spaced intervals, with padding sent
out otherwise. Set Linkpadding=0 in the rc file to send cells as soon
as they're available (and to never send padding cells).
Added license/copyrights statements at the top of most files.
router->min and router->max have been merged into a single 'bandwidth'
value. We should make the routerinfo_t reflect this (want to do that,
Mat?)
As the bandwidth increases, and we want to stop sleeping more and more
frequently to send a single cell, cpu usage goes up. At 128kB/s we're
pretty much calling poll with a timeout of 1ms or even 0ms. The current
code takes a timeout of 0-9ms and makes it 10ms. prepare_for_poll()
handles everything that should have happened in the past, so as long as
our buffers don't get too full in that 10ms, we're ok.
Speaking of too full, if you run three servers at 100kB/s with -l debug,
it spends too much time printing debugging messages to be able to keep
up with the cells. The outbuf ultimately fills up and it kills that
connection. If you run with -l err, it works fine up through 500kB/s and
probably beyond. Down the road we'll want to teach it to recognize when
an outbuf is getting full, and back off.
svn:r50
2002-07-16 03:12:15 +02:00
|
|
|
/* See LICENSE for licensing information */
|
|
|
|
/* $Id$ */
|
2002-06-27 00:45:49 +02:00
|
|
|
|
2004-05-09 18:47:25 +02:00
|
|
|
/**
|
|
|
|
* \file command.c
|
|
|
|
* \brief Functions for processing incoming cells
|
|
|
|
**/
|
|
|
|
|
2004-05-11 05:21:18 +02:00
|
|
|
/* In-points to command.c:
|
|
|
|
*
|
|
|
|
* - command_process_cell(), called from
|
2004-05-13 01:48:57 +02:00
|
|
|
* connection_or_process_cells_from_inbuf() in connection_or.c
|
2004-05-11 05:21:18 +02:00
|
|
|
*/
|
|
|
|
|
2002-06-27 00:45:49 +02:00
|
|
|
#include "or.h"
|
|
|
|
|
2004-05-10 12:27:54 +02:00
|
|
|
extern or_options_t options; /* command-line and config-file options */
|
2002-11-23 09:49:03 +01:00
|
|
|
|
2004-05-10 12:27:54 +02:00
|
|
|
/** Keep statistics about how many of each type of cell we've received. */
|
2003-10-02 22:00:38 +02:00
|
|
|
unsigned long stats_n_padding_cells_processed = 0;
|
|
|
|
unsigned long stats_n_create_cells_processed = 0;
|
|
|
|
unsigned long stats_n_created_cells_processed = 0;
|
|
|
|
unsigned long stats_n_relay_cells_processed = 0;
|
|
|
|
unsigned long stats_n_destroy_cells_processed = 0;
|
|
|
|
|
2004-05-09 18:47:25 +02:00
|
|
|
/** These are the main four functions for processing cells */
|
2003-09-16 07:41:49 +02:00
|
|
|
static void command_process_create_cell(cell_t *cell, connection_t *conn);
|
|
|
|
static void command_process_created_cell(cell_t *cell, connection_t *conn);
|
|
|
|
static void command_process_relay_cell(cell_t *cell, connection_t *conn);
|
|
|
|
static void command_process_destroy_cell(cell_t *cell, connection_t *conn);
|
|
|
|
|
2004-05-09 18:47:25 +02:00
|
|
|
/** This is a wrapper function around the actual function that processes the
|
|
|
|
* <b>cell</b> that just arrived on <b>conn</b>. Increment <b>*time</b>
|
|
|
|
* by the number of microseconds used by the call to <b>*func(cell, conn)</b>.
|
2004-05-07 10:07:41 +02:00
|
|
|
*/
|
|
|
|
static void command_time_process_cell(cell_t *cell, connection_t *conn, int *time,
|
2002-11-24 09:45:54 +01:00
|
|
|
void (*func)(cell_t *, connection_t *)) {
|
|
|
|
struct timeval start, end;
|
2003-12-17 22:09:31 +01:00
|
|
|
long time_passed;
|
2002-11-24 09:45:54 +01:00
|
|
|
|
2003-10-04 05:29:09 +02:00
|
|
|
tor_gettimeofday(&start);
|
2002-11-24 09:45:54 +01:00
|
|
|
|
|
|
|
(*func)(cell, conn);
|
|
|
|
|
2003-10-04 05:29:09 +02:00
|
|
|
tor_gettimeofday(&end);
|
2003-04-16 19:04:58 +02:00
|
|
|
time_passed = tv_udiff(&start, &end) ;
|
2002-11-24 09:45:54 +01:00
|
|
|
|
2004-02-28 08:01:22 +01:00
|
|
|
if (time_passed > 10000) { /* more than 10ms */
|
2003-06-18 00:18:26 +02:00
|
|
|
log_fn(LOG_INFO,"That call just took %ld ms.",time_passed/1000);
|
2002-11-24 09:45:54 +01:00
|
|
|
}
|
|
|
|
*time += time_passed;
|
|
|
|
}
|
|
|
|
|
2004-05-09 18:47:25 +02:00
|
|
|
/** Process a <b>cell</b> that was just received on <b>conn</b>. Keep internal
|
2004-05-07 10:07:41 +02:00
|
|
|
* statistics about how many of each cell we've processed so far
|
|
|
|
* this second, and the total number of microseconds it took to
|
|
|
|
* process each type of cell.
|
|
|
|
*/
|
2002-06-27 00:45:49 +02:00
|
|
|
void command_process_cell(cell_t *cell, connection_t *conn) {
|
2004-05-07 10:07:41 +02:00
|
|
|
/* how many of each cell have we seen so far this second? needs better
|
|
|
|
* name. */
|
2003-05-20 08:41:23 +02:00
|
|
|
static int num_create=0, num_created=0, num_relay=0, num_destroy=0;
|
2004-05-07 10:07:41 +02:00
|
|
|
/* how long has it taken to process each type of cell? */
|
2003-05-20 08:41:23 +02:00
|
|
|
static int create_time=0, created_time=0, relay_time=0, destroy_time=0;
|
2003-10-04 05:29:09 +02:00
|
|
|
static time_t current_second = 0; /* from previous calls to time */
|
2004-05-07 10:07:41 +02:00
|
|
|
|
2003-10-04 05:29:09 +02:00
|
|
|
time_t now = time(NULL);
|
2002-11-24 09:45:54 +01:00
|
|
|
|
2003-10-04 05:29:09 +02:00
|
|
|
if(now > current_second) { /* the second has rolled over */
|
2002-11-24 09:45:54 +01:00
|
|
|
/* print stats */
|
2004-04-16 00:09:14 +02:00
|
|
|
log(LOG_INFO,"At end of second: %d creates (%d ms), %d createds (%d ms), %d relays (%d ms), %d destroys (%d ms)",
|
|
|
|
num_create, create_time/1000,
|
|
|
|
num_created, created_time/1000,
|
|
|
|
num_relay, relay_time/1000,
|
|
|
|
num_destroy, destroy_time/1000);
|
2002-11-24 09:45:54 +01:00
|
|
|
|
|
|
|
/* zero out stats */
|
2003-05-20 08:41:23 +02:00
|
|
|
num_create = num_created = num_relay = num_destroy = 0;
|
|
|
|
create_time = created_time = relay_time = destroy_time = 0;
|
2002-11-24 09:45:54 +01:00
|
|
|
|
|
|
|
/* remember which second it is, for next time */
|
2003-10-04 05:29:09 +02:00
|
|
|
current_second = now;
|
2002-11-24 09:45:54 +01:00
|
|
|
}
|
2002-06-27 00:45:49 +02:00
|
|
|
|
|
|
|
switch(cell->command) {
|
|
|
|
case CELL_PADDING:
|
2003-10-02 22:00:38 +02:00
|
|
|
++stats_n_padding_cells_processed;
|
2002-06-27 00:45:49 +02:00
|
|
|
/* do nothing */
|
|
|
|
break;
|
|
|
|
case CELL_CREATE:
|
2003-10-02 22:00:38 +02:00
|
|
|
++stats_n_create_cells_processed;
|
2004-05-07 10:07:41 +02:00
|
|
|
++num_create;
|
|
|
|
command_time_process_cell(cell, conn, &create_time,
|
2002-11-24 09:45:54 +01:00
|
|
|
command_process_create_cell);
|
2002-06-27 00:45:49 +02:00
|
|
|
break;
|
2003-05-06 01:24:46 +02:00
|
|
|
case CELL_CREATED:
|
2003-10-02 22:00:38 +02:00
|
|
|
++stats_n_created_cells_processed;
|
2004-05-07 10:07:41 +02:00
|
|
|
++num_created;
|
|
|
|
command_time_process_cell(cell, conn, &created_time,
|
2003-05-06 01:24:46 +02:00
|
|
|
command_process_created_cell);
|
|
|
|
break;
|
2003-05-01 08:42:29 +02:00
|
|
|
case CELL_RELAY:
|
2003-10-02 22:00:38 +02:00
|
|
|
++stats_n_relay_cells_processed;
|
2004-05-07 10:07:41 +02:00
|
|
|
++num_relay;
|
|
|
|
command_time_process_cell(cell, conn, &relay_time,
|
2003-05-01 08:42:29 +02:00
|
|
|
command_process_relay_cell);
|
2002-06-27 00:45:49 +02:00
|
|
|
break;
|
|
|
|
case CELL_DESTROY:
|
2003-10-02 22:00:38 +02:00
|
|
|
++stats_n_destroy_cells_processed;
|
2004-05-07 10:07:41 +02:00
|
|
|
++num_destroy;
|
|
|
|
command_time_process_cell(cell, conn, &destroy_time,
|
2002-11-24 09:45:54 +01:00
|
|
|
command_process_destroy_cell);
|
2002-06-27 00:45:49 +02:00
|
|
|
break;
|
2002-07-18 08:37:58 +02:00
|
|
|
default:
|
2003-10-10 03:48:32 +02:00
|
|
|
log_fn(LOG_WARN,"Cell of unknown type (%d) received. Dropping.", cell->command);
|
2002-07-18 08:37:58 +02:00
|
|
|
break;
|
2002-06-27 00:45:49 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-05-09 18:47:25 +02:00
|
|
|
/** Process a 'create' <b>cell</b> that just arrived from <b>conn</b>. Make a new circuit
|
2004-05-07 10:07:41 +02:00
|
|
|
* with the p_circ_id specified in cell. Put the circuit in state
|
|
|
|
* onionskin_pending, and pass the onionskin to the cpuworker. Circ will
|
|
|
|
* get picked up again when the cpuworker finishes decrypting it.
|
|
|
|
*/
|
2003-09-16 07:41:49 +02:00
|
|
|
static void command_process_create_cell(cell_t *cell, connection_t *conn) {
|
2002-06-27 00:45:49 +02:00
|
|
|
circuit_t *circ;
|
|
|
|
|
2003-11-11 04:01:48 +01:00
|
|
|
circ = circuit_get_by_circ_id_conn(cell->circ_id, conn);
|
2002-06-27 00:45:49 +02:00
|
|
|
|
2003-05-06 01:24:46 +02:00
|
|
|
if(circ) {
|
2003-11-11 04:01:48 +01:00
|
|
|
log_fn(LOG_WARN,"received CREATE cell (circID %d) for known circ. Dropping.", cell->circ_id);
|
2002-06-27 00:45:49 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2003-11-11 04:01:48 +01:00
|
|
|
circ = circuit_new(cell->circ_id, conn);
|
2003-05-06 01:24:46 +02:00
|
|
|
circ->state = CIRCUIT_STATE_ONIONSKIN_PENDING;
|
2004-04-03 01:30:54 +02:00
|
|
|
circ->purpose = CIRCUIT_PURPOSE_OR;
|
2003-05-06 01:24:46 +02:00
|
|
|
|
2003-12-16 10:48:17 +01:00
|
|
|
memcpy(circ->onionskin, cell->payload, ONIONSKIN_CHALLENGE_LEN);
|
2003-05-06 01:24:46 +02:00
|
|
|
|
2003-08-21 01:05:22 +02:00
|
|
|
/* hand it off to the cpuworkers, and then return */
|
|
|
|
if(assign_to_cpuworker(NULL, CPUWORKER_TASK_ONION, circ) < 0) {
|
2003-10-10 03:48:32 +02:00
|
|
|
log_fn(LOG_WARN,"Failed to hand off onionskin. Closing.");
|
2004-03-02 18:48:17 +01:00
|
|
|
circuit_mark_for_close(circ);
|
2003-08-21 01:05:22 +02:00
|
|
|
return;
|
2003-05-06 01:24:46 +02:00
|
|
|
}
|
2004-02-28 08:01:22 +01:00
|
|
|
log_fn(LOG_DEBUG,"success: handed off onionskin.");
|
2003-05-06 01:24:46 +02:00
|
|
|
}
|
|
|
|
|
2004-05-09 18:47:25 +02:00
|
|
|
/** Process a 'created' <b>cell</b> that just arrived from <b>conn</b>. Find the circuit
|
|
|
|
* that it's intended for. If we're not the origin of the circuit, package
|
|
|
|
* the 'created' cell in an 'extended' relay cell and pass it back. If we
|
2004-05-07 10:07:41 +02:00
|
|
|
* are the origin of the circuit, send it to circuit_finish_handshake() to
|
|
|
|
* finish processing keys, and then call circuit_send_next_onion_skin() to
|
|
|
|
* extend to the next hop in the circuit if necessary.
|
|
|
|
*/
|
2003-09-16 07:41:49 +02:00
|
|
|
static void command_process_created_cell(cell_t *cell, connection_t *conn) {
|
2003-05-06 01:24:46 +02:00
|
|
|
circuit_t *circ;
|
|
|
|
|
2003-11-11 04:01:48 +01:00
|
|
|
circ = circuit_get_by_circ_id_conn(cell->circ_id, conn);
|
2003-05-06 01:24:46 +02:00
|
|
|
|
|
|
|
if(!circ) {
|
2003-11-11 04:01:48 +01:00
|
|
|
log_fn(LOG_INFO,"(circID %d) unknown circ (probably got a destroy earlier). Dropping.", cell->circ_id);
|
2003-05-06 01:24:46 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2003-11-11 04:01:48 +01:00
|
|
|
if(circ->n_circ_id != cell->circ_id) {
|
2003-10-10 03:48:32 +02:00
|
|
|
log_fn(LOG_WARN,"got created cell from OPward? Closing.");
|
2004-03-02 18:48:17 +01:00
|
|
|
circuit_mark_for_close(circ);
|
2003-05-06 01:24:46 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2004-04-08 04:24:06 +02:00
|
|
|
if(CIRCUIT_IS_ORIGIN(circ)) { /* we're the OP. Handshake this. */
|
2003-06-18 00:18:26 +02:00
|
|
|
log_fn(LOG_DEBUG,"at OP. Finishing handshake.");
|
2003-05-06 01:24:46 +02:00
|
|
|
if(circuit_finish_handshake(circ, cell->payload) < 0) {
|
2003-10-10 03:48:32 +02:00
|
|
|
log_fn(LOG_WARN,"circuit_finish_handshake failed.");
|
2004-03-02 18:48:17 +01:00
|
|
|
circuit_mark_for_close(circ);
|
2002-06-27 00:45:49 +02:00
|
|
|
return;
|
|
|
|
}
|
2003-06-18 00:18:26 +02:00
|
|
|
log_fn(LOG_DEBUG,"Moving to next skin.");
|
2003-05-06 01:24:46 +02:00
|
|
|
if(circuit_send_next_onion_skin(circ) < 0) {
|
2003-11-18 08:48:00 +01:00
|
|
|
log_fn(LOG_INFO,"circuit_send_next_onion_skin failed.");
|
2004-03-02 18:48:17 +01:00
|
|
|
circuit_mark_for_close(circ); /* XXX push this circuit_close lower */
|
2002-06-27 00:45:49 +02:00
|
|
|
return;
|
|
|
|
}
|
2003-05-06 01:24:46 +02:00
|
|
|
} else { /* pack it into an extended relay cell, and send it. */
|
2004-02-28 08:01:22 +01:00
|
|
|
log_fn(LOG_DEBUG,"Converting created cell to extended relay cell, sending.");
|
2003-10-04 10:19:23 +02:00
|
|
|
connection_edge_send_command(NULL, circ, RELAY_COMMAND_EXTENDED,
|
2003-12-16 10:48:17 +01:00
|
|
|
cell->payload, ONIONSKIN_REPLY_LEN, NULL);
|
2002-11-27 05:08:20 +01:00
|
|
|
}
|
|
|
|
}
|
2002-06-27 00:45:49 +02:00
|
|
|
|
2004-05-09 18:47:25 +02:00
|
|
|
/** Process a 'relay' <b>cell</b> that just arrived from <b>conn</b>. Make sure
|
2004-05-07 10:07:41 +02:00
|
|
|
* it came in with a recognized circ_id. Pass it on to
|
|
|
|
* circuit_receive_relay_cell() for actual processing.
|
|
|
|
*/
|
2003-09-16 07:41:49 +02:00
|
|
|
static void command_process_relay_cell(cell_t *cell, connection_t *conn) {
|
2002-07-18 08:37:58 +02:00
|
|
|
circuit_t *circ;
|
2002-06-27 00:45:49 +02:00
|
|
|
|
2003-11-11 04:01:48 +01:00
|
|
|
circ = circuit_get_by_circ_id_conn(cell->circ_id, conn);
|
2002-06-27 00:45:49 +02:00
|
|
|
|
|
|
|
if(!circ) {
|
2004-04-26 05:00:33 +02:00
|
|
|
log_fn(LOG_INFO,"unknown circuit %d on connection to %s:%d. Dropping.",
|
|
|
|
cell->circ_id, conn->address, conn->port);
|
2002-06-27 00:45:49 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2003-05-06 01:24:46 +02:00
|
|
|
if(circ->state == CIRCUIT_STATE_ONIONSKIN_PENDING) {
|
2003-10-10 03:48:32 +02:00
|
|
|
log_fn(LOG_WARN,"circuit in create_wait. Closing.");
|
2004-03-02 18:48:17 +01:00
|
|
|
circuit_mark_for_close(circ);
|
2002-11-27 05:08:20 +01:00
|
|
|
return;
|
|
|
|
}
|
major overhaul: dns slave subsystem, topics
on startup, it forks off a master dns handler, which forks off dns
slaves (like the apache model). slaves as spawned as load increases,
and then reused. excess slaves are not ever killed, currently.
implemented topics. each topic has a receive window in each direction
at each edge of the circuit, and sends sendme's at the data level, as
per before. each circuit also has receive windows in each direction at
each hop; an edge sends a circuit-level sendme as soon as enough data
cells have arrived (regardless of whether the data cells were flushed
to the exit conns). removed the 'connected' cell type, since it's now
a topic command within data cells.
at the edge of the circuit, there can be multiple connections associated
with a single circuit. you find them via the linked list conn->next_topic.
currently each new ap connection starts its own circuit, so we ought
to see comparable performance to what we had before. but that's only
because i haven't written the code to reattach to old circuits. please
try to break it as-is, and then i'll make it reuse the same circuit and
we'll try to break that.
svn:r152
2003-01-26 10:02:24 +01:00
|
|
|
|
2003-11-11 04:01:48 +01:00
|
|
|
if(cell->circ_id == circ->p_circ_id) { /* it's an outgoing cell */
|
2003-12-23 08:45:31 +01:00
|
|
|
if(circuit_receive_relay_cell(cell, circ, CELL_DIRECTION_OUT) < 0) {
|
|
|
|
log_fn(LOG_WARN,"circuit_receive_relay_cell (forward) failed. Closing.");
|
2004-03-02 18:48:17 +01:00
|
|
|
circuit_mark_for_close(circ);
|
2002-06-27 00:45:49 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else { /* it's an ingoing cell */
|
2003-12-23 08:45:31 +01:00
|
|
|
if(circuit_receive_relay_cell(cell, circ, CELL_DIRECTION_IN) < 0) {
|
|
|
|
log_fn(LOG_WARN,"circuit_receive_relay_cell (backward) failed. Closing.");
|
2004-03-02 18:48:17 +01:00
|
|
|
circuit_mark_for_close(circ);
|
major overhaul: dns slave subsystem, topics
on startup, it forks off a master dns handler, which forks off dns
slaves (like the apache model). slaves as spawned as load increases,
and then reused. excess slaves are not ever killed, currently.
implemented topics. each topic has a receive window in each direction
at each edge of the circuit, and sends sendme's at the data level, as
per before. each circuit also has receive windows in each direction at
each hop; an edge sends a circuit-level sendme as soon as enough data
cells have arrived (regardless of whether the data cells were flushed
to the exit conns). removed the 'connected' cell type, since it's now
a topic command within data cells.
at the edge of the circuit, there can be multiple connections associated
with a single circuit. you find them via the linked list conn->next_topic.
currently each new ap connection starts its own circuit, so we ought
to see comparable performance to what we had before. but that's only
because i haven't written the code to reattach to old circuits. please
try to break it as-is, and then i'll make it reuse the same circuit and
we'll try to break that.
svn:r152
2003-01-26 10:02:24 +01:00
|
|
|
return;
|
2002-06-27 00:45:49 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-05-09 18:47:25 +02:00
|
|
|
/** Process a 'destroy' <b>cell</b> that just arrived from
|
|
|
|
* <b>conn</b>. Find the circ that it refers to (if any).
|
2004-05-07 10:07:41 +02:00
|
|
|
*
|
|
|
|
* If the circ is in state
|
|
|
|
* onionskin_pending, then call onion_pending_remove() to remove it
|
|
|
|
* from the pending onion list (note that if it's already being
|
|
|
|
* processed by the cpuworker, it won't be in the list anymore; but
|
|
|
|
* when the cpuworker returns it, the circuit will be gone, and the
|
|
|
|
* cpuworker response will be dropped).
|
|
|
|
*
|
|
|
|
* Then mark the circuit for close (which marks all edges for close,
|
|
|
|
* and passes the destroy cell onward if necessary).
|
|
|
|
*/
|
2003-09-16 07:41:49 +02:00
|
|
|
static void command_process_destroy_cell(cell_t *cell, connection_t *conn) {
|
2002-06-27 00:45:49 +02:00
|
|
|
circuit_t *circ;
|
|
|
|
|
2003-11-11 04:01:48 +01:00
|
|
|
circ = circuit_get_by_circ_id_conn(cell->circ_id, conn);
|
2002-06-27 00:45:49 +02:00
|
|
|
|
|
|
|
if(!circ) {
|
2004-04-26 05:00:33 +02:00
|
|
|
log_fn(LOG_INFO,"unknown circuit %d on connection to %s:%d. Dropping.",
|
|
|
|
cell->circ_id, conn->address, conn->port);
|
2002-06-27 00:45:49 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2004-04-06 00:01:35 +02:00
|
|
|
log_fn(LOG_INFO,"Received for circID %d.",cell->circ_id);
|
2003-05-06 01:24:46 +02:00
|
|
|
if(circ->state == CIRCUIT_STATE_ONIONSKIN_PENDING) {
|
2002-11-27 05:08:20 +01:00
|
|
|
onion_pending_remove(circ);
|
|
|
|
}
|
major overhaul: dns slave subsystem, topics
on startup, it forks off a master dns handler, which forks off dns
slaves (like the apache model). slaves as spawned as load increases,
and then reused. excess slaves are not ever killed, currently.
implemented topics. each topic has a receive window in each direction
at each edge of the circuit, and sends sendme's at the data level, as
per before. each circuit also has receive windows in each direction at
each hop; an edge sends a circuit-level sendme as soon as enough data
cells have arrived (regardless of whether the data cells were flushed
to the exit conns). removed the 'connected' cell type, since it's now
a topic command within data cells.
at the edge of the circuit, there can be multiple connections associated
with a single circuit. you find them via the linked list conn->next_topic.
currently each new ap connection starts its own circuit, so we ought
to see comparable performance to what we had before. but that's only
because i haven't written the code to reattach to old circuits. please
try to break it as-is, and then i'll make it reuse the same circuit and
we'll try to break that.
svn:r152
2003-01-26 10:02:24 +01:00
|
|
|
|
2004-04-26 06:32:01 +02:00
|
|
|
if(cell->circ_id == circ->p_circ_id) {
|
|
|
|
/* the destroy came from behind */
|
2003-04-20 21:47:33 +02:00
|
|
|
circ->p_conn = NULL;
|
2004-03-02 18:48:17 +01:00
|
|
|
circuit_mark_for_close(circ);
|
2003-06-13 11:20:23 +02:00
|
|
|
} else { /* the destroy came from ahead */
|
2003-04-20 21:47:33 +02:00
|
|
|
circ->n_conn = NULL;
|
2004-04-26 06:32:01 +02:00
|
|
|
#if 0
|
|
|
|
if(!CIRCUIT_IS_ORIGIN(circ)) {
|
|
|
|
log_fn(LOG_DEBUG, "Delivering 'truncated' back.");
|
|
|
|
connection_edge_send_command(NULL, circ, RELAY_COMMAND_TRUNCATED,
|
|
|
|
NULL, 0, NULL);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
circuit_mark_for_close(circ);
|
2003-06-13 11:20:23 +02:00
|
|
|
}
|
2002-06-27 00:45:49 +02:00
|
|
|
}
|
|
|
|
|
2003-04-07 04:12:02 +02:00
|
|
|
/*
|
|
|
|
Local Variables:
|
|
|
|
mode:c
|
|
|
|
indent-tabs-mode:nil
|
|
|
|
c-basic-offset:2
|
|
|
|
End:
|
|
|
|
*/
|