[tor-commits] [tor/master] Convert relay.c/relay.h to channel_t

commit e136f7ccb4e671e33b6c92a48df819082291f5c1 Author: Andrea Shepard andrea@persephoneslair.org Date: Sat Aug 25 14:30:01 2012 -0700

Convert relay.c/relay.h to channel_t

Note: this is a squashed commit; see branch bug6465_rebased_v2 of user/andrea/tor.git for full history of the following 10 commits:

Convert relay.c/relay.h to channel_t Updating the timestamp if n_flushed > 0 at the end of channel_flush_from_first_active_circuit() was redundant since channel_write_cell() et al. do it themselves. Get rid of now-unnecessary time parameter in channel_flush_from_first_active_circuit() Get rid of now-unnecessary time parameter in channel_flush_from_first_active_circuit() in connection_or.c Add non-inlined external call for channeltls.c to free a packed_cell_t Appease make check-spaces in relay.c Replace channel_get_write_queue_len() with sufficient and easier to implement channel_has_queued_writes() in relay.c Rename channel_touched_by_client() and client_used field for consistency with other timestamps in relay.c Don't double-free packed cells in relay.c (channel_t Tor now bootstraps and works as a client) Rearrange channel_t struct to use a union distinguishing listener from cell-bearing channels in relay.c --- src/or/connection.c | 4 - src/or/relay.c | 405 +++++++++++++++++++++++++++++---------------------- src/or/relay.h | 8 +- 3 files changed, 236 insertions(+), 181 deletions(-)

diff --git a/src/or/connection.c b/src/or/connection.c index 8e9c701..db234f1 100644 --- a/src/or/connection.c +++ b/src/or/connection.c @@ -265,9 +265,6 @@ or_connection_new(int socket_family)

or_conn->timestamp_last_added_nonpadding = time(NULL);

- or_conn->active_circuit_pqueue = smartlist_new(); - or_conn->active_circuit_pqueue_last_recalibrated = cell_ewma_get_tick(); - return or_conn; }

@@ -508,7 +505,6 @@ _connection_free(connection_t *conn) or_conn->tls = NULL; or_handshake_state_free(or_conn->handshake_state); or_conn->handshake_state = NULL; - smartlist_free(or_conn->active_circuit_pqueue); tor_free(or_conn->nickname); } if (conn->type == CONN_TYPE_AP) { diff --git a/src/or/relay.c b/src/or/relay.c index 4a50b71..3850562 100644 --- a/src/or/relay.c +++ b/src/or/relay.c @@ -14,6 +14,7 @@ #define RELAY_PRIVATE #include "or.h" #include "buffers.h" +#include "channel.h" #include "circuitbuild.h" #include "circuitlist.h" #include "config.h" @@ -166,7 +167,7 @@ int circuit_receive_relay_cell(cell_t *cell, circuit_t *circ, cell_direction_t cell_direction) { - or_connection_t *or_conn=NULL; + channel_t *chan = NULL; crypt_path_t *layer_hint=NULL; char recognized=0; int reason; @@ -213,17 +214,17 @@ circuit_receive_relay_cell(cell_t *cell, circuit_t *circ, /* not recognized. pass it on. */ if (cell_direction == CELL_DIRECTION_OUT) { cell->circ_id = circ->n_circ_id; /* switch it */ - or_conn = circ->n_conn; + chan = circ->n_chan; } else if (! CIRCUIT_IS_ORIGIN(circ)) { cell->circ_id = TO_OR_CIRCUIT(circ)->p_circ_id; /* switch it */ - or_conn = TO_OR_CIRCUIT(circ)->p_conn; + chan = TO_OR_CIRCUIT(circ)->p_chan; } else { log_fn(LOG_PROTOCOL_WARN, LD_OR, "Dropping unrecognized inbound cell on origin circuit."); return 0; }

- if (!or_conn) { + if (!chan) { // XXXX Can this splice stuff be done more cleanly? if (! CIRCUIT_IS_ORIGIN(circ) && TO_OR_CIRCUIT(circ)->rend_splice && @@ -254,7 +255,7 @@ circuit_receive_relay_cell(cell_t *cell, circuit_t *circ, * we might kill the circ before we relay * the cells. */

- append_cell_to_circuit_queue(circ, or_conn, cell, cell_direction, 0); + append_cell_to_circuit_queue(circ, chan, cell, cell_direction, 0); return 0; }

@@ -353,13 +354,13 @@ circuit_package_relay_cell(cell_t *cell, circuit_t *circ, cell_direction_t cell_direction, crypt_path_t *layer_hint, streamid_t on_stream) { - or_connection_t *conn; /* where to send the cell */ + channel_t *chan; /* where to send the cell */

if (cell_direction == CELL_DIRECTION_OUT) { crypt_path_t *thishop; /* counter for repeated crypts */ - conn = circ->n_conn; - if (!CIRCUIT_IS_ORIGIN(circ) || !conn) { - log_warn(LD_BUG,"outgoing relay cell has n_conn==NULL. Dropping."); + chan = circ->n_chan; + if (!CIRCUIT_IS_ORIGIN(circ) || !chan) { + log_warn(LD_BUG,"outgoing relay cell has n_chan==NULL. Dropping."); return 0; /* just drop it */ }

@@ -388,14 +389,14 @@ circuit_package_relay_cell(cell_t *cell, circuit_t *circ, return 0; /* just drop it */ } or_circ = TO_OR_CIRCUIT(circ); - conn = or_circ->p_conn; + chan = or_circ->p_chan; relay_set_digest(or_circ->p_digest, cell); if (relay_crypt_one_payload(or_circ->p_crypto, cell->payload, 1) < 0) return -1; } ++stats_n_relay_cells_relayed;

- append_cell_to_circuit_queue(circ, conn, cell, cell_direction, on_stream); + append_cell_to_circuit_queue(circ, chan, cell, cell_direction, on_stream); return 0; }

@@ -561,9 +562,9 @@ relay_send_command_from_edge(streamid_t stream_id, circuit_t *circ, geoip_change_dirreq_state(circ->dirreq_id, DIRREQ_TUNNELED, DIRREQ_END_CELL_SENT);

- if (cell_direction == CELL_DIRECTION_OUT && circ->n_conn) { + if (cell_direction == CELL_DIRECTION_OUT && circ->n_chan) { /* if we're using relaybandwidthrate, this conn wants priority */ - circ->n_conn->client_used = approx_time(); + channel_timestamp_client(circ->n_chan); }

if (cell_direction == CELL_DIRECTION_OUT) { @@ -1095,7 +1096,8 @@ connection_edge_process_relay_cell(cell_t *cell, circuit_t *circ, * and linked. */ static uint64_t next_id = 0; circ->dirreq_id = ++next_id; - TO_CONN(TO_OR_CIRCUIT(circ)->p_conn)->dirreq_id = circ->dirreq_id; + tor_assert(!(TO_OR_CIRCUIT(circ)->p_chan->is_listener)); + TO_OR_CIRCUIT(circ)->p_chan->u.cell_chan.dirreq_id = circ->dirreq_id; }

return connection_exit_begin_conn(cell, circ); @@ -1230,12 +1232,12 @@ connection_edge_process_relay_cell(cell_t *cell, circuit_t *circ, "'truncate' unsupported at origin. Dropping."); return 0; } - if (circ->n_conn) { + if (circ->n_chan) { uint8_t trunc_reason = get_uint8(cell->payload + RELAY_HEADER_SIZE); - circuit_clear_cell_queue(circ, circ->n_conn); - connection_or_send_destroy(circ->n_circ_id, circ->n_conn, - trunc_reason); - circuit_set_n_circid_orconn(circ, 0, NULL); + circuit_clear_cell_queue(circ, circ->n_chan); + channel_send_destroy(circ->n_circ_id, circ->n_chan, + trunc_reason); + circuit_set_n_circid_chan(circ, 0, NULL); } log_debug(LD_EXIT, "Processed 'truncate', replying."); { @@ -1594,10 +1596,10 @@ circuit_resume_edge_reading_helper(edge_connection_t *first_conn, * needed to fill the cell queue. */ int max_to_package = circ->package_window; if (CIRCUIT_IS_ORIGIN(circ)) { - cells_on_queue = circ->n_conn_cells.n; + cells_on_queue = circ->n_chan_cells.n; } else { or_circuit_t *or_circ = TO_OR_CIRCUIT(circ); - cells_on_queue = or_circ->p_conn_cells.n; + cells_on_queue = or_circ->p_chan_cells.n; } if (CELL_QUEUE_HIGHWATER_SIZE - cells_on_queue < max_to_package) max_to_package = CELL_QUEUE_HIGHWATER_SIZE - cells_on_queue; @@ -1842,6 +1844,13 @@ packed_cell_new(void) return mp_pool_get(cell_pool); }

+/** Return a packed cell used outside by channel_t lower layer */ +void +packed_cell_free(packed_cell_t *cell) +{ + packed_cell_free_unchecked(cell); +} + /** Log current statistics for cell pool allocation at log level * <b>severity</b>. */ void @@ -1851,9 +1860,9 @@ dump_cell_pool_usage(int severity) int n_circs = 0; int n_cells = 0; for (c = _circuit_get_global_list(); c; c = c->next) { - n_cells += c->n_conn_cells.n; + n_cells += c->n_chan_cells.n; if (!CIRCUIT_IS_ORIGIN(c)) - n_cells += TO_OR_CIRCUIT(c)->p_conn_cells.n; + n_cells += TO_OR_CIRCUIT(c)->p_chan_cells.n; ++n_circs; } log(severity, LD_MM, "%d cells allocated on %d circuits. %d cells leaked.", @@ -1964,35 +1973,35 @@ cell_queue_pop(cell_queue_t *queue) return cell; }

-/** Return a pointer to the "next_active_on_{n,p}_conn" pointer of <b>circ</b>, - * depending on whether <b>conn</b> matches n_conn or p_conn. */ +/** Return a pointer to the "next_active_on_{n,p}_chan" pointer of <b>circ</b>, + * depending on whether <b>chan</b> matches n_chan or p_chan. */ static INLINE circuit_t ** -next_circ_on_conn_p(circuit_t *circ, or_connection_t *conn) +next_circ_on_chan_p(circuit_t *circ, channel_t *chan) { tor_assert(circ); - tor_assert(conn); - if (conn == circ->n_conn) { - return &circ->next_active_on_n_conn; + tor_assert(chan); + if (chan == circ->n_chan) { + return &circ->next_active_on_n_chan; } else { or_circuit_t *orcirc = TO_OR_CIRCUIT(circ); - tor_assert(conn == orcirc->p_conn); - return &orcirc->next_active_on_p_conn; + tor_assert(chan == orcirc->p_chan); + return &orcirc->next_active_on_p_chan; } }

-/** Return a pointer to the "prev_active_on_{n,p}_conn" pointer of <b>circ</b>, - * depending on whether <b>conn</b> matches n_conn or p_conn. */ +/** Return a pointer to the "prev_active_on_{n,p}_chan" pointer of <b>circ</b>, + * depending on whether <b>chan</b> matches n_chan or p_chan. */ static INLINE circuit_t ** -prev_circ_on_conn_p(circuit_t *circ, or_connection_t *conn) +prev_circ_on_chan_p(circuit_t *circ, channel_t *chan) { tor_assert(circ); - tor_assert(conn); - if (conn == circ->n_conn) { - return &circ->prev_active_on_n_conn; + tor_assert(chan); + if (chan == circ->n_chan) { + return &circ->prev_active_on_n_chan; } else { or_circuit_t *orcirc = TO_OR_CIRCUIT(circ); - tor_assert(conn == orcirc->p_conn); - return &orcirc->prev_active_on_p_conn; + tor_assert(chan == orcirc->p_chan); + return &orcirc->prev_active_on_p_chan; } }

@@ -2013,7 +2022,7 @@ compare_cell_ewma_counts(const void *p1, const void *p2) static circuit_t * cell_ewma_to_circuit(cell_ewma_t *ewma) { - if (ewma->is_for_p_conn) { + if (ewma->is_for_p_chan) { /* This is an or_circuit_t's p_cell_ewma. */ or_circuit_t *orcirc = SUBTYPE_P(ewma, or_circuit_t, p_cell_ewma); return TO_CIRCUIT(orcirc); @@ -2162,165 +2171,203 @@ scale_single_cell_ewma(cell_ewma_t *ewma, unsigned cur_tick) ewma->last_adjusted_tick = cur_tick; }

-/** Adjust the cell count of every active circuit on <b>conn</b> so +/** Adjust the cell count of every active circuit on <b>chan</b> so * that they are scaled with respect to <b>cur_tick</b> */ static void -scale_active_circuits(or_connection_t *conn, unsigned cur_tick) +scale_active_circuits(channel_t *chan, unsigned cur_tick) { + double factor; + + tor_assert(chan); + tor_assert(!(chan->is_listener));

- double factor = get_scale_factor( - conn->active_circuit_pqueue_last_recalibrated, - cur_tick); + factor = + get_scale_factor( + chan->u.cell_chan.active_circuit_pqueue_last_recalibrated, + cur_tick); /** Ordinarily it isn't okay to change the value of an element in a heap, * but it's okay here, since we are preserving the order. */ - SMARTLIST_FOREACH(conn->active_circuit_pqueue, cell_ewma_t *, e, { + SMARTLIST_FOREACH_BEGIN( + chan->u.cell_chan.active_circuit_pqueue, + cell_ewma_t *, e) { tor_assert(e->last_adjusted_tick == - conn->active_circuit_pqueue_last_recalibrated); + chan->u.cell_chan.active_circuit_pqueue_last_recalibrated); e->cell_count *= factor; e->last_adjusted_tick = cur_tick; - }); - conn->active_circuit_pqueue_last_recalibrated = cur_tick; + } SMARTLIST_FOREACH_END(e); + chan->u.cell_chan.active_circuit_pqueue_last_recalibrated = cur_tick; }

-/** Rescale <b>ewma</b> to the same scale as <b>conn</b>, and add it to - * <b>conn</b>'s priority queue of active circuits */ +/** Rescale <b>ewma</b> to the same scale as <b>chan</b>, and add it to + * <b>chan</b>'s priority queue of active circuits */ static void -add_cell_ewma_to_conn(or_connection_t *conn, cell_ewma_t *ewma) +add_cell_ewma_to_chan(channel_t *chan, cell_ewma_t *ewma) { + tor_assert(chan); + tor_assert(!(chan->is_listener)); + tor_assert(ewma); tor_assert(ewma->heap_index == -1); - scale_single_cell_ewma(ewma, - conn->active_circuit_pqueue_last_recalibrated);

- smartlist_pqueue_add(conn->active_circuit_pqueue, + scale_single_cell_ewma( + ewma, + chan->u.cell_chan.active_circuit_pqueue_last_recalibrated); + + smartlist_pqueue_add(chan->u.cell_chan.active_circuit_pqueue, compare_cell_ewma_counts, STRUCT_OFFSET(cell_ewma_t, heap_index), ewma); }

-/** Remove <b>ewma</b> from <b>conn</b>'s priority queue of active circuits */ +/** Remove <b>ewma</b> from <b>chan</b>'s priority queue of active circuits */ static void -remove_cell_ewma_from_conn(or_connection_t *conn, cell_ewma_t *ewma) +remove_cell_ewma_from_chan(channel_t *chan, cell_ewma_t *ewma) { + tor_assert(chan); + tor_assert(!(chan->is_listener)); + tor_assert(ewma); tor_assert(ewma->heap_index != -1); - smartlist_pqueue_remove(conn->active_circuit_pqueue, + + smartlist_pqueue_remove(chan->u.cell_chan.active_circuit_pqueue, compare_cell_ewma_counts, STRUCT_OFFSET(cell_ewma_t, heap_index), ewma); }

-/** Remove and return the first cell_ewma_t from conn's priority queue of +/** Remove and return the first cell_ewma_t from chan's priority queue of * active circuits. Requires that the priority queue is nonempty. */ static cell_ewma_t * -pop_first_cell_ewma_from_conn(or_connection_t *conn) +pop_first_cell_ewma_from_chan(channel_t *chan) { - return smartlist_pqueue_pop(conn->active_circuit_pqueue, + tor_assert(chan); + tor_assert(!(chan->is_listener)); + + return smartlist_pqueue_pop(chan->u.cell_chan.active_circuit_pqueue, compare_cell_ewma_counts, STRUCT_OFFSET(cell_ewma_t, heap_index)); }

/** Add <b>circ</b> to the list of circuits with pending cells on - * <b>conn</b>. No effect if <b>circ</b> is already linked. */ + * <b>chan</b>. No effect if <b>circ</b> is already linked. */ void -make_circuit_active_on_conn(circuit_t *circ, or_connection_t *conn) +make_circuit_active_on_chan(circuit_t *circ, channel_t *chan) { - circuit_t **nextp = next_circ_on_conn_p(circ, conn); - circuit_t **prevp = prev_circ_on_conn_p(circ, conn); + circuit_t **nextp = NULL, **prevp = NULL; + + tor_assert(chan); + tor_assert(!(chan->is_listener)); + tor_assert(circ); + + nextp = next_circ_on_chan_p(circ, chan); + prevp = prev_circ_on_chan_p(circ, chan);

if (*nextp && *prevp) { /* Already active. */ return; }

- assert_active_circuits_ok_paranoid(conn); + assert_active_circuits_ok_paranoid(chan);

- if (! conn->active_circuits) { - conn->active_circuits = circ; + if (!(chan->u.cell_chan.active_circuits)) { + chan->u.cell_chan.active_circuits = circ; *prevp = *nextp = circ; } else { - circuit_t *head = conn->active_circuits; - circuit_t *old_tail = *prev_circ_on_conn_p(head, conn); - *next_circ_on_conn_p(old_tail, conn) = circ; + circuit_t *head = chan->u.cell_chan.active_circuits; + circuit_t *old_tail = *prev_circ_on_chan_p(head, chan); + *next_circ_on_chan_p(old_tail, chan) = circ; *nextp = head; - *prev_circ_on_conn_p(head, conn) = circ; + *prev_circ_on_chan_p(head, chan) = circ; *prevp = old_tail; }

- if (circ->n_conn == conn) { - add_cell_ewma_to_conn(conn, &circ->n_cell_ewma); + if (circ->n_chan == chan) { + add_cell_ewma_to_chan(chan, &circ->n_cell_ewma); } else { or_circuit_t *orcirc = TO_OR_CIRCUIT(circ); - tor_assert(conn == orcirc->p_conn); - add_cell_ewma_to_conn(conn, &orcirc->p_cell_ewma); + tor_assert(chan == orcirc->p_chan); + add_cell_ewma_to_chan(chan, &orcirc->p_cell_ewma); }

- assert_active_circuits_ok_paranoid(conn); + assert_active_circuits_ok_paranoid(chan); }

/** Remove <b>circ</b> from the list of circuits with pending cells on - * <b>conn</b>. No effect if <b>circ</b> is already unlinked. */ + * <b>chan</b>. No effect if <b>circ</b> is already unlinked. */ void -make_circuit_inactive_on_conn(circuit_t *circ, or_connection_t *conn) +make_circuit_inactive_on_chan(circuit_t *circ, channel_t *chan) { - circuit_t **nextp = next_circ_on_conn_p(circ, conn); - circuit_t **prevp = prev_circ_on_conn_p(circ, conn); - circuit_t *next = *nextp, *prev = *prevp; + circuit_t **nextp = NULL, **prevp = NULL; + circuit_t *next = NULL, *prev = NULL; + + tor_assert(chan); + tor_assert(!(chan->is_listener)); + tor_assert(circ); + + nextp = next_circ_on_chan_p(circ, chan); + prevp = prev_circ_on_chan_p(circ, chan); + next = *nextp; + prev = *prevp;

if (!next && !prev) { /* Already inactive. */ return; }

- assert_active_circuits_ok_paranoid(conn); + assert_active_circuits_ok_paranoid(chan);

tor_assert(next && prev); - tor_assert(*prev_circ_on_conn_p(next, conn) == circ); - tor_assert(*next_circ_on_conn_p(prev, conn) == circ); + tor_assert(*prev_circ_on_chan_p(next, chan) == circ); + tor_assert(*next_circ_on_chan_p(prev, chan) == circ);

if (next == circ) { - conn->active_circuits = NULL; + chan->u.cell_chan.active_circuits = NULL; } else { - *prev_circ_on_conn_p(next, conn) = prev; - *next_circ_on_conn_p(prev, conn) = next; - if (conn->active_circuits == circ) - conn->active_circuits = next; + *prev_circ_on_chan_p(next, chan) = prev; + *next_circ_on_chan_p(prev, chan) = next; + if (chan->u.cell_chan.active_circuits == circ) + chan->u.cell_chan.active_circuits = next; } *prevp = *nextp = NULL;

- if (circ->n_conn == conn) { - remove_cell_ewma_from_conn(conn, &circ->n_cell_ewma); + if (circ->n_chan == chan) { + remove_cell_ewma_from_chan(chan, &circ->n_cell_ewma); } else { or_circuit_t *orcirc = TO_OR_CIRCUIT(circ); - tor_assert(conn == orcirc->p_conn); - remove_cell_ewma_from_conn(conn, &orcirc->p_cell_ewma); + tor_assert(chan == orcirc->p_chan); + remove_cell_ewma_from_chan(chan, &orcirc->p_cell_ewma); }

- assert_active_circuits_ok_paranoid(conn); + assert_active_circuits_ok_paranoid(chan); }

/** Remove all circuits from the list of circuits with pending cells on - * <b>conn</b>. */ + * <b>chan</b>. */ void -connection_or_unlink_all_active_circs(or_connection_t *orconn) +channel_unlink_all_active_circs(channel_t *chan) { - circuit_t *head = orconn->active_circuits; - circuit_t *cur = head; + circuit_t *head = NULL, *cur = NULL; + + tor_assert(chan); + tor_assert(!(chan->is_listener)); + + cur = head = chan->u.cell_chan.active_circuits; if (! head) return; do { - circuit_t *next = *next_circ_on_conn_p(cur, orconn); - *prev_circ_on_conn_p(cur, orconn) = NULL; - *next_circ_on_conn_p(cur, orconn) = NULL; + circuit_t *next = *next_circ_on_chan_p(cur, chan); + *prev_circ_on_chan_p(cur, chan) = NULL; + *next_circ_on_chan_p(cur, chan) = NULL; cur = next; } while (cur != head); - orconn->active_circuits = NULL; + chan->u.cell_chan.active_circuits = NULL;

- SMARTLIST_FOREACH(orconn->active_circuit_pqueue, cell_ewma_t *, e, + SMARTLIST_FOREACH(chan->u.cell_chan.active_circuit_pqueue, + cell_ewma_t *, e, e->heap_index = -1); - smartlist_clear(orconn->active_circuit_pqueue); + smartlist_clear(chan->u.cell_chan.active_circuit_pqueue); }

/** Block (if <b>block</b> is true) or unblock (if <b>block</b> is false) - * every edge connection that is using <b>circ</b> to write to <b>orconn</b>, + * every edge connection that is using <b>circ</b> to write to <b>chan</b>, * and start or stop reading as appropriate. * * If <b>stream_id</b> is nonzero, block only the edge connection whose @@ -2329,17 +2376,17 @@ connection_or_unlink_all_active_circs(or_connection_t *orconn) * Returns the number of streams whose status we changed. */ static int -set_streams_blocked_on_circ(circuit_t *circ, or_connection_t *orconn, +set_streams_blocked_on_circ(circuit_t *circ, channel_t *chan, int block, streamid_t stream_id) { edge_connection_t *edge = NULL; int n = 0; - if (circ->n_conn == orconn) { - circ->streams_blocked_on_n_conn = block; + if (circ->n_chan == chan) { + circ->streams_blocked_on_n_chan = block; if (CIRCUIT_IS_ORIGIN(circ)) edge = TO_ORIGIN_CIRCUIT(circ)->p_streams; } else { - circ->streams_blocked_on_p_conn = block; + circ->streams_blocked_on_p_chan = block; tor_assert(!CIRCUIT_IS_ORIGIN(circ)); edge = TO_OR_CIRCUIT(circ)->n_streams; } @@ -2374,12 +2421,11 @@ set_streams_blocked_on_circ(circuit_t *circ, or_connection_t *orconn, }

/** Pull as many cells as possible (but no more than <b>max</b>) from the - * queue of the first active circuit on <b>conn</b>, and write them to - * <b>conn</b>-&gt;outbuf. Return the number of cells written. Advance + * queue of the first active circuit on <b>chan</b>, and write them to + * <b>chan</b>-&gt;outbuf. Return the number of cells written. Advance * the active circuit pointer to the next active circuit in the ring. */ int -connection_or_flush_from_first_active_circuit(or_connection_t *conn, int max, - time_t now) +channel_flush_from_first_active_circuit(channel_t *chan, int max) { int n_flushed; cell_queue_t *queue; @@ -2393,9 +2439,12 @@ connection_or_flush_from_first_active_circuit(or_connection_t *conn, int max, cell_ewma_t *cell_ewma = NULL; double ewma_increment = -1;

- circ = conn->active_circuits; + tor_assert(chan); + tor_assert(!(chan->is_listener)); + + circ = chan->u.cell_chan.active_circuits; if (!circ) return 0; - assert_active_circuits_ok_paranoid(conn); + assert_active_circuits_ok_paranoid(chan);

/* See if we're doing the ewma circuit selection algorithm. */ if (ewma_enabled) { @@ -2404,28 +2453,28 @@ connection_or_flush_from_first_active_circuit(or_connection_t *conn, int max, tor_gettimeofday_cached(&now_hires); tick = cell_ewma_tick_from_timeval(&now_hires, &fractional_tick);

- if (tick != conn->active_circuit_pqueue_last_recalibrated) { - scale_active_circuits(conn, tick); + if (tick != chan->u.cell_chan.active_circuit_pqueue_last_recalibrated) { + scale_active_circuits(chan, tick); }

ewma_increment = pow(ewma_scale_factor, -fractional_tick);

- cell_ewma = smartlist_get(conn->active_circuit_pqueue, 0); + cell_ewma = smartlist_get(chan->u.cell_chan.active_circuit_pqueue, 0); circ = cell_ewma_to_circuit(cell_ewma); }

- if (circ->n_conn == conn) { - queue = &circ->n_conn_cells; - streams_blocked = circ->streams_blocked_on_n_conn; + if (circ->n_chan == chan) { + queue = &circ->n_chan_cells; + streams_blocked = circ->streams_blocked_on_n_chan; } else { - queue = &TO_OR_CIRCUIT(circ)->p_conn_cells; - streams_blocked = circ->streams_blocked_on_p_conn; + queue = &TO_OR_CIRCUIT(circ)->p_chan_cells; + streams_blocked = circ->streams_blocked_on_p_chan; } - tor_assert(*next_circ_on_conn_p(circ,conn)); + tor_assert(*next_circ_on_chan_p(circ, chan));

for (n_flushed = 0; n_flushed < max && queue->head; ) { packed_cell_t *cell = cell_queue_pop(queue); - tor_assert(*next_circ_on_conn_p(circ,conn)); + tor_assert(*next_circ_on_chan_p(circ, chan));

/* Calculate the exact time that this cell has spent in the queue. */ if (get_options()->CellStatistics && !CIRCUIT_IS_ORIGIN(circ)) { @@ -2462,14 +2511,18 @@ connection_or_flush_from_first_active_circuit(or_connection_t *conn, int max,

/* If we just flushed our queue and this circuit is used for a * tunneled directory request, possibly advance its state. */ - if (queue->n == 0 && TO_CONN(conn)->dirreq_id) - geoip_change_dirreq_state(TO_CONN(conn)->dirreq_id, + if (queue->n == 0 && chan->u.cell_chan.dirreq_id) + geoip_change_dirreq_state(chan->u.cell_chan.dirreq_id, DIRREQ_TUNNELED, DIRREQ_CIRC_QUEUE_FLUSHED);

- connection_write_to_buf(cell->body, CELL_NETWORK_SIZE, TO_CONN(conn)); + channel_write_packed_cell(chan, cell); + /* + * Don't packed_cell_free_unchecked(cell) here because the channel will + * do so when it gets out of the channel queue (probably already did, in + * which case that was an immediate double-free bug). + */

- packed_cell_free_unchecked(cell); ++n_flushed; if (cell_ewma) { cell_ewma_t *tmp; @@ -2477,44 +2530,43 @@ connection_or_flush_from_first_active_circuit(or_connection_t *conn, int max, /* We pop and re-add the cell_ewma_t here, not above, since we need to * re-add it immediately to keep the priority queue consistent with * the linked-list implementation */ - tmp = pop_first_cell_ewma_from_conn(conn); + tmp = pop_first_cell_ewma_from_chan(chan); tor_assert(tmp == cell_ewma); - add_cell_ewma_to_conn(conn, cell_ewma); + add_cell_ewma_to_chan(chan, cell_ewma); } - if (!ewma_enabled && circ != conn->active_circuits) { + if (!ewma_enabled && circ != chan->u.cell_chan.active_circuits) { /* If this happens, the current circuit just got made inactive by * a call in connection_write_to_buf(). That's nothing to worry about: - * circuit_make_inactive_on_conn() already advanced conn->active_circuits + * circuit_make_inactive_on_conn() already advanced chan->active_circuits * for us. */ - assert_active_circuits_ok_paranoid(conn); + assert_active_circuits_ok_paranoid(chan); goto done; } } - tor_assert(*next_circ_on_conn_p(circ,conn)); - assert_active_circuits_ok_paranoid(conn); - conn->active_circuits = *next_circ_on_conn_p(circ, conn); + tor_assert(*next_circ_on_chan_p(circ, chan)); + assert_active_circuits_ok_paranoid(chan); + chan->u.cell_chan.active_circuits = *next_circ_on_chan_p(circ, chan);

/* Is the cell queue low enough to unblock all the streams that are waiting * to write to this circuit? */ if (streams_blocked && queue->n <= CELL_QUEUE_LOWWATER_SIZE) - set_streams_blocked_on_circ(circ, conn, 0, 0); /* unblock streams */ + set_streams_blocked_on_circ(circ, chan, 0, 0); /* unblock streams */

/* Did we just run out of cells on this circuit's queue? */ if (queue->n == 0) { log_debug(LD_GENERAL, "Made a circuit inactive."); - make_circuit_inactive_on_conn(circ, conn); + make_circuit_inactive_on_chan(circ, chan); } done: - if (n_flushed) - conn->timestamp_last_added_nonpadding = now; + return n_flushed; }

-/** Add <b>cell</b> to the queue of <b>circ</b> writing to <b>orconn</b> +/** Add <b>cell</b> to the queue of <b>circ</b> writing to <b>chan</b> * transmitting in <b>direction</b>. */ void -append_cell_to_circuit_queue(circuit_t *circ, or_connection_t *orconn, +append_cell_to_circuit_queue(circuit_t *circ, channel_t *chan, cell_t *cell, cell_direction_t direction, streamid_t fromstream) { @@ -2524,12 +2576,12 @@ append_cell_to_circuit_queue(circuit_t *circ, or_connection_t *orconn, return;

if (direction == CELL_DIRECTION_OUT) { - queue = &circ->n_conn_cells; - streams_blocked = circ->streams_blocked_on_n_conn; + queue = &circ->n_chan_cells; + streams_blocked = circ->streams_blocked_on_n_chan; } else { or_circuit_t *orcirc = TO_OR_CIRCUIT(circ); - queue = &orcirc->p_conn_cells; - streams_blocked = circ->streams_blocked_on_p_conn; + queue = &orcirc->p_chan_cells; + streams_blocked = circ->streams_blocked_on_p_chan; }

cell_queue_append_packed_copy(queue, cell); @@ -2537,27 +2589,27 @@ append_cell_to_circuit_queue(circuit_t *circ, or_connection_t *orconn, /* If we have too many cells on the circuit, we should stop reading from * the edge streams for a while. */ if (!streams_blocked && queue->n >= CELL_QUEUE_HIGHWATER_SIZE) - set_streams_blocked_on_circ(circ, orconn, 1, 0); /* block streams */ + set_streams_blocked_on_circ(circ, chan, 1, 0); /* block streams */

if (streams_blocked && fromstream) { /* This edge connection is apparently not blocked; block it. */ - set_streams_blocked_on_circ(circ, orconn, 1, fromstream); + set_streams_blocked_on_circ(circ, chan, 1, fromstream); }

if (queue->n == 1) { /* This was the first cell added to the queue. We need to make this * circuit active. */ log_debug(LD_GENERAL, "Made a circuit active."); - make_circuit_active_on_conn(circ, orconn); + make_circuit_active_on_chan(circ, chan); }

- if (! connection_get_outbuf_len(TO_CONN(orconn))) { + if (!channel_has_queued_writes(chan)) { /* There is no data at all waiting to be sent on the outbuf. Add a * cell, so that we can notice when it gets flushed, flushed_some can * get called, and we can start putting more data onto the buffer then. */ log_debug(LD_GENERAL, "Primed a buffer."); - connection_or_flush_from_first_active_circuit(orconn, 1, approx_time()); + channel_flush_from_first_active_circuit(chan, 1); } }

@@ -2621,21 +2673,21 @@ decode_address_from_payload(tor_addr_t *addr_out, const uint8_t *payload, return payload + 2 + payload[1]; }

-/** Remove all the cells queued on <b>circ</b> for <b>orconn</b>. */ +/** Remove all the cells queued on <b>circ</b> for <b>chan</b>. */ void -circuit_clear_cell_queue(circuit_t *circ, or_connection_t *orconn) +circuit_clear_cell_queue(circuit_t *circ, channel_t *chan) { cell_queue_t *queue; - if (circ->n_conn == orconn) { - queue = &circ->n_conn_cells; + if (circ->n_chan == chan) { + queue = &circ->n_chan_cells; } else { or_circuit_t *orcirc = TO_OR_CIRCUIT(circ); - tor_assert(orcirc->p_conn == orconn); - queue = &orcirc->p_conn_cells; + tor_assert(orcirc->p_chan == chan); + queue = &orcirc->p_chan_cells; }

if (queue->n) - make_circuit_inactive_on_conn(circ,orconn); + make_circuit_inactive_on_chan(circ, chan);

cell_queue_clear(queue); } @@ -2643,36 +2695,41 @@ circuit_clear_cell_queue(circuit_t *circ, or_connection_t *orconn) /** Fail with an assert if the active circuits ring on <b>orconn</b> is * corrupt. */ void -assert_active_circuits_ok(or_connection_t *orconn) +assert_active_circuits_ok(channel_t *chan) { - circuit_t *head = orconn->active_circuits; - circuit_t *cur = head; + circuit_t *head = NULL, *cur = NULL; int n = 0; + + tor_assert(chan); + tor_assert(!(chan->is_listener)); + + cur = head = chan->u.cell_chan.active_circuits; + if (! head) return; do { - circuit_t *next = *next_circ_on_conn_p(cur, orconn); - circuit_t *prev = *prev_circ_on_conn_p(cur, orconn); + circuit_t *next = *next_circ_on_chan_p(cur, chan); + circuit_t *prev = *prev_circ_on_chan_p(cur, chan); cell_ewma_t *ewma; tor_assert(next); tor_assert(prev); - tor_assert(*next_circ_on_conn_p(prev, orconn) == cur); - tor_assert(*prev_circ_on_conn_p(next, orconn) == cur); - if (orconn == cur->n_conn) { + tor_assert(*next_circ_on_chan_p(prev, chan) == cur); + tor_assert(*prev_circ_on_chan_p(next, chan) == cur); + if (chan == cur->n_chan) { ewma = &cur->n_cell_ewma; - tor_assert(!ewma->is_for_p_conn); + tor_assert(!ewma->is_for_p_chan); } else { ewma = &TO_OR_CIRCUIT(cur)->p_cell_ewma; - tor_assert(ewma->is_for_p_conn); + tor_assert(ewma->is_for_p_chan); } tor_assert(ewma->heap_index != -1); - tor_assert(ewma == smartlist_get(orconn->active_circuit_pqueue, + tor_assert(ewma == smartlist_get(chan->u.cell_chan.active_circuit_pqueue, ewma->heap_index)); n++; cur = next; } while (cur != head);

- tor_assert(n == smartlist_len(orconn->active_circuit_pqueue)); + tor_assert(n == smartlist_len(chan->u.cell_chan.active_circuit_pqueue)); }

/** Return 1 if we shouldn't restart reading on this circuit, even if @@ -2682,9 +2739,9 @@ static int circuit_queue_streams_are_blocked(circuit_t *circ) { if (CIRCUIT_IS_ORIGIN(circ)) { - return circ->streams_blocked_on_n_conn; + return circ->streams_blocked_on_n_chan; } else { - return circ->streams_blocked_on_p_conn; + return circ->streams_blocked_on_p_chan; } }

diff --git a/src/or/relay.h b/src/or/relay.h index a414655..7f96d59 100644 --- a/src/or/relay.h +++ b/src/or/relay.h @@ -41,6 +41,9 @@ void free_cell_pool(void); void clean_cell_pool(void); void dump_cell_pool_usage(int severity);

+/* For channeltls.c */ +void packed_cell_free(packed_cell_t *cell); + void cell_queue_clear(cell_queue_t *queue); void cell_queue_append(cell_queue_t *queue, packed_cell_t *cell); void cell_queue_append_packed_copy(cell_queue_t *queue, const cell_t *cell); @@ -49,9 +52,8 @@ void append_cell_to_circuit_queue(circuit_t *circ, channel_t *chan, cell_t *cell, cell_direction_t direction, streamid_t fromstream); void channel_unlink_all_active_circs(channel_t *chan); -int channel_flush_from_first_active_circuit(channel_t *conn, - int max, time_t now); -void assert_active_circuits_ok(or_connection_t *orconn); +int channel_flush_from_first_active_circuit(channel_t *chan, int max); +void assert_active_circuits_ok(channel_t *chan); void make_circuit_inactive_on_chan(circuit_t *circ, channel_t *chan); void make_circuit_active_on_chan(circuit_t *circ, channel_t *chan);