November 2014 - tor-commits - lists.torproject.org

[tor/master] Add channel/incoming unit test
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 76fcb8cb55d91aa66699266b00ff5379e3c99461 Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Jan 22 00:06:06 2014 -0800 Add channel/incoming unit test --- src/test/test_channel.c | 123 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 123 insertions(+) diff --git a/src/test/test_channel.c b/src/test/test_channel.c index add57de..18746df 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -24,6 +24,8 @@ extern uint64_t estimated_total_queue_size; static int test_chan_accept_cells = 0; +static int test_chan_fixed_cells_recved = 0; +static int test_chan_var_cells_recved = 0; static int test_cells_written = 0; static int test_destroy_not_pending_calls = 0; static int test_doesnt_want_writes_count = 0; @@ -33,6 +35,10 @@ static int test_releases_count = 0; static void channel_note_destroy_not_pending_mock(channel_t *ch, circid_t circid); +static void chan_test_cell_handler(channel_t *ch, + cell_t *cell); +static void chan_test_var_cell_handler(channel_t *ch, + var_cell_t *var_cell); static void chan_test_close(channel_t *ch); static void chan_test_error(channel_t *ch); static void chan_test_finish_close(channel_t *ch); @@ -45,6 +51,7 @@ static int chan_test_write_var_cell(channel_t *ch, var_cell_t *var_cell); static void scheduler_channel_doesnt_want_writes_mock(channel_t *ch); static void test_channel_flush(void *arg); +static void test_channel_incoming(void *arg); static void test_channel_lifecycle(void *arg); static void test_channel_multi(void *arg); static void test_channel_queue_size(void *arg); @@ -60,6 +67,42 @@ channel_note_destroy_not_pending_mock(channel_t *ch, ++test_destroy_not_pending_calls; } +/* + * Handle an incoming fixed-size cell for unit tests + */ + +static void +chan_test_cell_handler(channel_t *ch, + cell_t *cell) +{ + test_assert(ch); + test_assert(cell); + + tor_free(cell); + ++test_chan_fixed_cells_recved; + + done: + return; +} + +/* + * Handle an incoming variable-size cell for unit tests + */ + +static void +chan_test_var_cell_handler(channel_t *ch, + var_cell_t *var_cell) +{ + test_assert(ch); + test_assert(var_cell); + + tor_free(var_cell); + ++test_chan_var_cells_recved; + + done: + return; +} + static void chan_test_close(channel_t *ch) { @@ -368,6 +411,85 @@ test_channel_flush(void *arg) return; } +static void +test_channel_incoming(void *arg) +{ + channel_t *ch = NULL; + cell_t *cell = NULL; + var_cell_t *var_cell = NULL; + int old_count; + + (void)arg; + + /* Mock these for duration of the test */ + MOCK(scheduler_channel_doesnt_want_writes, + scheduler_channel_doesnt_want_writes_mock); + MOCK(scheduler_release_channel, + scheduler_release_channel_mock); + + /* Accept cells to lower layer */ + test_chan_accept_cells = 1; + /* Use default overhead factor */ + test_overhead_estimate = 1.0f; + + ch = new_fake_channel(); + test_assert(ch); + /* Start it off in OPENING */ + ch->state = CHANNEL_STATE_OPENING; + /* We'll need a cmux */ + ch->cmux = circuitmux_alloc(); + + /* Install incoming cell handlers */ + channel_set_cell_handlers(ch, + chan_test_cell_handler, + chan_test_var_cell_handler); + /* Test cell handler getters */ + test_eq(channel_get_cell_handler(ch), chan_test_cell_handler); + test_eq(channel_get_var_cell_handler(ch), chan_test_var_cell_handler); + + /* Try to register it */ + channel_register(ch); + test_assert(ch->registered); + + /* Open it */ + channel_change_state(ch, CHANNEL_STATE_OPEN); + test_eq(ch->state, CHANNEL_STATE_OPEN); + + /* Receive a fixed cell */ + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + old_count = test_chan_fixed_cells_recved; + channel_queue_cell(ch, cell); + cell = NULL; + test_eq(test_chan_fixed_cells_recved, old_count + 1); + + /* Receive a variable-size cell */ + var_cell = tor_malloc_zero(sizeof(var_cell_t) + CELL_PAYLOAD_SIZE); + make_fake_var_cell(var_cell); + old_count = test_chan_var_cells_recved; + channel_queue_var_cell(ch, var_cell); + var_cell = NULL; + test_eq(test_chan_var_cells_recved, old_count + 1); + + /* Close it */ + channel_mark_for_close(ch); + test_eq(ch->state, CHANNEL_STATE_CLOSING); + chan_test_finish_close(ch); + test_eq(ch->state, CHANNEL_STATE_CLOSED); + channel_run_cleanup(); + ch = NULL; + + done: + tor_free(ch); + tor_free(cell); + tor_free(var_cell); + + UNMOCK(scheduler_channel_doesnt_want_writes); + UNMOCK(scheduler_release_channel); + + return; +} + /** * Normal channel lifecycle test: * @@ -1169,6 +1291,7 @@ test_channel_write(void *arg) struct testcase_t channel_tests[] = { { "flush", test_channel_flush, TT_FORK, NULL, NULL }, + { "incoming", test_channel_incoming, TT_FORK, NULL, NULL }, { "lifecycle", test_channel_lifecycle, TT_FORK, NULL, NULL }, { "lifecycle_2", test_channel_lifecycle_2, TT_FORK, NULL, NULL }, { "multi", test_channel_multi, TT_FORK, NULL, NULL },

1 0

[tor/master] Expose some channel cell queue stuff to the test suite
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit bbb06b73cd46d8e603b9a5b99f2cdd28e31888eb Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Jan 21 20:51:21 2014 -0800 Expose some channel cell queue stuff to the test suite --- src/or/channel.c | 32 +++++--------------------------- src/or/channel.h | 28 ++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 27 deletions(-) diff --git a/src/or/channel.c b/src/or/channel.c index 9e3e452..76ade4f 100644 --- a/src/or/channel.c +++ b/src/or/channel.c @@ -13,6 +13,9 @@ #define TOR_CHANNEL_INTERNAL_ +/* This one's for stuff only channel.c and the test suite should see */ +#define CHANNEL_PRIVATE_ + #include "or.h" #include "channel.h" #include "channeltls.h" @@ -31,29 +34,6 @@ #include "routerlist.h" #include "scheduler.h" -/* Cell queue structure */ - -typedef struct cell_queue_entry_s cell_queue_entry_t; -struct cell_queue_entry_s { - TOR_SIMPLEQ_ENTRY(cell_queue_entry_s) next; - enum { - CELL_QUEUE_FIXED, - CELL_QUEUE_VAR, - CELL_QUEUE_PACKED - } type; - union { - struct { - cell_t *cell; - } fixed; - struct { - var_cell_t *var_cell; - } var; - struct { - packed_cell_t *packed_cell; - } packed; - } u; -}; - /* Global lists of channels */ /* All channel_t instances */ @@ -175,7 +155,6 @@ static cell_queue_entry_t * cell_queue_entry_new_fixed(cell_t *cell); static cell_queue_entry_t * cell_queue_entry_new_var(var_cell_t *var_cell); -static int chan_cell_queue_len(const chan_cell_queue_t *queue); static int is_destroy_cell(channel_t *chan, const cell_queue_entry_t *q, circid_t *circid_out); @@ -1751,9 +1730,8 @@ channel_get_cell_queue_entry_size(channel_t *chan, cell_queue_entry_t *q) rv = get_cell_network_size(chan->wide_circ_ids); break; case CELL_QUEUE_VAR: - tor_assert(q->u.var.var_cell); rv = get_var_cell_header_size(chan->wide_circ_ids) + - q->u.var.var_cell->payload_len; + (q->u.var.var_cell ? q->u.var.var_cell->payload_len : 0); break; case CELL_QUEUE_PACKED: rv = get_cell_network_size(chan->wide_circ_ids); @@ -3455,7 +3433,7 @@ channel_listener_describe_transport(channel_listener_t *chan_l) /** * Return the number of entries in <b>queue</b> */ -static int +STATIC int chan_cell_queue_len(const chan_cell_queue_t *queue) { int r = 0; diff --git a/src/or/channel.h b/src/or/channel.h index 023c39d..ba6d66b 100644 --- a/src/or/channel.h +++ b/src/or/channel.h @@ -354,6 +354,34 @@ void channel_set_cmux_policy_everywhere(circuitmux_policy_t *pol); #ifdef TOR_CHANNEL_INTERNAL_ +#ifdef CHANNEL_PRIVATE_ +/* Cell queue structure (here rather than channel.c for test suite use) */ + +typedef struct cell_queue_entry_s cell_queue_entry_t; +struct cell_queue_entry_s { + TOR_SIMPLEQ_ENTRY(cell_queue_entry_s) next; + enum { + CELL_QUEUE_FIXED, + CELL_QUEUE_VAR, + CELL_QUEUE_PACKED + } type; + union { + struct { + cell_t *cell; + } fixed; + struct { + var_cell_t *var_cell; + } var; + struct { + packed_cell_t *packed_cell; + } packed; + } u; +}; + +/* Cell queue functions for benefit of test suite */ +STATIC int chan_cell_queue_len(const chan_cell_queue_t *queue); +#endif + /* Channel operations for subclasses and internal use only */ /* Initialize a newly allocated channel - do this first in subclass

1 0

[tor/master] Small channel unit test improvements
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit f7951d318a29e8f9af5af080160902b62ee278b7 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Jan 21 22:33:04 2014 -0800 Small channel unit test improvements --- src/test/test_channel.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/test/test_channel.c b/src/test/test_channel.c index 9cc709d..2f07413 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -20,6 +20,9 @@ #include "test.h" #include "fakechans.h" +/* This comes from channel.c */ +extern uint64_t estimated_total_queue_size; + static int test_chan_accept_cells = 0; static int test_cells_written = 0; static int test_destroy_not_pending_calls = 0; @@ -400,6 +403,8 @@ test_channel_lifecycle(void *arg) test_assert(ch1); /* Start it off in OPENING */ ch1->state = CHANNEL_STATE_OPENING; + /* We'll need a cmux */ + ch1->cmux = circuitmux_alloc(); /* Try to register it */ channel_register(ch1); @@ -422,6 +427,7 @@ test_channel_lifecycle(void *arg) ch2 = new_fake_channel(); test_assert(ch2); ch2->state = CHANNEL_STATE_OPENING; + ch2->cmux = circuitmux_alloc(); /* Register */ channel_register(ch2); @@ -784,6 +790,10 @@ test_channel_queue_impossible(void *arg) var_cell_t *var_cell = NULL; int old_count; cell_queue_entry_t *q = NULL; + uint64_t global_queue_estimate; + + /* Cache the global queue size (see below) */ + global_queue_estimate = channel_get_global_queue_estimate(); (void)arg; @@ -890,6 +900,13 @@ test_channel_queue_impossible(void *arg) tor_free(ch); free_cell_pool(); + /* + * Doing that meant that we couldn't correctly adjust the queue size + * for the var cell, so manually reset the global queue size estimate + * so the next test doesn't break if we run with --no-fork. + */ + estimated_total_queue_size = global_queue_estimate; + return; }

1 0

[tor/master] Check some can't-happen cases draining channel cell queues
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit b6d0aaec07e1251af3735f4d5ec8250c4f9ce470 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Jan 21 20:51:50 2014 -0800 Check some can't-happen cases draining channel cell queues --- src/test/test_channel.c | 125 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 125 insertions(+) diff --git a/src/test/test_channel.c b/src/test/test_channel.c index eff4189..8c0b063 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -2,6 +2,7 @@ /* See LICENSE for licensing information */ #define TOR_CHANNEL_INTERNAL_ +#define CHANNEL_PRIVATE_ #include "or.h" #include "channel.h" /* For channel_note_destroy_not_pending */ @@ -566,6 +567,129 @@ test_channel_multi(void *arg) return; } +/** + * Check some hopefully-impossible edge cases in the channel queue we + * can only trigger by doing evil things to the queue directly. + */ + +static void +test_channel_queue_impossible(void *arg) +{ + channel_t *ch = NULL; + cell_t *cell = NULL; + packed_cell_t *packed_cell = NULL; + var_cell_t *var_cell = NULL; + int old_count; + cell_queue_entry_t *q = NULL; + + (void)arg; + + init_cell_pool(); + + packed_cell = packed_cell_new(); + test_assert(packed_cell); + + ch = new_fake_channel(); + test_assert(ch); + + /* We test queueing here; tell it not to accept cells */ + test_chan_accept_cells = 0; + /* ...and keep it from trying to flush the queue */ + ch->state = CHANNEL_STATE_MAINT; + + /* Cache the cell written count */ + old_count = test_cells_written; + + /* Assert that the queue is initially empty */ + test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 0); + + /* Get a fresh cell and write it to the channel*/ + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + channel_write_cell(ch, cell); + + /* Now it should be queued */ + test_eq(chan_cell_queue_len(&(ch->outgoing_queue)),1); + q = TOR_SIMPLEQ_FIRST(&(ch->outgoing_queue)); + test_assert(q); + if (q) { + test_eq(q->type, CELL_QUEUE_FIXED); + test_eq(q->u.fixed.cell, cell); + } + /* Do perverse things to it */ + tor_free(q->u.fixed.cell); + q->u.fixed.cell = NULL; + + /* + * Now change back to open with channel_change_state() and assert that it + * gets thrown away properly. + */ + test_chan_accept_cells = 1; + channel_change_state(ch, CHANNEL_STATE_OPEN); + test_assert(test_cells_written == old_count); + test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 0); + + /* Same thing but for a var_cell */ + + test_chan_accept_cells = 0; + ch->state = CHANNEL_STATE_MAINT; + var_cell = tor_malloc_zero(sizeof(var_cell_t) + CELL_PAYLOAD_SIZE); + make_fake_var_cell(var_cell); + channel_write_var_cell(ch, var_cell); + + /* Check that it's queued */ + test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 1); + q = TOR_SIMPLEQ_FIRST(&(ch->outgoing_queue)); + test_assert(q); + if (q) { + test_eq(q->type, CELL_QUEUE_VAR); + test_eq(q->u.var.var_cell, var_cell); + } + + /* Remove the cell from the queue entry */ + tor_free(q->u.var.var_cell); + q->u.var.var_cell = NULL; + + /* Let it drain and check that the bad entry is discarded */ + test_chan_accept_cells = 1; + channel_change_state(ch, CHANNEL_STATE_OPEN); + test_assert(test_cells_written == old_count); + test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 0); + + /* Same thing with a packed_cell */ + + test_chan_accept_cells = 0; + ch->state = CHANNEL_STATE_MAINT; + packed_cell = packed_cell_new(); + test_assert(packed_cell); + channel_write_packed_cell(ch, packed_cell); + + /* Check that it's queued */ + test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 1); + q = TOR_SIMPLEQ_FIRST(&(ch->outgoing_queue)); + test_assert(q); + if (q) { + test_eq(q->type, CELL_QUEUE_PACKED); + test_eq(q->u.packed.packed_cell, packed_cell); + } + + /* Remove the cell from the queue entry */ + packed_cell_free(q->u.packed.packed_cell); + q->u.packed.packed_cell = NULL; + + /* Let it drain and check that the bad entry is discarded */ + test_chan_accept_cells = 1; + channel_change_state(ch, CHANNEL_STATE_OPEN); + test_assert(test_cells_written == old_count); + test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 0); + + done: + tor_free(ch); + free_cell_pool(); + + return; +} + static void test_channel_queue_size(void *arg) { @@ -801,6 +925,7 @@ struct testcase_t channel_tests[] = { { "flush", test_channel_flush, TT_FORK, NULL, NULL }, { "lifecycle", test_channel_lifecycle, TT_FORK, NULL, NULL }, { "multi", test_channel_multi, TT_FORK, NULL, NULL }, + { "queue_impossible", test_channel_queue_impossible, TT_FORK, NULL, NULL }, { "queue_size", test_channel_queue_size, TT_FORK, NULL, NULL }, { "write", test_channel_write, TT_FORK, NULL, NULL }, END_OF_TESTCASES

1 0

[tor/master] Add append_cell_to_circuit_queue() unit test
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 5992a69deee324fb91f5f2995e145edd2c0560d2 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Jan 21 02:54:35 2014 -0800 Add append_cell_to_circuit_queue() unit test --- src/test/Makefile.nmake | 4 +- src/test/include.am | 1 + src/test/test.c | 2 + src/test/test_relay.c | 130 +++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 135 insertions(+), 2 deletions(-) diff --git a/src/test/Makefile.nmake b/src/test/Makefile.nmake index fceef99..2a347bd 100644 --- a/src/test/Makefile.nmake +++ b/src/test/Makefile.nmake @@ -14,8 +14,8 @@ LIBS = ..\..\..\build-alpha\lib\libevent.lib \ TEST_OBJECTS = test.obj test_addr.obj test_channel.obj test_containers.obj \ test_controller_events.ogj test_crypto.obj test_data.obj test_dir.obj \ test_microdesc.obj test_pt.obj test_util.obj test_config.obj \ - test_cell_formats.obj test_replay.obj test_introduce.obj tinytest.obj \ - test_hs.obj + test_cell_formats.obj test_relay.obj test_replay.obj \ + test_introduce.obj tinytest.obj test_hs.obj tinytest.obj: ..\ext\tinytest.c $(CC) $(CFLAGS) /D snprintf=_snprintf /c ..\ext\tinytest.c diff --git a/src/test/include.am b/src/test/include.am index 547f23b..531b81e 100644 --- a/src/test/include.am +++ b/src/test/include.am @@ -38,6 +38,7 @@ src_test_test_SOURCES = \ src/test/test_options.c \ src/test/test_pt.c \ src/test/test_relaycell.c \ + src/test/test_relay.c \ src/test/test_replay.c \ src/test/test_routerkeys.c \ src/test/test_socks.c \ diff --git a/src/test/test.c b/src/test/test.c index 4d4f6f2..7ade83d 100644 --- a/src/test/test.c +++ b/src/test/test.c @@ -1310,6 +1310,7 @@ extern struct testcase_t status_tests[]; extern struct testcase_t routerset_tests[]; extern struct testcase_t router_tests[]; extern struct testcase_t channel_tests[]; +extern struct testcase_t relay_tests[]; static struct testgroup_t testgroups[] = { { "", test_array }, @@ -1343,6 +1344,7 @@ static struct testgroup_t testgroups[] = { { "status/" , status_tests }, { "routerset/" , routerset_tests }, { "channel/", channel_tests }, + { "relay/" , relay_tests }, END_OF_GROUPS }; diff --git a/src/test/test_relay.c b/src/test/test_relay.c new file mode 100644 index 0000000..6b9cb33 --- /dev/null +++ b/src/test/test_relay.c @@ -0,0 +1,130 @@ +/* Copyright (c) 2014, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +#include "or.h" +#define CIRCUITBUILD_PRIVATE +#include "circuitbuild.h" +#define RELAY_PRIVATE +#include "relay.h" +/* For init/free stuff */ +#include "scheduler.h" + +/* Test suite stuff */ +#include "test.h" +#include "fakechans.h" + +static or_circuit_t * new_fake_orcirc(channel_t *nchan, channel_t *pchan); + +static void test_relay_append_cell_to_circuit_queue(void *arg); + +static or_circuit_t * +new_fake_orcirc(channel_t *nchan, channel_t *pchan) +{ + or_circuit_t *orcirc = NULL; + circuit_t *circ = NULL; + + orcirc = tor_malloc_zero(sizeof(*orcirc)); + circ = &(orcirc->base_); + circ->magic = OR_CIRCUIT_MAGIC; + + circ->n_chan = nchan; + circ->n_circ_id = get_unique_circ_id_by_chan(nchan); + circ->n_mux = NULL; /* ?? */ + cell_queue_init(&(circ->n_chan_cells)); + circ->n_hop = NULL; + circ->streams_blocked_on_n_chan = 0; + circ->streams_blocked_on_p_chan = 0; + circ->n_delete_pending = 0; + circ->p_delete_pending = 0; + circ->received_destroy = 0; + circ->state = CIRCUIT_STATE_OPEN; + circ->purpose = CIRCUIT_PURPOSE_OR; + circ->package_window = CIRCWINDOW_START_MAX; + circ->deliver_window = CIRCWINDOW_START_MAX; + circ->n_chan_create_cell = NULL; + + orcirc->p_chan = pchan; + orcirc->p_circ_id = get_unique_circ_id_by_chan(pchan); + cell_queue_init(&(orcirc->p_chan_cells)); + + return orcirc; +} + +static void +test_relay_append_cell_to_circuit_queue(void *arg) +{ + channel_t *nchan = NULL, *pchan = NULL; + or_circuit_t *orcirc = NULL; + cell_t *cell = NULL; + int old_count, new_count; + + (void)arg; + + /* We'll need the cell pool for append_cell_to_circuit_queue() to work */ + init_cell_pool(); + + /* Make fake channels to be nchan and pchan for the circuit */ + nchan = new_fake_channel(); + test_assert(nchan); + + pchan = new_fake_channel(); + test_assert(pchan); + + /* We'll need chans with working cmuxes */ + nchan->cmux = circuitmux_alloc(); + pchan->cmux = circuitmux_alloc(); + + /* Make a fake orcirc */ + orcirc = new_fake_orcirc(nchan, pchan); + test_assert(orcirc); + + /* Make a cell */ + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + + MOCK(scheduler_channel_has_waiting_cells, + scheduler_channel_has_waiting_cells_mock); + + /* Append it */ + old_count = get_mock_scheduler_has_waiting_cells_count(); + append_cell_to_circuit_queue(TO_CIRCUIT(orcirc), nchan, cell, + CELL_DIRECTION_OUT, 0); + new_count = get_mock_scheduler_has_waiting_cells_count(); + test_eq(new_count, old_count + 1); + + /* Now try the reverse direction */ + old_count = get_mock_scheduler_has_waiting_cells_count(); + append_cell_to_circuit_queue(TO_CIRCUIT(orcirc), pchan, cell, + CELL_DIRECTION_IN, 0); + new_count = get_mock_scheduler_has_waiting_cells_count(); + test_eq(new_count, old_count + 1); + + UNMOCK(scheduler_channel_has_waiting_cells); + + /* Get rid of the fake channels */ + MOCK(scheduler_release_channel, scheduler_release_channel_mock); + channel_mark_for_close(nchan); + channel_mark_for_close(pchan); + UNMOCK(scheduler_release_channel); + + /* Shut down channels */ + channel_free_all(); + nchan = pchan = NULL; + + done: + tor_free(orcirc); + if (nchan && nchan->cmux) circuitmux_free(nchan->cmux); + tor_free(nchan); + if (pchan && pchan->cmux) circuitmux_free(pchan->cmux); + tor_free(pchan); + free_cell_pool(); + + return; +} + +struct testcase_t relay_tests[] = { + { "append_cell_to_circuit_queue", test_relay_append_cell_to_circuit_queue, + TT_FORK, NULL, NULL }, + END_OF_TESTCASES +}; +

1 0

[tor/master] Add unknown cell queue entry type case to channel/queue_impossible unit test
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit b5d4ef18e172c18dd169570b17dfb14a4a270ae1 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Jan 21 22:54:40 2014 -0800 Add unknown cell queue entry type case to channel/queue_impossible unit test --- src/test/test_channel.c | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/src/test/test_channel.c b/src/test/test_channel.c index 2f07413..add57de 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -896,6 +896,32 @@ test_channel_queue_impossible(void *arg) test_assert(test_cells_written == old_count); test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 0); + /* Unknown cell type case */ + test_chan_accept_cells = 0; + ch->state = CHANNEL_STATE_MAINT; + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + channel_write_cell(ch, cell); + + /* Check that it's queued */ + test_eq(chan_cell_queue_len(&(ch->outgoing_queue)),1); + q = TOR_SIMPLEQ_FIRST(&(ch->outgoing_queue)); + test_assert(q); + if (q) { + test_eq(q->type, CELL_QUEUE_FIXED); + test_eq(q->u.fixed.cell, cell); + } + /* Clobber it, including the queue entry type */ + tor_free(q->u.fixed.cell); + q->u.fixed.cell = NULL; + q->type = CELL_QUEUE_PACKED + 1; + + /* Let it drain and check that the bad entry is discarded */ + test_chan_accept_cells = 1; + channel_change_state(ch, CHANNEL_STATE_OPEN); + test_assert(test_cells_written == old_count); + test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 0); + done: tor_free(ch); free_cell_pool();

1 0

[tor/master] Add scheduler_channel_has_waiting_cells_mock() and some mock counter queries
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 46ff91b6ec90fc8ee9a84622f9dce91903686559 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Jan 21 02:50:33 2014 -0800 Add scheduler_channel_has_waiting_cells_mock() and some mock counter queries --- src/test/fakechans.h | 6 ++++++ src/test/test_channel.c | 40 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 46 insertions(+) diff --git a/src/test/fakechans.h b/src/test/fakechans.h index 99773e7..b129ab4 100644 --- a/src/test/fakechans.h +++ b/src/test/fakechans.h @@ -14,6 +14,12 @@ void make_fake_var_cell(var_cell_t *c); channel_t * new_fake_channel(void); /* Also exposes some a mock used by both test_channel.c and test_relay.c */ +void scheduler_channel_has_waiting_cells_mock(channel_t *ch); void scheduler_release_channel_mock(channel_t *ch); +/* Query some counters used by the exposed mocks */ +int get_mock_scheduler_has_waiting_cells_count(void); +int get_mock_scheduler_release_channel_count(void); + #endif /* !defined(TOR_FAKECHANS_H) */ + diff --git a/src/test/test_channel.c b/src/test/test_channel.c index 1ae9810..eff4189 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -22,6 +22,7 @@ static int test_chan_accept_cells = 0; static int test_cells_written = 0; static int test_destroy_not_pending_calls = 0; static int test_doesnt_want_writes_count = 0; +static int test_has_waiting_cells_count = 0; static double test_overhead_estimate = 1.0f; static int test_releases_count = 0; @@ -206,6 +207,31 @@ new_fake_channel(void) return chan; } +/** + * Counter query for scheduler_channel_has_waiting_cells_mock() + */ + +int +get_mock_scheduler_has_waiting_cells_count(void) +{ + return test_has_waiting_cells_count; +} + +/** + * Mock for scheduler_channel_has_waiting_cells() + */ + +void +scheduler_channel_has_waiting_cells_mock(channel_t *ch) +{ + (void)ch; + + /* Increment counter */ + ++test_has_waiting_cells_count; + + return; +} + static void scheduler_channel_doesnt_want_writes_mock(channel_t *ch) { @@ -217,6 +243,20 @@ scheduler_channel_doesnt_want_writes_mock(channel_t *ch) return; } +/** + * Counter query for scheduler_release_channel_mock() + */ + +int +get_mock_scheduler_release_channel_count(void) +{ + return test_releases_count; +} + +/** + * Mock for scheduler_release_channel() + */ + void scheduler_release_channel_mock(channel_t *ch) {

1 0

[tor/master] Let channel unit tests mess with global queue estimate
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit ae3ed185e495499516173d6c5dd51ea49a0aa9c1 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Jan 21 22:30:02 2014 -0800 Let channel unit tests mess with global queue estimate --- src/or/channel.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/or/channel.c b/src/or/channel.c index 76ade4f..18c236f 100644 --- a/src/or/channel.c +++ b/src/or/channel.c @@ -109,7 +109,7 @@ static uint64_t n_channel_bytes_in_queues = 0; * transmit overhead* */ -static uint64_t estimated_total_queue_size = 0; +STATIC uint64_t estimated_total_queue_size = 0; /* Digest->channel map *

1 0

[tor/master] Expose get_unique_circ_id_by_chan() to test suite
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 2ee69bd5d74842681aa3c90aae93b93fb0657269 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Jan 21 02:49:51 2014 -0800 Expose get_unique_circ_id_by_chan() to test suite --- src/or/circuitbuild.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/or/circuitbuild.c b/src/or/circuitbuild.c index edf7d28..7a23fba 100644 --- a/src/or/circuitbuild.c +++ b/src/or/circuitbuild.c @@ -14,6 +14,7 @@ #include "or.h" #include "channel.h" #include "circpathbias.h" +#define CIRCUITBUILD_PRIVATE #include "circuitbuild.h" #include "circuitlist.h" #include "circuitstats.h"

1 0

[tor/master] Add channel lifecycle test
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 37baef0687e4bef0cfadf927bfbc832a59de32f4 Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Dec 18 15:50:32 2013 -0800 Add channel lifecycle test --- src/test/test_channel.c | 114 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 114 insertions(+) diff --git a/src/test/test_channel.c b/src/test/test_channel.c index acbfca1..c47d292 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -18,7 +18,9 @@ static int test_chan_accept_cells = 0; static int test_cells_written = 0; static int test_destroy_not_pending_calls = 0; +static int test_doesnt_want_writes_count = 0; static double test_overhead_estimate = 1.0f; +static int test_releases_count = 0; static void channel_note_destroy_not_pending_mock(channel_t *ch, circid_t circid); @@ -32,8 +34,10 @@ static int chan_test_write_var_cell(channel_t *ch, var_cell_t *var_cell); static void make_fake_cell(cell_t *c); static void make_fake_var_cell(var_cell_t *c); static channel_t * new_fake_channel(void); +static void scheduler_channel_doesnt_want_writes_mock(channel_t *ch); static void scheduler_release_channel_mock(channel_t *ch); +static void test_channel_lifecycle(void *arg); static void test_channel_multi(void *arg); static void test_channel_queue_size(void *arg); static void test_channel_write(void *arg); @@ -191,6 +195,17 @@ new_fake_channel(void) } static void +scheduler_channel_doesnt_want_writes_mock(channel_t *ch) +{ + (void)ch; + + /* Increment counter */ + ++test_doesnt_want_writes_count; + + return; +} + +static void scheduler_release_channel_mock(channel_t *ch) { (void)ch; @@ -202,6 +217,104 @@ scheduler_release_channel_mock(channel_t *ch) } static void +test_channel_lifecycle(void *arg) +{ + channel_t *ch1 = NULL, *ch2 = NULL; + cell_t *cell = NULL; + int old_count, init_doesnt_want_writes_count; + int init_releases_count; + + (void)arg; + + /* Mock these for the whole lifecycle test */ + MOCK(scheduler_channel_doesnt_want_writes, + scheduler_channel_doesnt_want_writes_mock); + MOCK(scheduler_release_channel, + scheduler_release_channel_mock); + + /* Cache some initial counter values */ + init_doesnt_want_writes_count = test_doesnt_want_writes_count; + init_releases_count = test_releases_count; + + /* Accept cells to lower layer */ + test_chan_accept_cells = 1; + /* Use default overhead factor */ + test_overhead_estimate = 1.0f; + + ch1 = new_fake_channel(); + test_assert(ch1); + /* Start it off in OPENING */ + ch1->state = CHANNEL_STATE_OPENING; + + /* Try to register it */ + channel_register(ch1); + test_assert(ch1->registered); + + /* Try to write a cell through (should queue) */ + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + old_count = test_cells_written; + channel_write_cell(ch1, cell); + test_eq(old_count, test_cells_written); + + /* Move it to OPEN and flush */ + channel_change_state(ch1, CHANNEL_STATE_OPEN); + + /* Queue should drain */ + test_eq(old_count + 1, test_cells_written); + + /* Get another one */ + ch2 = new_fake_channel(); + test_assert(ch2); + ch2->state = CHANNEL_STATE_OPENING; + + /* Register */ + channel_register(ch2); + test_assert(ch2->registered); + + /* Check counters */ + test_eq(test_doesnt_want_writes_count, init_doesnt_want_writes_count); + test_eq(test_releases_count, init_releases_count); + + /* Move ch1 to MAINT */ + channel_change_state(ch1, CHANNEL_STATE_MAINT); + test_eq(test_doesnt_want_writes_count, init_doesnt_want_writes_count + 1); + test_eq(test_releases_count, init_releases_count); + + /* Move ch2 to OPEN */ + channel_change_state(ch2, CHANNEL_STATE_OPEN); + test_eq(test_doesnt_want_writes_count, init_doesnt_want_writes_count + 1); + test_eq(test_releases_count, init_releases_count); + + /* Move ch1 back to OPEN */ + channel_change_state(ch1, CHANNEL_STATE_OPEN); + test_eq(test_doesnt_want_writes_count, init_doesnt_want_writes_count + 1); + test_eq(test_releases_count, init_releases_count); + + /* Mark ch2 for close */ + channel_mark_for_close(ch2); + test_eq(ch2->state, CHANNEL_STATE_CLOSING); + test_eq(test_doesnt_want_writes_count, init_doesnt_want_writes_count + 1); + test_eq(test_releases_count, init_releases_count + 1); + + /* Shut down channels */ + channel_free_all(); + ch1 = ch2 = NULL; + test_eq(test_doesnt_want_writes_count, init_doesnt_want_writes_count + 1); + /* channel_free() calls scheduler_release_channel() */ + test_eq(test_releases_count, init_releases_count + 4); + + done: + tor_free(ch1); + tor_free(ch2); + + UNMOCK(scheduler_channel_doesnt_want_writes); + UNMOCK(scheduler_release_channel); + + return; +} + +static void test_channel_multi(void *arg) { channel_t *ch1 = NULL, *ch2 = NULL; @@ -563,6 +676,7 @@ test_channel_write(void *arg) } struct testcase_t channel_tests[] = { + { "lifecycle", test_channel_lifecycle, TT_FORK, NULL, NULL }, { "multi", test_channel_multi, TT_FORK, NULL, NULL }, { "queue_size", test_channel_queue_size, TT_FORK, NULL, NULL }, { "write", test_channel_write, TT_FORK, NULL, NULL },

1 0