tor-commits November 2014

tor-commits@lists.torproject.org

24 participants
954 discussions

[tor/master] What the hell was I on?
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 5a24ff0563ed916abffcde083019d23142197fdf Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Jan 22 02:50:40 2014 -0800 What the hell was I on? --- src/or/channel.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/or/channel.c b/src/or/channel.c index 18c236f..94cca5c 100644 --- a/src/or/channel.c +++ b/src/or/channel.c @@ -2263,7 +2263,8 @@ channel_flush_some_cells(channel_t *chan, ssize_t num_cells) /* Now process the queue if necessary */ - if (q_len_after > q_len_before && num_cells < flushed) { + if ((q_len_after > q_len_before) && + (unlimited || (flushed < num_cells))) { flushed += channel_flush_some_cells_from_outgoing_queue(chan, (unlimited ? -1 : num_cells - flushed)); }

1 0

[tor/master] Make is_local_addr() mockable
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 3bc7108d2cfb6795f1beb0f5dbb3ab66fe1601d3 Author: Andrea Shepard <andrea(a)torproject.org> Date: Thu Jan 23 04:52:59 2014 -0800 Make is_local_addr() mockable --- src/or/config.c | 4 ++-- src/or/config.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/or/config.c b/src/or/config.c index 4ae9fad..86d7c6e 100644 --- a/src/or/config.c +++ b/src/or/config.c @@ -2259,8 +2259,8 @@ resolve_my_address(int warn_severity, const or_options_t *options, /** Return true iff <b>addr</b> is judged to be on the same network as us, or * on a private network. */ -int -is_local_addr(const tor_addr_t *addr) +MOCK_IMPL(int, +is_local_addr, (const tor_addr_t *addr)) { if (tor_addr_is_internal(addr, 0)) return 1; diff --git a/src/or/config.h b/src/or/config.h index 8a1919c..bf176a6 100644 --- a/src/or/config.h +++ b/src/or/config.h @@ -32,7 +32,7 @@ uint32_t get_last_resolved_addr(void); int resolve_my_address(int warn_severity, const or_options_t *options, uint32_t *addr_out, const char **method_out, char **hostname_out); -int is_local_addr(const tor_addr_t *addr); +MOCK_DECL(int, is_local_addr, (const tor_addr_t *addr)); void options_init(or_options_t *options); #define OPTIONS_DUMP_MINIMAL 1

1 0

[tor/master] Make buf_datalen() mockable
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit a2de0a1034b3d4c1433c548526a1401e51540bc1 Author: Andrea Shepard <andrea(a)torproject.org> Date: Thu Jan 23 06:42:14 2014 -0800 Make buf_datalen() mockable --- src/or/buffers.c | 4 ++-- src/or/buffers.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/or/buffers.c b/src/or/buffers.c index 033f862..85eff36 100644 --- a/src/or/buffers.c +++ b/src/or/buffers.c @@ -559,8 +559,8 @@ buf_clear(buf_t *buf) } /** Return the number of bytes stored in <b>buf</b> */ -size_t -buf_datalen(const buf_t *buf) +MOCK_IMPL(size_t, +buf_datalen, (const buf_t *buf)) { return buf->datalen; } diff --git a/src/or/buffers.h b/src/or/buffers.h index c90e147..6b91a2d 100644 --- a/src/or/buffers.h +++ b/src/or/buffers.h @@ -24,7 +24,7 @@ void buf_shrink(buf_t *buf); size_t buf_shrink_freelists(int free_all); void buf_dump_freelist_sizes(int severity); -size_t buf_datalen(const buf_t *buf); +MOCK_DECL(size_t, buf_datalen, (const buf_t *buf)); size_t buf_allocation(const buf_t *buf); size_t buf_slack(const buf_t *buf);

1 0

[tor/master] Make connection_or_connect() mockable
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 3b080230e9fda4befda17739d202b9bc59006add Author: Andrea Shepard <andrea(a)torproject.org> Date: Thu Jan 23 04:54:44 2014 -0800 Make connection_or_connect() mockable --- src/or/connection_or.c | 8 ++++---- src/or/connection_or.h | 7 ++++--- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/or/connection_or.c b/src/or/connection_or.c index 445335b..52f417d 100644 --- a/src/or/connection_or.c +++ b/src/or/connection_or.c @@ -1174,10 +1174,10 @@ connection_or_notify_error(or_connection_t *conn, * * Return the launched conn, or NULL if it failed. */ -or_connection_t * -connection_or_connect(const tor_addr_t *_addr, uint16_t port, - const char *id_digest, - channel_tls_t *chan) + +MOCK_IMPL(or_connection_t *, +connection_or_connect, (const tor_addr_t *_addr, uint16_t port, + const char *id_digest, channel_tls_t *chan)) { or_connection_t *conn; const or_options_t *options = get_options(); diff --git a/src/or/connection_or.h b/src/or/connection_or.h index 7b46d7d..c922fb5 100644 --- a/src/or/connection_or.h +++ b/src/or/connection_or.h @@ -37,9 +37,10 @@ void connection_or_connect_failed(or_connection_t *conn, int reason, const char *msg); void connection_or_notify_error(or_connection_t *conn, int reason, const char *msg); -or_connection_t *connection_or_connect(const tor_addr_t *addr, uint16_t port, - const char *id_digest, - channel_tls_t *chan); +MOCK_DECL(or_connection_t *, + connection_or_connect, + (const tor_addr_t *addr, uint16_t port, + const char *id_digest, channel_tls_t *chan)); void connection_or_close_normally(or_connection_t *orconn, int flush); void connection_or_close_for_error(or_connection_t *orconn, int flush);

1 0

[tor/master] Implement tlschan create and overhead estimate unit tests
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 8719f8ff09346f2aaa596ec77ff326923379ccde Author: Andrea Shepard <andrea(a)torproject.org> Date: Thu Jan 23 05:59:46 2014 -0800 Implement tlschan create and overhead estimate unit tests --- src/test/test_channeltls.c | 212 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 211 insertions(+), 1 deletion(-) diff --git a/src/test/test_channeltls.c b/src/test/test_channeltls.c index 6284cc0..9be738f 100644 --- a/src/test/test_channeltls.c +++ b/src/test/test_channeltls.c @@ -1,18 +1,228 @@ -/* Copyright (c) 2013, The Tor Project, Inc. */ +/* Copyright (c) 2014, The Tor Project, Inc. */ /* See LICENSE for licensing information */ +#include <math.h> + #define TOR_CHANNEL_INTERNAL_ #include "or.h" +#include "address.h" #include "channel.h" #include "channeltls.h" +#include "connection_or.h" +#include "config.h" /* For init/free stuff */ #include "scheduler.h" +#include "tortls.h" /* Test suite stuff */ #include "test.h" #include "fakechans.h" +/* The channeltls unit tests */ +static void test_channeltls_create(void *arg); +static void test_channeltls_overhead_estimate(void *arg); + +/* Mocks used by channeltls unit tests */ +static or_connection_t * tlschan_connection_or_connect_mock( + const tor_addr_t *addr, + uint16_t port, + const char *digest, + channel_tls_t *tlschan); +static int tlschan_is_local_addr_mock(const tor_addr_t *addr); + +/* Fake close method */ +static void tlschan_fake_close_method(channel_t *chan); + +/* Flags controlling behavior of channeltls unit test mocks */ +static int tlschan_local = 0; + +/* Thing to cast to fake tor_tls_t * to appease assert_connection_ok() */ +static int fake_tortls = 0; /* Bleh... */ + +static void +test_channeltls_create(void *arg) +{ + tor_addr_t test_addr; + channel_t *ch = NULL; + const char test_digest[DIGEST_LEN] = { + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, + 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14 }; + + (void)arg; + + /* Set up a fake address to fake-connect to */ + test_addr.family = AF_INET; + test_addr.addr.in_addr.s_addr = htonl(0x01020304); + + /* For this test we always want the address to be treated as non-local */ + tlschan_local = 0; + /* Install is_local_addr() mock */ + MOCK(is_local_addr, tlschan_is_local_addr_mock); + + /* Install mock for connection_or_connect() */ + MOCK(connection_or_connect, tlschan_connection_or_connect_mock); + + /* Try connecting */ + ch = channel_tls_connect(&test_addr, 567, test_digest); + test_assert(ch != NULL); + + done: + if (ch) { + MOCK(scheduler_release_channel, scheduler_release_channel_mock); + /* + * Use fake close method that doesn't try to do too much to fake + * orconn + */ + ch->close = tlschan_fake_close_method; + channel_mark_for_close(ch); + tor_free(ch); + UNMOCK(scheduler_release_channel); + } + + UNMOCK(connection_or_connect); + UNMOCK(is_local_addr); + + return; +} + +static void +test_channeltls_overhead_estimate(void *arg) +{ + tor_addr_t test_addr; + channel_t *ch = NULL; + const char test_digest[DIGEST_LEN] = { + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, + 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14 }; + float r; + channel_tls_t *tlschan = NULL; + + (void)arg; + + /* Set up a fake address to fake-connect to */ + test_addr.family = AF_INET; + test_addr.addr.in_addr.s_addr = htonl(0x01020304); + + /* For this test we always want the address to be treated as non-local */ + tlschan_local = 0; + /* Install is_local_addr() mock */ + MOCK(is_local_addr, tlschan_is_local_addr_mock); + + /* Install mock for connection_or_connect() */ + MOCK(connection_or_connect, tlschan_connection_or_connect_mock); + + /* Try connecting */ + ch = channel_tls_connect(&test_addr, 567, test_digest); + test_assert(ch != NULL); + + /* First case: silly low ratios should get clamped to 1.0f */ + tlschan = BASE_CHAN_TO_TLS(ch); + test_assert(tlschan != NULL); + tlschan->conn->bytes_xmitted = 128; + tlschan->conn->bytes_xmitted_by_tls = 64; + r = ch->get_overhead_estimate(ch); + test_assert(fabsf(r - 1.0f) < 1E-12); + + tlschan->conn->bytes_xmitted_by_tls = 127; + r = ch->get_overhead_estimate(ch); + test_assert(fabsf(r - 1.0f) < 1E-12); + + /* Now middle of the range */ + tlschan->conn->bytes_xmitted_by_tls = 192; + r = ch->get_overhead_estimate(ch); + test_assert(fabsf(r - 1.5f) < 1E-12); + + /* Now above the 2.0f clamp */ + tlschan->conn->bytes_xmitted_by_tls = 257; + r = ch->get_overhead_estimate(ch); + test_assert(fabsf(r - 2.0f) < 1E-12); + + tlschan->conn->bytes_xmitted_by_tls = 512; + r = ch->get_overhead_estimate(ch); + test_assert(fabsf(r - 2.0f) < 1E-12); + + done: + if (ch) { + MOCK(scheduler_release_channel, scheduler_release_channel_mock); + /* + * Use fake close method that doesn't try to do too much to fake + * orconn + */ + ch->close = tlschan_fake_close_method; + channel_mark_for_close(ch); + tor_free(ch); + UNMOCK(scheduler_release_channel); + } + + UNMOCK(connection_or_connect); + UNMOCK(is_local_addr); + + return; +} + +static or_connection_t * +tlschan_connection_or_connect_mock(const tor_addr_t *addr, + uint16_t port, + const char *digest, + channel_tls_t *tlschan) +{ + or_connection_t *result = NULL; + + test_assert(addr != NULL); + test_assert(port != 0); + test_assert(digest != NULL); + test_assert(tlschan != NULL); + + /* Make a fake orconn */ + result = tor_malloc_zero(sizeof(*result)); + result->base_.magic = OR_CONNECTION_MAGIC; + result->base_.state = OR_CONN_STATE_OPEN; + result->base_.type = CONN_TYPE_OR; + result->base_.socket_family = addr->family; + result->base_.address = tor_strdup("<fake>"); + memcpy(&(result->base_.addr), addr, sizeof(tor_addr_t)); + result->base_.port = port; + memcpy(result->identity_digest, digest, DIGEST_LEN); + result->chan = tlschan; + memcpy(&(result->real_addr), addr, sizeof(tor_addr_t)); + result->tls = (tor_tls_t *)((void *)(&fake_tortls)); + + done: + return result; +} + +static void +tlschan_fake_close_method(channel_t *chan) +{ + channel_tls_t *tlschan = NULL; + + test_assert(chan != NULL); + test_eq(chan->magic, TLS_CHAN_MAGIC); + + tlschan = BASE_CHAN_TO_TLS(chan); + test_assert(tlschan != NULL); + + /* Just free the fake orconn */ + tor_free(tlschan->conn); + + channel_closed(chan); + + done: + return; +} + +static int +tlschan_is_local_addr_mock(const tor_addr_t *addr) +{ + test_assert(addr != NULL); + + done: + return tlschan_local; +} + struct testcase_t channeltls_tests[] = { + { "create", test_channeltls_create, TT_FORK, NULL, NULL }, + { "overhead_estimate", test_channeltls_overhead_estimate, + TT_FORK, NULL, NULL }, END_OF_TESTCASES };

1 0

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

28 Nov '14

commit 030b0fe1076bd8747e3fecf32740c0b3fd3759eb Author: Andrea Shepard <andrea(a)torproject.org> Date: Thu Jan 23 06:56:18 2014 -0800 Add channeltls/num_bytes_queued unit test --- src/test/test_channeltls.c | 95 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 95 insertions(+) diff --git a/src/test/test_channeltls.c b/src/test/test_channeltls.c index 9be738f..b70d0fd 100644 --- a/src/test/test_channeltls.c +++ b/src/test/test_channeltls.c @@ -6,6 +6,7 @@ #define TOR_CHANNEL_INTERNAL_ #include "or.h" #include "address.h" +#include "buffers.h" #include "channel.h" #include "channeltls.h" #include "connection_or.h" @@ -20,9 +21,11 @@ /* The channeltls unit tests */ static void test_channeltls_create(void *arg); +static void test_channeltls_num_bytes_queued(void *arg); static void test_channeltls_overhead_estimate(void *arg); /* Mocks used by channeltls unit tests */ +static size_t tlschan_buf_datalen_mock(const buf_t *buf); static or_connection_t * tlschan_connection_or_connect_mock( const tor_addr_t *addr, uint16_t port, @@ -35,6 +38,8 @@ static void tlschan_fake_close_method(channel_t *chan); /* Flags controlling behavior of channeltls unit test mocks */ static int tlschan_local = 0; +static const buf_t * tlschan_buf_datalen_mock_target = NULL; +static size_t tlschan_buf_datalen_mock_size = 0; /* Thing to cast to fake tor_tls_t * to appease assert_connection_ok() */ static int fake_tortls = 0; /* Bleh... */ @@ -86,6 +91,84 @@ test_channeltls_create(void *arg) } static void +test_channeltls_num_bytes_queued(void *arg) +{ + tor_addr_t test_addr; + channel_t *ch = NULL; + const char test_digest[DIGEST_LEN] = { + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, + 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14 }; + channel_tls_t *tlschan = NULL; + size_t len; + int fake_outbuf = 0; + + (void)arg; + + /* Set up a fake address to fake-connect to */ + test_addr.family = AF_INET; + test_addr.addr.in_addr.s_addr = htonl(0x01020304); + + /* For this test we always want the address to be treated as non-local */ + tlschan_local = 0; + /* Install is_local_addr() mock */ + MOCK(is_local_addr, tlschan_is_local_addr_mock); + + /* Install mock for connection_or_connect() */ + MOCK(connection_or_connect, tlschan_connection_or_connect_mock); + + /* Try connecting */ + ch = channel_tls_connect(&test_addr, 567, test_digest); + test_assert(ch != NULL); + + /* + * Next, we have to test ch->num_bytes_queued, which is + * channel_tls_num_bytes_queued_method. We can't mock + * connection_get_outbuf_len() directly because it's static INLINE + * in connection.h, but we can mock buf_datalen(). Note that + * if bufferevents ever work, this will break with them enabled. + */ + + test_assert(ch->num_bytes_queued != NULL); + tlschan = BASE_CHAN_TO_TLS(ch); + test_assert(tlschan != NULL); + if (TO_CONN(tlschan->conn)->outbuf == NULL) { + /* We need an outbuf to make sure buf_datalen() gets called */ + fake_outbuf = 1; + TO_CONN(tlschan->conn)->outbuf = buf_new(); + } + tlschan_buf_datalen_mock_target = TO_CONN(tlschan->conn)->outbuf; + tlschan_buf_datalen_mock_size = 1024; + MOCK(buf_datalen, tlschan_buf_datalen_mock); + len = ch->num_bytes_queued(ch); + test_eq(len, tlschan_buf_datalen_mock_size); + UNMOCK(buf_datalen); + tlschan_buf_datalen_mock_target = NULL; + tlschan_buf_datalen_mock_size = 0; + if (fake_outbuf) { + buf_free(TO_CONN(tlschan->conn)->outbuf); + TO_CONN(tlschan->conn)->outbuf = NULL; + } + + done: + if (ch) { + MOCK(scheduler_release_channel, scheduler_release_channel_mock); + /* + * Use fake close method that doesn't try to do too much to fake + * orconn + */ + ch->close = tlschan_fake_close_method; + channel_mark_for_close(ch); + tor_free(ch); + UNMOCK(scheduler_release_channel); + } + + UNMOCK(connection_or_connect); + UNMOCK(is_local_addr); + + return; +} + +static void test_channeltls_overhead_estimate(void *arg) { tor_addr_t test_addr; @@ -159,6 +242,16 @@ test_channeltls_overhead_estimate(void *arg) return; } +static size_t +tlschan_buf_datalen_mock(const buf_t *buf) +{ + if (buf != NULL && buf == tlschan_buf_datalen_mock_target) { + return tlschan_buf_datalen_mock_size; + }else { + return buf_datalen__real(buf); + } +} + static or_connection_t * tlschan_connection_or_connect_mock(const tor_addr_t *addr, uint16_t port, @@ -221,6 +314,8 @@ tlschan_is_local_addr_mock(const tor_addr_t *addr) struct testcase_t channeltls_tests[] = { { "create", test_channeltls_create, TT_FORK, NULL, NULL }, + { "num_bytes_queued", test_channeltls_num_bytes_queued, + TT_FORK, NULL, NULL }, { "overhead_estimate", test_channeltls_overhead_estimate, TT_FORK, NULL, NULL }, END_OF_TESTCASES

1 0

[tor/master] Limited unit test for channel_dump_statistics()
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 462eaed43e73af7869bd4ed96561e9bed88a9de3 Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Jan 22 16:23:54 2014 -0800 Limited unit test for channel_dump_statistics() --- src/test/test_channel.c | 112 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 111 insertions(+), 1 deletion(-) diff --git a/src/test/test_channel.c b/src/test/test_channel.c index fc0ef3d..9ad271d 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -29,6 +29,7 @@ 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; +static int test_dumpstats_calls = 0; static int test_has_waiting_cells_count = 0; static double test_overhead_estimate = 1.0f; static int test_releases_count = 0; @@ -46,11 +47,15 @@ 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 const char * chan_test_describe_transport(channel_t *ch); +static void chan_test_dumpstats(channel_t *ch, int severity); 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); +static const char * chan_test_get_remote_descr(channel_t *ch, int flags); +static int chan_test_is_canonical(channel_t *ch, int req); static size_t chan_test_num_bytes_queued(channel_t *ch); static int chan_test_num_cells_writeable(channel_t *ch); static int chan_test_write_cell(channel_t *ch, cell_t *cell); @@ -78,6 +83,15 @@ channel_note_destroy_not_pending_mock(channel_t *ch, ++test_destroy_not_pending_calls; } +static const char * +chan_test_describe_transport(channel_t *ch) +{ + test_assert(ch != NULL); + + done: + return "Fake channel for unit tests"; +} + /** * Mock for channel_dump_statistics(); if the channel matches the * target, bump a counter - otherwise ignore. @@ -173,6 +187,23 @@ chan_test_cell_handler(channel_t *ch, } /* + * Fake transport-specific stats call + */ + +static void +chan_test_dumpstats(channel_t *ch, int severity) +{ + test_assert(ch != NULL); + + (void)severity; + + ++test_dumpstats_calls; + + done: + return; +} + +/* * Handle an incoming variable-size cell for unit tests */ @@ -233,6 +264,16 @@ chan_test_finish_close(channel_t *ch) return; } +static const char * +chan_test_get_remote_descr(channel_t *ch, int flags) +{ + test_assert(ch); + test_eq(flags & ~(GRD_FLAG_ORIGINAL | GRD_FLAG_ADDR_ONLY), 0); + + done: + return "Fake channel for unit tests; no real endpoint"; +} + static double chan_test_get_overhead_estimate(channel_t *ch) { @@ -242,6 +283,17 @@ chan_test_get_overhead_estimate(channel_t *ch) return test_overhead_estimate; } +static int +chan_test_is_canonical(channel_t *ch, int req) +{ + test_assert(ch != NULL); + test_assert(req == 0 || req == 1); + + done: + /* Fake channels are always canonical */ + return 1; +} + static size_t chan_test_num_bytes_queued(channel_t *ch) { @@ -440,13 +492,16 @@ scheduler_release_channel_mock(channel_t *ch) } /** - * Test for channel_dumpstats() + * Test for channel_dumpstats() and limited test for + * channel_dump_statistics() */ static void test_channel_dumpstats(void *arg) { channel_t *ch = NULL; + cell_t *cell = NULL; + int old_count; (void)arg; @@ -499,7 +554,62 @@ test_channel_dumpstats(void *arg) dump_statistics_mock_target = NULL; dump_statistics_mock_matches = 0; + /* Now make another channel */ + ch = new_fake_channel(); + test_assert(ch); + ch->cmux = circuitmux_alloc(); + channel_register(ch); + test_assert(ch->registered); + /* Lie about its age so dumpstats gets coverage for rate calculations */ + ch->timestamp_created = time(NULL) - 30; + test_assert(ch->timestamp_created > 0); + test_assert(time(NULL) > ch->timestamp_created); + + /* Put cells through it both ways to make the counters non-zero */ + cell = tor_malloc_zero(sizeof(*cell)); + make_fake_cell(cell); + test_chan_accept_cells = 1; + old_count = test_cells_written; + channel_write_cell(ch, cell); + cell = NULL; + test_eq(test_cells_written, old_count + 1); + test_assert(ch->n_bytes_xmitted > 0); + test_assert(ch->n_cells_xmitted > 0); + + /* Receive path */ + channel_set_cell_handlers(ch, + chan_test_cell_handler, + chan_test_var_cell_handler); + test_eq(channel_get_cell_handler(ch), chan_test_cell_handler); + test_eq(channel_get_var_cell_handler(ch), chan_test_var_cell_handler); + 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); + test_assert(ch->n_bytes_recved > 0); + test_assert(ch->n_cells_recved > 0); + + /* Test channel_dump_statistics */ + ch->describe_transport = chan_test_describe_transport; + ch->dumpstats = chan_test_dumpstats; + ch->get_remote_descr = chan_test_get_remote_descr; + ch->is_canonical = chan_test_is_canonical; + old_count = test_dumpstats_calls; + channel_dump_statistics(ch, LOG_DEBUG); + test_eq(test_dumpstats_calls, old_count + 1); + + /* Close the channel */ + 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(cell); tor_free(ch); UNMOCK(scheduler_channel_doesnt_want_writes);

1 0

[tor/master] Make scheduler.c static globals visible to test suite
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 9869254608587dbd0d33bcba0233967f6bf3c326 Author: Andrea Shepard <andrea(a)torproject.org> Date: Thu Jan 23 20:55:13 2014 -0800 Make scheduler.c static globals visible to test suite --- src/or/scheduler.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/or/scheduler.c b/src/or/scheduler.c index 367480c..71da4a4 100644 --- a/src/or/scheduler.c +++ b/src/or/scheduler.c @@ -109,27 +109,27 @@ */ /* Pqueue of channels that can write and have cells (pending work) */ -static smartlist_t *channels_pending = NULL; +STATIC smartlist_t *channels_pending = NULL; /* * This event runs the scheduler from its callback, and is manually * activated whenever a channel enters open for writes/cells to send. */ -static struct event *run_sched_ev = NULL; +STATIC struct event *run_sched_ev = NULL; /* * Queue heuristic; this is not the queue size, but an 'effective queuesize' * that ages out contributions from stalled channels. */ -static uint64_t queue_heuristic = 0; +STATIC uint64_t queue_heuristic = 0; /* * Timestamp for last queue heuristic update */ -static time_t queue_heuristic_timestamp = 0; +STATIC time_t queue_heuristic_timestamp = 0; /* Scheduler static function declarations */

1 0

[tor/master] Make some scheduler.c static functions visible to the test suite
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 71a9ed6feb9e28cce0a2e776e23b440b0139e479 Author: Andrea Shepard <andrea(a)torproject.org> Date: Thu Jan 23 21:13:26 2014 -0800 Make some scheduler.c static functions visible to the test suite --- src/or/scheduler.c | 7 +++---- src/or/scheduler.h | 7 +++++++ 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/src/or/scheduler.c b/src/or/scheduler.c index 71da4a4..1b4ae04 100644 --- a/src/or/scheduler.c +++ b/src/or/scheduler.c @@ -12,6 +12,7 @@ #include "channel.h" #include "compat_libevent.h" +#define SCHEDULER_PRIVATE_ #include "scheduler.h" #ifdef HAVE_EVENT2_EVENT_H @@ -141,8 +142,6 @@ static void scheduler_retrigger(void); #if 0 static void scheduler_trigger(void); #endif -static uint64_t scheduler_get_queue_heuristic(void); -static void scheduler_update_queue_heuristic(time_t now); /* Scheduler function implementations */ @@ -642,7 +641,7 @@ scheduler_adjust_queue_size(channel_t *chan, char dir, uint64_t adj) * Query the current value of the queue heuristic */ -static uint64_t +STATIC uint64_t scheduler_get_queue_heuristic(void) { time_t now = approx_time(); @@ -656,7 +655,7 @@ scheduler_get_queue_heuristic(void) * Adjust the queue heuristic value to the present time */ -static void +STATIC void scheduler_update_queue_heuristic(time_t now) { time_t diff; diff --git a/src/or/scheduler.h b/src/or/scheduler.h index 7f59ec4..3c0d86d 100644 --- a/src/or/scheduler.h +++ b/src/or/scheduler.h @@ -34,5 +34,12 @@ void scheduler_adjust_queue_size(channel_t *chan, char dir, uint64_t adj); /* Notify scheduler that a channel's queue position may have changed */ void scheduler_touch_channel(channel_t *chan); +/* Things only scheduler.c and its test suite should see */ + +#ifdef SCHEDULER_PRIVATE_ +STATIC uint64_t scheduler_get_queue_heuristic(void); +STATIC void scheduler_update_queue_heuristic(time_t now); +#endif + #endif /* !defined(TOR_SCHEDULER_H) */

1 0

[tor/master] Add channel_tls_num_cells_writeable_method() coverage to channeltls/num_bytes_queued unit test
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 5e9a88e001f66092b8b3fd5fd14877214d038027 Author: Andrea Shepard <andrea(a)torproject.org> Date: Thu Jan 23 07:11:13 2014 -0800 Add channel_tls_num_cells_writeable_method() coverage to channeltls/num_bytes_queued unit test --- src/test/test_channeltls.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/src/test/test_channeltls.c b/src/test/test_channeltls.c index b70d0fd..4dcf4c5 100644 --- a/src/test/test_channeltls.c +++ b/src/test/test_channeltls.c @@ -100,7 +100,7 @@ test_channeltls_num_bytes_queued(void *arg) 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14 }; channel_tls_t *tlschan = NULL; size_t len; - int fake_outbuf = 0; + int fake_outbuf = 0, n; (void)arg; @@ -141,6 +141,15 @@ test_channeltls_num_bytes_queued(void *arg) MOCK(buf_datalen, tlschan_buf_datalen_mock); len = ch->num_bytes_queued(ch); test_eq(len, tlschan_buf_datalen_mock_size); + /* + * We also cover num_cells_writeable here; since wide_circ_ids = 0 on + * the fake tlschans, cell_network_size returns 512, and so with + * tlschan_buf_datalen_mock_size == 1024, we should be able to write + * ceil((OR_CONN_HIGHWATER - 1024) / 512) = ceil(OR_CONN_HIGHWATER / 512) + * - 2 cells. + */ + n = ch->num_cells_writeable(ch); + test_eq(n, CEIL_DIV(OR_CONN_HIGHWATER, 512) - 2); UNMOCK(buf_datalen); tlschan_buf_datalen_mock_target = NULL; tlschan_buf_datalen_mock_size = 0;

1 0

← Newer
1
2
3
4
5
6
7
8
9
...
96
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits November 2014