October 2012 - tor-commits - lists.torproject.org

[tor/master] Implement circuitmux_detach_circuit() in circuitmux.c
by andrea＠torproject.org 11 Oct '12

11 Oct '12

commit c3ebd0340cca67dc4dd44bd18849100ebba39051 Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Sep 26 11:40:33 2012 -0700 Implement circuitmux_detach_circuit() in circuitmux.c --- src/or/circuitmux.c | 98 +++++++++++++++----------------------------------- 1 files changed, 30 insertions(+), 68 deletions(-) diff --git a/src/or/circuitmux.c b/src/or/circuitmux.c index 629fbcf..2a7d075 100644 --- a/src/or/circuitmux.c +++ b/src/or/circuitmux.c @@ -443,98 +443,60 @@ circuitmux_attach_circuit(circuitmux_t *cmux, circuit_t *circ, } } -/* - * Circuitmux/circuit attachment status inquiry functions - */ - /** - * Query the direction of an attached circuit + * Detach a circuit from a circuitmux and update all counters as needed; + * no-op if not attached. */ -cell_direction_t -circuitmux_attached_circuit_direction(circuitmux_t *cmux, circuit_t *circ) +void +circuitmux_detach_circuit(circuitmux_t *cmux, circuit_t *circ) { - chanid_circid_muxinfo_t *hashent = NULL; - - /* Try to find a map entry */ - hashent = circuitmux_find_map_entry(cmux, circ); - + chanid_circid_muxinfo_t search, *hashent = NULL; /* - * This function should only be called on attached circuits; assert that - * we had a map entry. + * Use this to keep track of whether we found it for n_chan or + * p_chan for consistency checking. */ - tor_assert(hashent); - - /* Return the direction from the map entry */ - return hashent->muxinfo.direction; -} - -/** - * Find an entry in the cmux's map for this circuit or return NULL if there - * is none. - */ + cell_direction_t last_searched_direction; -static chanid_circid_muxinfo_t * -circuitmux_find_map_entry(circuitmux_t *cmux, circuit_t *circ) -{ - chanid_circid_muxinfo_t search, *hashent = NULL; - - /* Sanity-check parameters */ tor_assert(cmux); tor_assert(cmux->chanid_circid_map); tor_assert(circ); tor_assert(circ->n_chan); - /* Okay, let's see if it's attached for n_chan/n_circ_id */ + /* See if we have it for n_chan/n_circ_id */ search.chan_id = circ->n_chan->global_identifier; search.circ_id = circ->n_circ_id; + hashent = HT_REMOVE(chanid_circid_muxinfo_map, cmux->chanid_circid_map, + &search); + last_searched_direction = CELL_DIRECTION_OUT; - /* Query */ - hashent = HT_FIND(chanid_circid_muxinfo_map, cmux->chanid_circid_map, - &search); - - /* Found something? */ - if (hashent) { - /* - * Assert that the direction makes sense for a hashent we found by - * n_chan/n_circ_id before we return it. - */ - tor_assert(hashent->muxinfo.direction == CELL_DIRECTION_OUT); - } else { - /* Not there, have we got a p_chan/p_circ_id to try? */ + /* Got one? If not, see if it's an or_circuit_t and try p_chan/p_circ_id */ + if (!hashent) { if (circ->magic == OR_CIRCUIT_MAGIC) { search.circ_id = TO_OR_CIRCUIT(circ)->p_circ_id; - /* Check for p_chan */ if (TO_OR_CIRCUIT(circ)->p_chan) { search.chan_id = TO_OR_CIRCUIT(circ)->p_chan->global_identifier; - /* Okay, search for that */ - hashent = HT_FIND(chanid_circid_muxinfo_map, cmux->chanid_circid_map, - &search); - /* Find anything? */ - if (hashent) { - /* Assert that the direction makes sense before we return it */ - tor_assert(hashent->muxinfo.direction == CELL_DIRECTION_IN); - } + hashent = HT_REMOVE(chanid_circid_muxinfo_map, + cmux->chanid_circid_map, + &search); + last_searched_direction = CELL_DIRECTION_IN; } } } - /* Okay, hashent is it if it was there */ - return hashent; -} - -/** - * Query whether a circuit is attached to a circuitmux - */ - -int -circuitmux_is_circuit_attached(circuitmux_t *cmux, circuit_t *circ) -{ - chanid_circid_muxinfo_t *hashent = NULL; + /* If hashent isn't NULL, we just removed it from the map */ + if (hashent) { + /* Update counters */ + --(cmux->n_circuits); + if (hashent->muxinfo.cell_count > 0) --(cmux->n_active_circuits); + cmux->n_cells -= hashent->muxinfo.cell_count; + /* TODO update active_circuits / active_circuit_pqueue */ - /* Look if it's in the circuit map */ - hashent = circuitmux_find_map_entry(cmux, circ); + /* Consistency check: the direction must match the direction searched */ + tor_assert(last_searched_direction == hashent->muxinfo.direction); - return (hashent != NULL); + /* Free the hash entry */ + tor_free(hashent); + } }

1 0

[tor/master] Implement circuitmux_attach_circuit() in circuitmux.c
by andrea＠torproject.org 11 Oct '12

11 Oct '12

commit 3c41d7f414511aeb6e9e0fd6bfb9be1af539840a Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Sep 26 00:56:26 2012 -0700 Implement circuitmux_attach_circuit() in circuitmux.c --- src/or/circuitmux.c | 238 ++++++++++++++++++++++++++++++++++++++++++++++++++- src/or/or.h | 4 - 2 files changed, 236 insertions(+), 6 deletions(-) diff --git a/src/or/circuitmux.c b/src/or/circuitmux.c index d4866ca..6508048 100644 --- a/src/or/circuitmux.c +++ b/src/or/circuitmux.c @@ -7,6 +7,7 @@ **/ #include "or.h" +#include "channel.h" #include "circuitmux.h" /* @@ -63,13 +64,16 @@ typedef struct circuit_muxinfo_s circuit_muxinfo_t; * TODO * * General status inquiries? - * + * */ struct circuitmux_s { /* Keep count of attached, active circuits */ unsigned int n_circuits, n_active_circuits; + /* Total number of queued cells on all circuits */ + unsigned int n_cells; + /* * Map from (channel ID, circuit ID) pairs to circuit_muxinfo_t */ @@ -102,11 +106,14 @@ struct circuitmux_s { /* * This struct holds whatever we want to store per attached circuit on a - * circuitmux_t; right now, just the count of queued cells. + * circuitmux_t; right now, just the count of queued cells and the direction. */ struct circuit_muxinfo_s { + /* Count of cells on this circuit at last update */ unsigned int cell_count; + /* Direction of flow */ + cell_direction_t direction; }; /* @@ -168,6 +175,10 @@ HT_GENERATE(chanid_circid_muxinfo_map, chanid_circid_muxinfo_t, node, chanid_circid_entry_hash, chanid_circid_entries_eq, 0.6, malloc, realloc, free); +/* + * Circuitmux alloc/free functions + */ + /** * Allocate a new circuitmux_t */ @@ -207,3 +218,226 @@ circuitmux_free(circuitmux_t *cmux) tor_free(cmux); } +/* + * Circuitmux/circuit attachment status inquiry functions + */ + +/** + * Query the direction of an attached circuit + */ + +cell_direction_t +circuitmux_attached_circuit_direction(circuitmux_t *cmux, circuit_t *circ) +{ + chanid_circid_muxinfo_t *hashent = NULL; + + /* Try to find a map entry */ + hashent = circuitmux_find_map_entry(cmux, circ); + + /* + * This function should only be called on attached circuits; assert that + * we had a map entry. + */ + tor_assert(hashent); + + /* Return the direction from the map entry */ + return hashent->muxinfo.direction; +} + +/** + * Find an entry in the cmux's map for this circuit or return NULL if there + * is none. + */ + +static chanid_circid_muxinfo_t * +circuitmux_find_map_entry(circuitmux_t *cmux, circuit_t *circ) +{ + chanid_circid_muxinfo_t search, *hashent = NULL; + + /* Sanity-check parameters */ + tor_assert(cmux); + tor_assert(cmux->chanid_circid_map); + tor_assert(circ); + tor_assert(circ->n_chan); + + /* Okay, let's see if it's attached for n_chan/n_circ_id */ + search.chan_id = circ->n_chan->global_identifier; + search.circ_id = circ->n_circ_id; + + /* Query */ + hashent = HT_FIND(chanid_circid_muxinfo_map, cmux->chanid_circid_map, + &search); + + /* Found something? */ + if (hashent) { + /* + * Assert that the direction makes sense for a hashent we found by + * n_chan/n_circ_id before we return it. + */ + tor_assert(hashent->muxinfo.direction == CELL_DIRECTION_OUT); + } else { + /* Not there, have we got a p_chan/p_circ_id to try? */ + if (circ->magic == OR_CIRCUIT_MAGIC) { + search.circ_id = TO_OR_CIRCUIT(circ)->p_circ_id; + /* Check for p_chan */ + if (TO_OR_CIRCUIT(circ)->p_chan) { + search.chan_id = TO_OR_CIRCUIT(circ)->p_chan->global_identifier; + /* Okay, search for that */ + hashent = HT_FIND(chanid_circid_muxinfo_map, cmux->chanid_circid_map, + &search); + /* Find anything? */ + if (hashent) { + /* Assert that the direction makes sense before we return it */ + tor_assert(hashent->muxinfo.direction == CELL_DIRECTION_IN); + } + } + } + } + + /* Okay, hashent is it if it was there */ + return hashent; +} + +/** + * Query whether a circuit is attached to a circuitmux + */ + +int +circuitmux_is_circuit_attached(circuitmux_t *cmux, circuit_t *circ) +{ + chanid_circid_muxinfo_t *hashent = NULL; + + /* Look if it's in the circuit map */ + hashent = circuitmux_find_map_entry(cmux, circ); + + return (hashent != NULL); +} + +/* + * Functions for circuit code to call to update circuit status + */ + +/** + * Attach a circuit to a circuitmux, for the specified direction. + */ + +void +circuitmux_attach_circuit(circuitmux_t *cmux, circuit_t *circ, + cell_direction_t direction) +{ + channel_t *chan = NULL; + uint64_t channel_id; + circid_t circ_id; + chanid_circid_muxinfo_t search, *hashent = NULL; + unsigned int cell_count; + + tor_assert(cmux); + tor_assert(circ); + tor_assert(direction == CELL_DIRECTION_IN || + direction == CELL_DIRECTION_OUT); + + /* + * Figure out which channel we're using, and get the circuit's current + * cell count and circuit ID. + */ + if (direction == CELL_DIRECTION_OUT) { + /* It's n_chan */ + chan = circ->n_chan; + cell_count = circ->n_chan_cells.n; + circ_id = circ->n_circ_id; + } else { + /* We want p_chan */ + chan = TO_OR_CIRCUIT(circ)->p_chan; + cell_count = TO_OR_CIRCUIT(circ)->p_chan_cells.n; + circ_id = TO_OR_CIRCUIT(circ)->p_circ_id; + } + /* Assert that we did get a channel */ + tor_assert(chan); + /* Assert that the circuit ID is sensible */ + tor_assert(circ_id != 0); + + /* Get the channel ID */ + channel_id = chan->global_identifier; + + /* See if we already have this one */ + search.chan_id = channel_id; + search.circ_id = circ_id; + hashent = HT_FIND(chanid_circid_muxinfo_map, cmux->chanid_circid_map, + &search); + + if (hashent) { + /* + * This circuit was already attached to this cmux; make sure the + * directions match and update the cell count and active circuit count. + */ + log_info(LD_CIRC, + "Circuit %u on channel " U64_FORMAT " was already attached to " + "cmux %p (trying to attach to %p)", + circ_id, U64_PRINTF_ARG(channel_id), + circ->mux, cmux); + + /* + * The mux pointer on the circuit should match this cmux, and the + * direction in result should match; otherwise assert. + */ + tor_assert(circ->mux == cmux); + tor_assert(hashent->muxinfo.direction == direction); + + /* + * Looks okay; just update the cell count and active circuits if we must + */ + if (hashent->muxinfo.cell_count > 0 && cell_count == 0) { + --(cmux->n_active_circuits); + } else if (hashent->muxinfo.cell_count == 0 && cell_count > 0) { + ++(cmux->n_active_circuits); + } + cmux->n_cells -= hashent->muxinfo.cell_count; + cmux->n_cells += cell_count; + hashent->muxinfo.cell_count = cell_count; + + /* TODO update active_circuits / active_circuit_pqueue */ + } else { + /* + * New circuit; add an entry and update the circuit/active circuit + * counts. + */ + log_debug(LD_CIRC, + "Attaching circuit %u on channel " U64_FORMAT " to cmux %p", + circ_id, U64_PRINTF_ARG(channel_id), cmux); + + /* Assert that the circuit doesn't already have a mux */ + tor_assert(circ->mux == NULL); + + /* Insert it in the map */ + hashent = tor_malloc_zero(sizeof(*hashent)); + hashent->chan_id = channel_id; + hashent->circ_id = circ_id; + hashent->muxinfo.cell_count = cell_count; + hashent->muxinfo.direction = direction; + HT_INSERT(chanid_circid_muxinfo_map, cmux->chanid_circid_map, + hashent); + + /* Set the circuit's mux */ + circ->mux = cmux; + + /* Make sure the next/prev pointers are NULL */ + if (direction == CELL_DIRECTION_OUT) { + circ->next_active_on_n_chan = NULL; + circ->prev_active_on_n_chan = NULL; + } else { + TO_OR_CIRCUIT(circ)->next_active_on_p_chan = NULL; + TO_OR_CIRCUIT(circ)->prev_active_on_p_chan = NULL; + } + + /* Update counters */ + ++(cmux->n_circuits); + if (cell_count > 0) { + ++(cmux->n_active_circuits); + circuitmux_make_circuit_active(cmux, circ, direction); + } + cmux->n_cells += cell_count; + + /* TODO update active_circuits / active_circuit_pqueue */ + } +} + diff --git a/src/or/or.h b/src/or/or.h index a9b0361..3555a08 100644 --- a/src/or/or.h +++ b/src/or/or.h @@ -2641,11 +2641,7 @@ typedef struct circuit_t { * The circuit_id used in the next (forward) hop of this circuit; * this is unique to n_chan, but this ordered pair is globally * unique: -<<<<<<< HEAD * -======= - * ->>>>>>> f1e8169... Use circuitmux_t in channels and when relaying cells * (n_chan->global_identifier, n_circ_id) */ circid_t n_circ_id;

1 0

[tor/master] Handle n_mux/p_mux properly in circuitmux.c
by andrea＠torproject.org 11 Oct '12

11 Oct '12

commit 8004448635d63fa829d2a836214c42c1609c3f01 Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Sep 26 11:51:39 2012 -0700 Handle n_mux/p_mux properly in circuitmux.c --- src/or/circuitmux.c | 30 +++++++++++++++++++++--------- src/or/or.h | 7 ++++++- 2 files changed, 27 insertions(+), 10 deletions(-) diff --git a/src/or/circuitmux.c b/src/or/circuitmux.c index 2a7d075..ede2486 100644 --- a/src/or/circuitmux.c +++ b/src/or/circuitmux.c @@ -340,7 +340,8 @@ circuitmux_attach_circuit(circuitmux_t *cmux, circuit_t *circ, /* * Figure out which channel we're using, and get the circuit's current - * cell count and circuit ID. + * cell count and circuit ID; assert that the circuit is not already + * attached to another mux. */ if (direction == CELL_DIRECTION_OUT) { /* It's n_chan */ @@ -376,13 +377,16 @@ circuitmux_attach_circuit(circuitmux_t *cmux, circuit_t *circ, "Circuit %u on channel " U64_FORMAT " was already attached to " "cmux %p (trying to attach to %p)", circ_id, U64_PRINTF_ARG(channel_id), - circ->mux, cmux); + ((direction == CELL_DIRECTION_OUT) ? + circ->n_mux : TO_OR_CIRCUIT(circ)->p_mux), + cmux); /* - * The mux pointer on the circuit should match this cmux, and the - * direction in result should match; otherwise assert. + * The mux pointer on this circuit and the direction in result should + * match; otherwise assert. */ - tor_assert(circ->mux == cmux); + if (direction == CELL_DIRECTION_OUT) tor_assert(circ->n_mux == cmux); + else tor_assert(TO_OR_CIRCUIT(circ)->p_mux == cmux); tor_assert(hashent->muxinfo.direction == direction); /* @@ -407,8 +411,12 @@ circuitmux_attach_circuit(circuitmux_t *cmux, circuit_t *circ, "Attaching circuit %u on channel " U64_FORMAT " to cmux %p", circ_id, U64_PRINTF_ARG(channel_id), cmux); - /* Assert that the circuit doesn't already have a mux */ - tor_assert(circ->mux == NULL); + /* + * Assert that the circuit doesn't already have a mux for this + * direction. + */ + if (direction == CELL_DIRECTION_OUT) tor_assert(circ->n_mux == NULL); + else tor_assert(TO_OR_CIRCUIT(circ)->p_mux == NULL); /* Insert it in the map */ hashent = tor_malloc_zero(sizeof(*hashent)); @@ -419,8 +427,9 @@ circuitmux_attach_circuit(circuitmux_t *cmux, circuit_t *circ, HT_INSERT(chanid_circid_muxinfo_map, cmux->chanid_circid_map, hashent); - /* Set the circuit's mux */ - circ->mux = cmux; + /* Set the circuit's mux for this direction */ + if (direction == CELL_DIRECTION_OUT) circ->n_mux = cmux; + else TO_OR_CIRCUIT(circ)->p_mux = cmux; /* Make sure the next/prev pointers are NULL */ if (direction == CELL_DIRECTION_OUT) { @@ -494,6 +503,9 @@ circuitmux_detach_circuit(circuitmux_t *cmux, circuit_t *circ) /* Consistency check: the direction must match the direction searched */ tor_assert(last_searched_direction == hashent->muxinfo.direction); + /* Clear the circuit's mux for this direction */ + if (last_searched_direction == CELL_DIRECTION_OUT) circ->n_mux = NULL; + else TO_OR_CIRCUIT(circ)->p_mux = NULL; /* Free the hash entry */ tor_free(hashent); diff --git a/src/or/or.h b/src/or/or.h index 3555a08..a0fcf8f 100644 --- a/src/or/or.h +++ b/src/or/or.h @@ -2650,7 +2650,7 @@ typedef struct circuit_t { * Circuit mux associated with n_chan to which this circuit is attached; * NULL if we have no n_chan. */ - circuitmux_t *mux; + circuitmux_t *n_mux; /** Queue of cells waiting to be transmitted on n_chan */ cell_queue_t n_chan_cells; @@ -2916,6 +2916,11 @@ typedef struct or_circuit_t { cell_queue_t p_chan_cells; /** The channel that is previous in this circuit. */ channel_t *p_chan; + /** + * Circuit mux associated with p_chan to which this circuit is attached; + * NULL if we have no p_chan. + */ + circuitmux_t *p_mux; /** Linked list of Exit streams associated with this circuit. */ edge_connection_t *n_streams; /** Linked list of Exit streams associated with this circuit that are

1 0

[tor/master] Implement circuitmux_clear_num_cells() and circuitmux_set_num_cells() in circuitmux.c, remove unneeded circuitmux_add_to_num_cells() from circuitmux.h
by andrea＠torproject.org 11 Oct '12

11 Oct '12

commit a9deec3550ed51b3cd2a6a51104745def56b5e7a Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Sep 26 12:23:58 2012 -0700 Implement circuitmux_clear_num_cells() and circuitmux_set_num_cells() in circuitmux.c, remove unneeded circuitmux_add_to_num_cells() from circuitmux.h --- src/or/circuitmux.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/or/circuitmux.h | 2 -- 2 files changed, 50 insertions(+), 2 deletions(-) diff --git a/src/or/circuitmux.c b/src/or/circuitmux.c index ede2486..f6cdbf1 100644 --- a/src/or/circuitmux.c +++ b/src/or/circuitmux.c @@ -512,3 +512,53 @@ circuitmux_detach_circuit(circuitmux_t *cmux, circuit_t *circ) } } +/** + * Clear the cell counter for a circuit on a circuitmux + */ + +void +circuitmux_clear_num_cells(circuitmux_t *cmux, circuit_t *circ) +{ + /* This is the same as setting the cell count to zero */ + circuitmux_set_num_cells(cmux, circ, 0); +} + +/** + * Set the cell counter for a circuit on a circuitmux + */ + +void +circuitmux_set_num_cells(circuitmux_t *cmux, circuit_t *circ, + unsigned int n_cells) +{ + chanid_circid_muxinfo_t *hashent = NULL; + + tor_assert(cmux); + tor_assert(circ); + + /* Search for this circuit's entry */ + hashent = circuitmux_find_map_entry(cmux, circ); + /* Assert that we found one */ + tor_assert(hashent); + + /* Update cmux cell counter */ + cmux->n_cells -= hashent->muxinfo.cell_count; + cmux->n_cells += n_cells; + + /* + * Update cmux active circuit counter: is the old cell count > 0 and the + * new cell count == 0 ? + */ + if (hashent->muxinfo.cell_count > 0 && n_cells == 0) { + --(cmux->n_active_circuits); + /* TODO update active_circuits / active_circuit_pqueue */ + /* Is the old cell count == 0 and the new cell count > 0 ? */ + } else if (hashent->muxinfo.cell_count == 0 && n_cells > 0) { + ++(cmux->n_active_circuits); + /* TODO update active_circuits / active_circuit_pqueue */ + } + + /* Update hash entry cell counter */ + hashent->muxinfo.cell_count = n_cells; +} + diff --git a/src/or/circuitmux.h b/src/or/circuitmux.h index c5f9526..ade544f 100644 --- a/src/or/circuitmux.h +++ b/src/or/circuitmux.h @@ -41,8 +41,6 @@ void circuitmux_attach_circuit(circuitmux_t *cmux, circuit_t *circ, cell_direction_t direction); void circuitmux_detach_circuit(circuitmux_t *cmux, circuit_t *circ); void circuitmux_clear_num_cells(circuitmux_t *cmux, circuit_t *circ); -void circuitmux_add_to_num_cells(circuitmux_t *cmux, circuit_t *circ, - unsigned int n_cells); void circuitmux_set_num_cells(circuitmux_t *cmux, circuit_t *circ, unsigned int n_cells);

1 0

[tor/master] Implement circuitmux_attached_circuit_direction(), circuitmux_find_map_entry() and circuitmux_is_circuit_attached() in circuitmux.c
by andrea＠torproject.org 11 Oct '12

11 Oct '12

commit 7e5c358d38cae7769426f1427f23ce6002cda980 Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Sep 26 10:54:08 2012 -0700 Implement circuitmux_attached_circuit_direction(), circuitmux_find_map_entry() and circuitmux_is_circuit_attached() in circuitmux.c --- src/or/circuitmux.c | 97 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 97 insertions(+), 0 deletions(-) diff --git a/src/or/circuitmux.c b/src/or/circuitmux.c index 6508048..629fbcf 100644 --- a/src/or/circuitmux.c +++ b/src/or/circuitmux.c @@ -137,6 +137,8 @@ chanid_circid_entries_eq(chanid_circid_muxinfo_t *a, chanid_circid_muxinfo_t *b); static INLINE unsigned int chanid_circid_entry_hash(chanid_circid_muxinfo_t *a); +static chanid_circid_muxinfo_t * +circuitmux_find_map_entry(circuitmux_t *cmux, circuit_t *circ); /* Function definitions */ @@ -441,3 +443,98 @@ circuitmux_attach_circuit(circuitmux_t *cmux, circuit_t *circ, } } +/* + * Circuitmux/circuit attachment status inquiry functions + */ + +/** + * Query the direction of an attached circuit + */ + +cell_direction_t +circuitmux_attached_circuit_direction(circuitmux_t *cmux, circuit_t *circ) +{ + chanid_circid_muxinfo_t *hashent = NULL; + + /* Try to find a map entry */ + hashent = circuitmux_find_map_entry(cmux, circ); + + /* + * This function should only be called on attached circuits; assert that + * we had a map entry. + */ + tor_assert(hashent); + + /* Return the direction from the map entry */ + return hashent->muxinfo.direction; +} + +/** + * Find an entry in the cmux's map for this circuit or return NULL if there + * is none. + */ + +static chanid_circid_muxinfo_t * +circuitmux_find_map_entry(circuitmux_t *cmux, circuit_t *circ) +{ + chanid_circid_muxinfo_t search, *hashent = NULL; + + /* Sanity-check parameters */ + tor_assert(cmux); + tor_assert(cmux->chanid_circid_map); + tor_assert(circ); + tor_assert(circ->n_chan); + + /* Okay, let's see if it's attached for n_chan/n_circ_id */ + search.chan_id = circ->n_chan->global_identifier; + search.circ_id = circ->n_circ_id; + + /* Query */ + hashent = HT_FIND(chanid_circid_muxinfo_map, cmux->chanid_circid_map, + &search); + + /* Found something? */ + if (hashent) { + /* + * Assert that the direction makes sense for a hashent we found by + * n_chan/n_circ_id before we return it. + */ + tor_assert(hashent->muxinfo.direction == CELL_DIRECTION_OUT); + } else { + /* Not there, have we got a p_chan/p_circ_id to try? */ + if (circ->magic == OR_CIRCUIT_MAGIC) { + search.circ_id = TO_OR_CIRCUIT(circ)->p_circ_id; + /* Check for p_chan */ + if (TO_OR_CIRCUIT(circ)->p_chan) { + search.chan_id = TO_OR_CIRCUIT(circ)->p_chan->global_identifier; + /* Okay, search for that */ + hashent = HT_FIND(chanid_circid_muxinfo_map, cmux->chanid_circid_map, + &search); + /* Find anything? */ + if (hashent) { + /* Assert that the direction makes sense before we return it */ + tor_assert(hashent->muxinfo.direction == CELL_DIRECTION_IN); + } + } + } + } + + /* Okay, hashent is it if it was there */ + return hashent; +} + +/** + * Query whether a circuit is attached to a circuitmux + */ + +int +circuitmux_is_circuit_attached(circuitmux_t *cmux, circuit_t *circ) +{ + chanid_circid_muxinfo_t *hashent = NULL; + + /* Look if it's in the circuit map */ + hashent = circuitmux_find_map_entry(cmux, circ); + + return (hashent != NULL); +} +

1 0

[tor/master] Eliminate linked list helper functions in relay.c which are no longer used
by andrea＠torproject.org 11 Oct '12

11 Oct '12

commit 35f5259df4feacbb77b14c6da30ec137a21763bb Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Sep 26 15:05:10 2012 -0700 Eliminate linked list helper functions in relay.c which are no longer used --- src/or/relay.c | 32 -------------------------------- 1 files changed, 0 insertions(+), 32 deletions(-) diff --git a/src/or/relay.c b/src/or/relay.c index f079243..e3b383b 100644 --- a/src/or/relay.c +++ b/src/or/relay.c @@ -1972,38 +1972,6 @@ cell_queue_pop(cell_queue_t *queue) return cell; } -/** Return a pointer to the "next_active_on_{n,p}_chan" pointer of circ, - * depending on whether chan matches n_chan or p_chan. */ -static INLINE circuit_t ** -next_circ_on_chan_p(circuit_t *circ, channel_t *chan) -{ - tor_assert(circ); - 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(chan == orcirc->p_chan); - return &orcirc->next_active_on_p_chan; - } -} - -/** Return a pointer to the "prev_active_on_{n,p}_chan" pointer of circ, - * depending on whether chan matches n_chan or p_chan. */ -static INLINE circuit_t ** -prev_circ_on_chan_p(circuit_t *circ, channel_t *chan) -{ - tor_assert(circ); - 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(chan == orcirc->p_chan); - return &orcirc->prev_active_on_p_chan; - } -} - #if 0 /** Helper for sorting cell_ewma_t values in their priority queue. */ static int

1 0

[tor/master] Implement circuitmux_detach_all_circuits() in circuitmux.c
by andrea＠torproject.org 11 Oct '12

11 Oct '12

commit fd31dd440c8feb31dc7b4e0641bd78d36a65e4e3 Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Sep 26 13:38:32 2012 -0700 Implement circuitmux_detach_all_circuits() in circuitmux.c --- src/or/circuitmux.c | 69 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 69 insertions(+), 0 deletions(-) diff --git a/src/or/circuitmux.c b/src/or/circuitmux.c index c640294..61fd30d 100644 --- a/src/or/circuitmux.c +++ b/src/or/circuitmux.c @@ -8,6 +8,7 @@ #include "or.h" #include "channel.h" +#include "circuitlist.h" #include "circuitmux.h" /* @@ -198,6 +199,74 @@ circuitmux_alloc(void) } /** + * Detach all circuits from a circuitmux (use before circuitmux_free()) + */ + +void +circuitmux_detach_all_circuits(circuitmux_t *cmux) +{ + chanid_circid_muxinfo_t **i = NULL, *to_remove; + channel_t *chan = NULL; + circuit_t *circ = NULL; + + tor_assert(cmux); + + i = HT_START(chanid_circid_muxinfo_map, cmux->chanid_circid_map); + while (i) { + to_remove = *i; + i = HT_NEXT_RMV(chanid_circid_muxinfo_map, cmux->chanid_circid_map, i); + if (to_remove) { + /* Find a channel and circuit */ + chan = channel_find_by_global_id(to_remove->chan_id); + if (chan) { + circ = circuit_get_by_circid_channel(to_remove->circ_id, chan); + if (circ) { + /* Clear the circuit's mux for this direction */ + if (to_remove->muxinfo.direction == CELL_DIRECTION_OUT) { + /* Clear n_mux */ + circ->n_mux = NULL; + } else if (circ->magic == OR_CIRCUIT_MAGIC) { + /* + * It has a sensible p_chan and direction == CELL_DIRECTION_IN, + * so clear p_mux. + */ + TO_OR_CIRCUIT(circ)->p_mux = NULL; + } else { + /* Complain and move on */ + log_warn(LD_CIRC, + "Circuit %d/channel " U64_FORMAT " had direction == " + "CELL_DIRECTION_IN, but isn't an or_circuit_t", + to_remove->circ_id, + U64_PRINTF_ARG(to_remove->chan_id)); + } + + /* TODO update active_circuits / active_circuit_pqueue */ + } else { + /* Complain and move on */ + log_warn(LD_CIRC, + "Couldn't find circuit %d (for channel " U64_FORMAT ")", + to_remove->circ_id, + U64_PRINTF_ARG(to_remove->chan_id)); + } + } else { + /* Complain and move on */ + log_warn(LD_CIRC, + "Couldn't find channel " U64_FORMAT " (for circuit id %d)", + U64_PRINTF_ARG(to_remove->chan_id), + to_remove->circ_id); + } + + /* Free it */ + tor_free(to_remove); + } + } + + cmux->n_circuits = 0; + cmux->n_active_circuits = 0; + cmux->n_cells = 0; +} + +/** * Free a circuitmux_t; the circuits must be detached first with * circuitmux_detach_all_circuits(). */

1 0

[tor/master] Implement circuitmux_is_circuit_active(), circuitmux_num_cells_for_circuit(), circuitmux_num_cells(), circuitmux_num_active_circuits() and circuitmux_num_circuits() in circuitmux.c
by andrea＠torproject.org 11 Oct '12

11 Oct '12

commit 9da04141e23505074d6867e579fea130bbb00964 Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Sep 26 12:56:30 2012 -0700 Implement circuitmux_is_circuit_active(), circuitmux_num_cells_for_circuit(), circuitmux_num_cells(), circuitmux_num_active_circuits() and circuitmux_num_circuits() in circuitmux.c --- src/or/circuitmux.c | 85 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 85 insertions(+), 0 deletions(-) diff --git a/src/or/circuitmux.c b/src/or/circuitmux.c index f6cdbf1..c640294 100644 --- a/src/or/circuitmux.c +++ b/src/or/circuitmux.c @@ -315,6 +315,91 @@ circuitmux_is_circuit_attached(circuitmux_t *cmux, circuit_t *circ) return (hashent != NULL); } +/** + * Query whether a circuit is active on a circuitmux + */ + +int +circuitmux_is_circuit_active(circuitmux_t *cmux, circuit_t *circ) +{ + chanid_circid_muxinfo_t *hashent = NULL; + int is_active = 0; + + tor_assert(cmux); + tor_assert(circ); + + /* Look if it's in the circuit map */ + hashent = circuitmux_find_map_entry(cmux, circ); + if (hashent) { + /* Check the number of cells on this circuit */ + is_active = (hashent->muxinfo.cell_count > 0); + } + /* else not attached, so not active */ + + return is_active; +} + +/** + * Query number of available cells for a circuit on a circuitmux + */ + +unsigned int +circuitmux_num_cells_for_circuit(circuitmux_t *cmux, circuit_t *circ) +{ + chanid_circid_muxinfo_t *hashent = NULL; + unsigned int n_cells = 0; + + tor_assert(cmux); + tor_assert(circ); + + /* Look if it's in the circuit map */ + hashent = circuitmux_find_map_entry(cmux, circ); + if (hashent) { + /* Just get the cell count for this circuit */ + n_cells = hashent->muxinfo.cell_count; + } + /* else not attached, so 0 cells */ + + return n_cells; +} + + +/** + * Query total number of available cells on a circuitmux + */ + +unsigned int +circuitmux_num_cells(circuitmux_t *cmux) +{ + tor_assert(cmux); + + return cmux->n_cells; +} + +/** + * Query total number of circuits active on a circuitmux + */ + +unsigned int +circuitmux_num_active_circuits(circuitmux_t *cmux) +{ + tor_assert(cmux); + + return cmux->n_active_circuits; +} + +/** + * Query total number of circuits attached to a circuitmux + */ + +unsigned int +circuitmux_num_circuits(circuitmux_t *cmux) +{ + tor_assert(cmux); + + return cmux->n_circuits; +} + /* * Functions for circuit code to call to update circuit status */

1 0

[tor/master] Implement circuitmux_make_circuit_inactive(), circuitmux_make_circuit_active() and linked list helper functions in circuitmux.c
by andrea＠torproject.org 11 Oct '12

11 Oct '12

commit 38fa3b7e4489dafdb74ebef96f5a684c1f29eb1e Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Sep 26 15:04:29 2012 -0700 Implement circuitmux_make_circuit_inactive(), circuitmux_make_circuit_active() and linked list helper functions in circuitmux.c --- src/or/circuitmux.c | 239 ++++++++++++++++++++++++++++++++++++++++++++++++--- 1 files changed, 227 insertions(+), 12 deletions(-) diff --git a/src/or/circuitmux.c b/src/or/circuitmux.c index 61fd30d..77bb568 100644 --- a/src/or/circuitmux.c +++ b/src/or/circuitmux.c @@ -85,7 +85,7 @@ struct circuitmux_s { * free up on this connection's outbuf. Every time we pull cells from * a circuit, we advance this pointer to the next circuit in the ring. */ - struct circuit_t *active_circuits; + struct circuit_t *active_circuits_head, *active_circuits_tail; /* * Priority queue of cell_ewma_t for circuits with queued cells waiting @@ -140,10 +140,50 @@ static INLINE unsigned int chanid_circid_entry_hash(chanid_circid_muxinfo_t *a); static chanid_circid_muxinfo_t * circuitmux_find_map_entry(circuitmux_t *cmux, circuit_t *circ); +static void +circuitmux_make_circuit_active(circuitmux_t *cmux, circuit_t *circ, + cell_direction_t direction); +static void +circuitmux_make_circuit_inactive(circuitmux_t *cmux, circuit_t *circ, + cell_direction_t direction); +static INLINE circuit_t ** +circuitmux_next_active_circ_p(circuitmux_t *cmux, circuit_t *circ); +static INLINE circuit_t ** +circuitmux_prev_active_circ_p(circuitmux_t *cmux, circuit_t *circ); /* Function definitions */ /** + * Linked list helpers + */ + +static INLINE circuit_t ** +circuitmux_next_active_circ_p(circuitmux_t *cmux, circuit_t *circ) +{ + tor_assert(cmux); + tor_assert(circ); + + if (circ->n_mux == cmux) return &(circ->next_active_on_n_chan); + else { + tor_assert(TO_OR_CIRCUIT(circ)->p_mux == cmux); + return &(TO_OR_CIRCUIT(circ)->next_active_on_p_chan); + } +} + +static INLINE circuit_t ** +circuitmux_prev_active_circ_p(circuitmux_t *cmux, circuit_t *circ) +{ + tor_assert(cmux); + tor_assert(circ); + + if (circ->n_mux == cmux) return &(circ->prev_active_on_n_chan); + else { + tor_assert(TO_OR_CIRCUIT(circ)->p_mux == cmux); + return &(TO_OR_CIRCUIT(circ)->prev_active_on_p_chan); + } +} + +/** * Helper for chanid_circid_cell_count_map_t hash table: compare the channel * ID and circuit ID for a and b, and return less than, equal to, or greater * than zero appropriately. @@ -225,12 +265,16 @@ circuitmux_detach_all_circuits(circuitmux_t *cmux) if (to_remove->muxinfo.direction == CELL_DIRECTION_OUT) { /* Clear n_mux */ circ->n_mux = NULL; + /* Update active_circuits et al. */ + circuitmux_make_circuit_inactive(cmux, circ, CELL_DIRECTION_OUT); } else if (circ->magic == OR_CIRCUIT_MAGIC) { /* * It has a sensible p_chan and direction == CELL_DIRECTION_IN, * so clear p_mux. */ TO_OR_CIRCUIT(circ)->p_mux = NULL; + /* Update active_circuits et al. */ + circuitmux_make_circuit_inactive(cmux, circ, CELL_DIRECTION_IN); } else { /* Complain and move on */ log_warn(LD_CIRC, @@ -239,8 +283,6 @@ circuitmux_detach_all_circuits(circuitmux_t *cmux) to_remove->circ_id, U64_PRINTF_ARG(to_remove->chan_id)); } - - /* TODO update active_circuits / active_circuit_pqueue */ } else { /* Complain and move on */ log_warn(LD_CIRC, @@ -432,7 +474,6 @@ circuitmux_num_cells_for_circuit(circuitmux_t *cmux, circuit_t *circ) return n_cells; } - /** * Query total number of available cells on a circuitmux */ @@ -548,14 +589,14 @@ circuitmux_attach_circuit(circuitmux_t *cmux, circuit_t *circ, */ if (hashent->muxinfo.cell_count > 0 && cell_count == 0) { --(cmux->n_active_circuits); + circuitmux_make_circuit_inactive(cmux, circ, direction); } else if (hashent->muxinfo.cell_count == 0 && cell_count > 0) { ++(cmux->n_active_circuits); + circuitmux_make_circuit_active(cmux, circ, direction); } cmux->n_cells -= hashent->muxinfo.cell_count; cmux->n_cells += cell_count; hashent->muxinfo.cell_count = cell_count; - - /* TODO update active_circuits / active_circuit_pqueue */ } else { /* * New circuit; add an entry and update the circuit/active circuit @@ -601,8 +642,6 @@ circuitmux_attach_circuit(circuitmux_t *cmux, circuit_t *circ, circuitmux_make_circuit_active(cmux, circ, direction); } cmux->n_cells += cell_count; - - /* TODO update active_circuits / active_circuit_pqueue */ } } @@ -651,9 +690,11 @@ circuitmux_detach_circuit(circuitmux_t *cmux, circuit_t *circ) if (hashent) { /* Update counters */ --(cmux->n_circuits); - if (hashent->muxinfo.cell_count > 0) --(cmux->n_active_circuits); + if (hashent->muxinfo.cell_count > 0) { + --(cmux->n_active_circuits); + circuitmux_make_circuit_inactive(cmux, circ, last_searched_direction); + } cmux->n_cells -= hashent->muxinfo.cell_count; - /* TODO update active_circuits / active_circuit_pqueue */ /* Consistency check: the direction must match the direction searched */ tor_assert(last_searched_direction == hashent->muxinfo.direction); @@ -667,6 +708,180 @@ circuitmux_detach_circuit(circuitmux_t *cmux, circuit_t *circ) } /** + * Make a circuit active; update active list and policy-specific info, but + * we don't mess with the counters or hash table here. + */ + +static void +circuitmux_make_circuit_active(circuitmux_t *cmux, circuit_t *circ, + cell_direction_t direction) +{ + circuit_t **next_active = NULL, **prev_active = NULL, **next_prev = NULL; + circuitmux_t *circuit_cmux = NULL; + channel_t *chan = NULL; + circid_t circ_id; + int already_active; + + tor_assert(cmux); + tor_assert(circ); + tor_assert(direction == CELL_DIRECTION_OUT || + direction == CELL_DIRECTION_IN); + + /* Get the right set of active list links for this direction */ + if (direction == CELL_DIRECTION_OUT) { + next_active = &(circ->next_active_on_n_chan); + prev_active = &(circ->prev_active_on_n_chan); + circuit_cmux = circ->n_mux; + chan = circ->n_chan; + circ_id = circ->n_circ_id; + } else { + next_active = &(TO_OR_CIRCUIT(circ)->next_active_on_p_chan); + prev_active = &(TO_OR_CIRCUIT(circ)->prev_active_on_p_chan); + circuit_cmux = TO_OR_CIRCUIT(circ)->p_mux; + chan = TO_OR_CIRCUIT(circ)->p_chan; + circ_id = TO_OR_CIRCUIT(circ)->p_circ_id; + } + + /* Assert that it is attached to this mux and a channel */ + tor_assert(cmux == circuit_cmux); + tor_assert(chan != NULL); + + /* + * Check if the circuit really was inactive; if it's active, at least one + * of the next_active and prev_active pointers will not be NULL, or this + * circuit will be either the head or tail of the list for this cmux. + */ + already_active = (*prev_active != NULL || *next_active != NULL || + cmux->active_circuits_head == circ || + cmux->active_circuits_tail == circ); + + /* If we're already active, log a warning and finish */ + if (already_active) { + log_warn(LD_CIRC, + "Circuit %d on channel " U64_FORMAT " was already active", + circ_id, U64_PRINTF_ARG(chan->global_identifier)); + return; + } + + /* + * This is going at the head of the list; if the old head is not NULL, + * then its prev pointer should point to this. + */ + *next_active = cmux->active_circuits_head; /* Next is old head */ + *prev_active = NULL; /* Prev is NULL (this will be the head) */ + if (cmux->active_circuits_head) { + /* The list had an old head; update its prev pointer */ + next_prev = + circuitmux_prev_active_circ_p(cmux, cmux->active_circuits_head); + tor_assert(next_prev); + *next_prev = circ; + } else { + /* The list was empty; this becomes the tail as well */ + cmux->active_circuits_tail = circ; + } + /* This becomes the new head of the list */ + cmux->active_circuits_head = circ; + + /* TODO policy-specific notifications */ +} + +/** + * Make a circuit inactive; update active list and policy-specific info, but + * we don't mess with the counters or hash table here. + */ + +static void +circuitmux_make_circuit_inactive(circuitmux_t *cmux, circuit_t *circ, + cell_direction_t direction) +{ + circuit_t **next_active = NULL, **prev_active = NULL; + circuit_t **next_prev = NULL, **prev_next = NULL; + circuitmux_t *circuit_cmux = NULL; + channel_t *chan = NULL; + circid_t circ_id; + int already_inactive; + + tor_assert(cmux); + tor_assert(circ); + tor_assert(direction == CELL_DIRECTION_OUT || + direction == CELL_DIRECTION_IN); + + /* Get the right set of active list links for this direction */ + if (direction == CELL_DIRECTION_OUT) { + next_active = &(circ->next_active_on_n_chan); + prev_active = &(circ->prev_active_on_n_chan); + circuit_cmux = circ->n_mux; + chan = circ->n_chan; + circ_id = circ->n_circ_id; + } else { + next_active = &(TO_OR_CIRCUIT(circ)->next_active_on_p_chan); + prev_active = &(TO_OR_CIRCUIT(circ)->prev_active_on_p_chan); + circuit_cmux = TO_OR_CIRCUIT(circ)->p_mux; + chan = TO_OR_CIRCUIT(circ)->p_chan; + circ_id = TO_OR_CIRCUIT(circ)->p_circ_id; + } + + /* Assert that it is attached to this mux and a channel */ + tor_assert(cmux == circuit_cmux); + tor_assert(chan != NULL); + + /* + * Check if the circuit really was active; if it's inactive, the + * next_active and prev_active pointers will be NULL and this circuit + * will not be the head or tail of the list for this cmux. + */ + already_inactive = (*prev_active == NULL && *next_active == NULL && + cmux->active_circuits_head != circ && + cmux->active_circuits_tail != circ); + + /* If we're already inactive, log a warning and finish */ + if (already_inactive) { + log_warn(LD_CIRC, + "Circuit %d on channel " U64_FORMAT " was already inactive", + circ_id, U64_PRINTF_ARG(chan->global_identifier)); + return; + } + + /* Remove from the list; first get next_prev and prev_next */ + if (*next_active) { + /* + * If there's a next circuit, its previous circuit becomes this + * circuit's previous circuit. + */ + next_prev = circuitmux_prev_active_circ_p(cmux, *next_active); + } else { + /* Else, the tail becomes this circuit's previous circuit */ + next_prev = &(cmux->active_circuits_tail); + } + + /* Got next_prev, now prev_next */ + if (*prev_active) { + /* + * If there's a previous circuit, its next circuit becomes this circuit's + * next circuit. + */ + prev_next = circuitmux_next_active_circ_p(cmux, *prev_active); + } else { + /* Else, the head becomes this circuit's next circuit */ + prev_next = &(cmux->active_circuits_head); + } + + /* Assert that we got sensible values for the next/prev pointers */ + tor_assert(next_prev != NULL); + tor_assert(prev_next != NULL); + + /* Update the next/prev pointers - this removes circ from the list */ + *next_prev = *prev_active; + *prev_next = *next_active; + + /* Now null out prev_active/next_active */ + *prev_active = NULL; + *next_active = NULL; + + /* TODO policy-specific notifications */ +} + +/** * Clear the cell counter for a circuit on a circuitmux */ @@ -705,11 +920,11 @@ circuitmux_set_num_cells(circuitmux_t *cmux, circuit_t *circ, */ if (hashent->muxinfo.cell_count > 0 && n_cells == 0) { --(cmux->n_active_circuits); - /* TODO update active_circuits / active_circuit_pqueue */ + circuitmux_make_circuit_inactive(cmux, circ, hashent->muxinfo.direction); /* Is the old cell count == 0 and the new cell count > 0 ? */ } else if (hashent->muxinfo.cell_count == 0 && n_cells > 0) { ++(cmux->n_active_circuits); - /* TODO update active_circuits / active_circuit_pqueue */ + circuitmux_make_circuit_active(cmux, circ, hashent->muxinfo.direction); } /* Update hash entry cell counter */

1 0

[tor/master] Allocate and free circuit-specific policy data in the right places
by andrea＠torproject.org 11 Oct '12

11 Oct '12

commit 930e3d611a7983dc0d5558b21b79e81f72cb7158 Author: Andrea Shepard <andrea(a)torproject.org> Date: Thu Sep 27 12:00:21 2012 -0700 Allocate and free circuit-specific policy data in the right places --- src/or/circuitmux.c | 58 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 56 insertions(+), 2 deletions(-) diff --git a/src/or/circuitmux.c b/src/or/circuitmux.c index 860ba64..5a5739f 100644 --- a/src/or/circuitmux.c +++ b/src/or/circuitmux.c @@ -260,7 +260,10 @@ circuitmux_detach_all_circuits(circuitmux_t *cmux) if (to_remove->muxinfo.direction == CELL_DIRECTION_OUT) { /* Clear n_mux */ circ->n_mux = NULL; - /* Update active_circuits et al. */ + /* + * Update active_circuits et al.; this does policy notifies, so + * comes before freeing policy data + */ circuitmux_make_circuit_inactive(cmux, circ, CELL_DIRECTION_OUT); } else if (circ->magic == OR_CIRCUIT_MAGIC) { /* @@ -268,7 +271,10 @@ circuitmux_detach_all_circuits(circuitmux_t *cmux) * so clear p_mux. */ TO_OR_CIRCUIT(circ)->p_mux = NULL; - /* Update active_circuits et al. */ + /* + * Update active_circuits et al.; this does policy notifies, so + * comes before freeing policy data + */ circuitmux_make_circuit_inactive(cmux, circ, CELL_DIRECTION_IN); } else { /* Complain and move on */ @@ -278,6 +284,24 @@ circuitmux_detach_all_circuits(circuitmux_t *cmux) to_remove->circ_id, U64_PRINTF_ARG(to_remove->chan_id)); } + + + /* Free policy-specific data if we have it */ + if (to_remove->muxinfo.policy_data) { + /* + * If we have policy data, assert that we have the means to + * free it + */ + tor_assert(cmux->policy); + tor_assert(cmux->policy_data); + tor_assert(cmux->policy->free_circ_data); + /* Call free_circ_data() */ + cmux->policy->free_circ_data(cmux, + cmux->policy_data, + circ, + to_remove->muxinfo.policy_data); + to_remove->muxinfo.policy_data = NULL; + } } else { /* Complain and move on */ log_warn(LD_CIRC, @@ -293,6 +317,9 @@ circuitmux_detach_all_circuits(circuitmux_t *cmux) to_remove->circ_id); } + /* Assert that we don't have un-freed policy data for this circuit */ + tor_assert(to_remove->muxinfo.policy_data == NULL); + /* Free it */ tor_free(to_remove); } @@ -620,6 +647,18 @@ circuitmux_attach_circuit(circuitmux_t *cmux, circuit_t *circ, hashent->circ_id = circ_id; hashent->muxinfo.cell_count = cell_count; hashent->muxinfo.direction = direction; + /* Allocate policy specific circuit data if we need it */ + if (cmux->policy && cmux->policy_data && + cmux->policy->alloc_circ_data) { + hashent->muxinfo.policy_data = + cmux->policy->alloc_circ_data(cmux, + cmux->policy_data, + circ, + direction, + cell_count); + /* If we wanted policy data, it's an error not to get any */ + tor_assert(hashent->muxinfo.policy_data); + } HT_INSERT(chanid_circid_muxinfo_map, cmux->chanid_circid_map, hashent); @@ -693,10 +732,25 @@ circuitmux_detach_circuit(circuitmux_t *cmux, circuit_t *circ) --(cmux->n_circuits); if (hashent->muxinfo.cell_count > 0) { --(cmux->n_active_circuits); + /* This does policy notifies, so comes before freeing policy data */ circuitmux_make_circuit_inactive(cmux, circ, last_searched_direction); } cmux->n_cells -= hashent->muxinfo.cell_count; + /* Free policy-specific data if we have it */ + if (hashent->muxinfo.policy_data) { + /* If we have policy data, assert that we have the means to free it */ + tor_assert(cmux->policy); + tor_assert(cmux->policy_data); + tor_assert(cmux->policy->free_circ_data); + /* Call free_circ_data() */ + cmux->policy->free_circ_data(cmux, + cmux->policy_data, + circ, + hashent->muxinfo.policy_data); + hashent->muxinfo.policy_data = NULL; + } + /* Consistency check: the direction must match the direction searched */ tor_assert(last_searched_direction == hashent->muxinfo.direction); /* Clear the circuit's mux for this direction */

1 0