[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]
[tor-commits] [tor/master] Merge branch 'macro_free_v2_squashed'
commit 5ee0cccd49e57fad8c810e817d912d4a61dbc96c
Merge: 44010c6fc 7ca5f4bf0
Author: Nick Mathewson <nickm@xxxxxxxxxxxxxx>
Date: Fri Dec 8 14:58:43 2017 -0500
Merge branch 'macro_free_v2_squashed'
changes/bug24337 | 8 ++++
configure.ac | 1 -
doc/HACKING/CodingStandards.md | 40 ++++++++++++++++++
src/common/address.c | 6 +--
src/common/address.h | 13 +++---
src/common/aes.c | 4 +-
src/common/aes.h | 4 +-
src/common/buffers.c | 2 +-
src/common/buffers.h | 3 +-
src/common/compat.c | 5 ++-
src/common/compat_libevent.c | 4 +-
src/common/compat_libevent.h | 8 +++-
src/common/compat_threads.c | 4 +-
src/common/compat_threads.h | 6 ++-
src/common/compress.c | 2 +-
src/common/compress.h | 4 +-
src/common/compress_lzma.c | 2 +-
src/common/compress_lzma.h | 5 ++-
src/common/compress_zlib.c | 2 +-
src/common/compress_zlib.h | 5 ++-
src/common/compress_zstd.c | 2 +-
src/common/compress_zstd.h | 5 ++-
src/common/confline.c | 2 +-
src/common/confline.h | 7 ++-
src/common/container.c | 19 ++++++---
src/common/container.h | 27 +++++++++---
src/common/crypto.c | 10 ++---
src/common/crypto.h | 19 ++++++---
src/common/crypto_ed25519.c | 2 +-
src/common/crypto_ed25519.h | 5 ++-
src/common/di_ops.c | 2 +-
src/common/di_ops.h | 7 ++-
src/common/handles.h | 4 +-
src/common/log.c | 11 +++--
src/common/memarea.c | 2 +-
src/common/memarea.h | 7 ++-
src/common/procmon.c | 2 +-
src/common/procmon.h | 4 +-
src/common/sandbox.c | 6 ++-
src/common/storagedir.c | 2 +-
src/common/storagedir.h | 5 ++-
src/common/timers.c | 2 +-
src/common/timers.h | 3 +-
src/common/tortls.c | 4 +-
src/common/tortls.h | 7 ++-
src/common/util.c | 2 +-
src/common/util.h | 25 ++++++++++-
src/common/workqueue.c | 5 ++-
src/or/addressmap.c | 35 ++++++++++-----
src/or/bridges.c | 7 ++-
src/or/channel.c | 26 ++++++------
src/or/channel.h | 9 +++-
src/or/circuitbuild.c | 2 +-
src/or/circuitbuild.h | 4 +-
src/or/circuitlist.c | 4 +-
src/or/circuitlist.h | 3 +-
src/or/circuitmux.c | 2 +-
src/or/circuitmux.h | 4 +-
src/or/config.c | 10 +++--
src/or/config.h | 12 ++++--
src/or/confparse.c | 2 +-
src/or/confparse.h | 7 ++-
src/or/connection.c | 15 ++++---
src/or/connection.h | 6 ++-
src/or/connection_edge.c | 12 +++---
src/or/connection_or.c | 8 ++--
src/or/connection_or.h | 7 ++-
src/or/conscache.c | 2 +-
src/or/conscache.h | 7 ++-
src/or/consdiffmgr.c | 17 ++++++--
src/or/control.c | 5 ++-
src/or/cpuworker.c | 19 +++++++--
src/or/dircollate.c | 7 ++-
src/or/dircollate.h | 4 +-
src/or/directory.c | 2 +-
src/or/directory.h | 4 +-
src/or/dirserv.c | 2 +-
src/or/dirserv.h | 4 +-
src/or/dirvote.c | 7 ++-
src/or/dirvote.h | 4 +-
src/or/dns.c | 10 ++---
src/or/dnsserv.c | 4 +-
src/or/entrynodes.c | 8 ++--
src/or/entrynodes.h | 21 +++++++--
src/or/ext_orport.c | 2 +-
src/or/ext_orport.h | 6 ++-
src/or/fp_pair.c | 2 +-
src/or/fp_pair.h | 7 ++-
src/or/geoip.c | 5 ++-
src/or/hs_cache.c | 44 ++++++++++++-------
src/or/hs_circuitmap.c | 5 ++-
src/or/hs_common.c | 2 +-
src/or/hs_common.h | 4 +-
src/or/hs_descriptor.c | 10 ++---
src/or/hs_descriptor.h | 21 ++++++---
src/or/hs_ident.c | 6 +--
src/or/hs_ident.h | 12 ++++--
src/or/hs_service.c | 12 +++---
src/or/hs_service.h | 23 ++++++----
src/or/microdesc.h | 6 ++-
src/or/networkstatus.c | 8 ++--
src/or/networkstatus.h | 16 +++++--
src/or/nodelist.c | 6 ++-
src/or/onion.c | 2 +-
src/or/onion.h | 4 +-
src/or/onion_fast.c | 2 +-
src/or/onion_fast.h | 4 +-
src/or/onion_ntor.c | 2 +-
src/or/onion_ntor.h | 4 +-
src/or/policies.c | 10 ++---
src/or/policies.h | 12 ++++--
src/or/proto_socks.c | 2 +-
src/or/proto_socks.h | 4 +-
src/or/protover.c | 2 +-
src/or/protover.h | 4 +-
src/or/relay.c | 4 +-
src/or/relay.h | 8 +++-
src/or/rendcache.c | 32 +++++++-------
src/or/rendcache.h | 18 +++++---
src/or/rendclient.c | 14 +++---
src/or/rendcommon.c | 6 +--
src/or/rendcommon.h | 14 ++++--
src/or/rendservice.c | 18 ++++----
src/or/rendservice.h | 22 +++++++---
src/or/rephist.c | 20 ++++++---
src/or/replaycache.c | 2 +-
src/or/replaycache.h | 4 +-
src/or/router.c | 3 +-
src/or/router.h | 4 +-
src/or/routerlist.c | 40 ++++++++++++------
src/or/routerlist.h | 14 ++++--
src/or/routerset.c | 2 +-
src/or/routerset.h | 3 +-
src/or/scheduler_kist.c | 4 +-
src/or/shared_random.c | 4 +-
src/or/shared_random.h | 3 +-
src/or/shared_random_state.c | 14 ++++--
src/or/shared_random_state.h | 2 +-
src/or/statefile.c | 2 +-
src/or/statefile.h | 3 +-
src/or/torcert.c | 4 +-
src/or/torcert.h | 7 ++-
src/or/transports.c | 2 +-
src/or/transports.h | 3 +-
src/test/test-timers.c | 2 +-
src/test/test.c | 6 +--
src/test/test_address.c | 16 +++----
src/test/test_cell_queue.c | 4 +-
src/test/test_channel.c | 2 +-
src/test/test_circuitlist.c | 28 ++++++------
src/test/test_dir.c | 6 +--
src/test/test_dir_handle_get.c | 96 +++++++++++++++++++++---------------------
src/test/test_dns.c | 6 +--
src/test/test_entryconn.c | 34 +++++++--------
src/test/test_entrynodes.c | 4 +-
src/test/test_extorport.c | 10 ++---
src/test/test_handles.c | 2 +
src/test/test_hs_cache.c | 2 +-
src/test/test_hs_client.c | 12 +++---
src/test/test_hs_intropoint.c | 38 ++++++++---------
src/test/test_hs_service.c | 16 +++----
src/test/test_link_handshake.c | 14 +++---
src/test/test_oom.c | 2 +-
src/test/test_policy.c | 8 ++--
src/test/test_rendcache.c | 8 ++--
src/test/test_replay.c | 2 +-
src/test/test_routerlist.c | 2 +-
src/test/test_routerset.c | 56 ++++++++++++------------
src/test/test_shared_random.c | 2 +-
169 files changed, 976 insertions(+), 555 deletions(-)
diff --cc src/or/channel.c
index 5b9d860ba,90536b146..7fa976817
--- a/src/or/channel.c
+++ b/src/or/channel.c
@@@ -159,15 -202,39 +160,15 @@@ HT_PROTOTYPE(channel_idmap, channel_idm
HT_GENERATE2(channel_idmap, channel_idmap_entry_s, node, channel_idmap_hash,
channel_idmap_eq, 0.5, tor_reallocarray_, tor_free_)
-static cell_queue_entry_t * cell_queue_entry_dup(cell_queue_entry_t *q);
-#if 0
-static int cell_queue_entry_is_padding(cell_queue_entry_t *q);
-#endif
-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 is_destroy_cell(channel_t *chan,
- const cell_queue_entry_t *q, circid_t *circid_out);
-
-static void channel_assert_counter_consistency(void);
-
/* Functions to maintain the digest map */
-static void channel_add_to_digest_map(channel_t *chan);
static void channel_remove_from_digest_map(channel_t *chan);
- static void channel_force_free(channel_t *chan);
- static void
- channel_free_list(smartlist_t *channels, int mark_for_close);
- static void
- channel_listener_free_list(smartlist_t *channels, int mark_for_close);
- static void channel_listener_force_free(channel_listener_t *chan_l);
-/*
- * Flush cells from just the outgoing queue without trying to get them
- * from circuits; used internall by channel_flush_some_cells().
- */
-static ssize_t
-channel_flush_some_cells_from_outgoing_queue(channel_t *chan,
- ssize_t num_cells);
+ static void channel_force_xfree(channel_t *chan);
-static void channel_free_list(smartlist_t *channels, int mark_for_close);
++static void channel_free_list(smartlist_t *channels,
++ int mark_for_close);
+ static void channel_listener_free_list(smartlist_t *channels,
- int mark_for_close);
++ int mark_for_close);
+ static void channel_listener_force_xfree(channel_listener_t *chan_l);
-static size_t channel_get_cell_queue_entry_size(channel_t *chan,
- cell_queue_entry_t *q);
-static void
-channel_write_cell_queue_entry(channel_t *chan, cell_queue_entry_t *q);
/***********************************
* Channel state utility functions *
@@@ -962,8 -1067,9 +963,8 @@@ channel_listener_free_(channel_listener
*/
static void
- channel_force_free(channel_t *chan)
+ channel_force_xfree(channel_t *chan)
{
- cell_queue_entry_t *cell, *cell_tmp;
tor_assert(chan);
log_debug(LD_CHANNEL,
@@@ -1429,18 -1668,250 +1430,17 @@@ channel_clear_remote_end(channel_t *cha
}
/**
- * Set the remote end metadata (identity_digest/nickname) of a channel
+ * Write to a channel the given packed cell.
*
- * Return 0 on success or -1 on error.
- * This function sets new remote end info on a channel; this is intended
- * for use by the lower layer.
- */
-
-void
-channel_set_remote_end(channel_t *chan,
- const char *identity_digest,
- const char *nickname)
-{
- int was_in_digest_map, should_be_in_digest_map, state_not_in_map;
-
- tor_assert(chan);
-
- log_debug(LD_CHANNEL,
- "Setting remote endpoint identity on channel %p with "
- "global ID " U64_FORMAT " to nickname %s, digest %s",
- chan, U64_PRINTF_ARG(chan->global_identifier),
- nickname ? nickname : "(null)",
- identity_digest ?
- hex_str(identity_digest, DIGEST_LEN) : "(null)");
-
- state_not_in_map = CHANNEL_CONDEMNED(chan);
-
- was_in_digest_map =
- !state_not_in_map &&
- chan->registered &&
- !tor_digest_is_zero(chan->identity_digest);
- should_be_in_digest_map =
- !state_not_in_map &&
- chan->registered &&
- (identity_digest &&
- !tor_digest_is_zero(identity_digest));
-
- if (was_in_digest_map)
- /* We should always remove it; we'll add it back if we're writing
- * in a new digest.
- */
- channel_remove_from_digest_map(chan);
-
- if (identity_digest) {
- memcpy(chan->identity_digest,
- identity_digest,
- sizeof(chan->identity_digest));
-
- } else {
- memset(chan->identity_digest, 0,
- sizeof(chan->identity_digest));
- }
-
- tor_free(chan->nickname);
- if (nickname)
- chan->nickname = tor_strdup(nickname);
-
- /* Put it in the digest map if we should */
- if (should_be_in_digest_map)
- channel_add_to_digest_map(chan);
-}
-
-/**
- * Duplicate a cell queue entry; this is a shallow copy intended for use
- * in channel_write_cell_queue_entry().
- */
-
-static cell_queue_entry_t *
-cell_queue_entry_dup(cell_queue_entry_t *q)
-{
- cell_queue_entry_t *rv = NULL;
-
- tor_assert(q);
-
- rv = tor_malloc(sizeof(*rv));
- memcpy(rv, q, sizeof(*rv));
-
- return rv;
-}
-
-/**
- * Free a cell_queue_entry_t; the handed_off parameter indicates whether
- * the contents were passed to the lower layer (it is responsible for
- * them) or not (we should free).
- */
-
-STATIC void
-cell_queue_entry_xfree(cell_queue_entry_t *q, int handed_off)
-{
- if (!q) return;
-
- if (!handed_off) {
- /*
- * If we handed it off, the recipient becomes responsible (or
- * with packed cells the channel_t subclass calls packed_cell
- * free after writing out its contents; see, e.g.,
- * channel_tls_write_packed_cell_method(). Otherwise, we have
- * to take care of it here if possible.
- */
- switch (q->type) {
- case CELL_QUEUE_FIXED:
- if (q->u.fixed.cell) {
- /*
- * There doesn't seem to be a cell_free() function anywhere in the
- * pre-channel code; just use tor_free()
- */
- tor_free(q->u.fixed.cell);
- }
- break;
- case CELL_QUEUE_PACKED:
- if (q->u.packed.packed_cell) {
- packed_cell_free(q->u.packed.packed_cell);
- }
- break;
- case CELL_QUEUE_VAR:
- if (q->u.var.var_cell) {
- /*
- * This one's in connection_or.c; it'd be nice to figure out the
- * whole flow of cells from one end to the other and factor the
- * cell memory management functions like this out of the specific
- * TLS lower layer.
- */
- var_cell_free(q->u.var.var_cell);
- }
- break;
- default:
- /*
- * Nothing we can do if we don't know the type; this will
- * have been warned about elsewhere.
- */
- break;
- }
- }
- tor_free(q);
-}
-
-#if 0
-/**
- * Check whether a cell queue entry is padding; this is a helper function
- * for channel_write_cell_queue_entry()
- */
-
-static int
-cell_queue_entry_is_padding(cell_queue_entry_t *q)
-{
- tor_assert(q);
-
- if (q->type == CELL_QUEUE_FIXED) {
- if (q->u.fixed.cell) {
- if (q->u.fixed.cell->command == CELL_PADDING ||
- q->u.fixed.cell->command == CELL_VPADDING) {
- return 1;
- }
- }
- } else if (q->type == CELL_QUEUE_VAR) {
- if (q->u.var.var_cell) {
- if (q->u.var.var_cell->command == CELL_PADDING ||
- q->u.var.var_cell->command == CELL_VPADDING) {
- return 1;
- }
- }
- }
-
- return 0;
-}
-#endif /* 0 */
-
-/**
- * Allocate a new cell queue entry for a fixed-size cell
- */
-
-static cell_queue_entry_t *
-cell_queue_entry_new_fixed(cell_t *cell)
-{
- cell_queue_entry_t *q = NULL;
-
- tor_assert(cell);
-
- q = tor_malloc(sizeof(*q));
- q->type = CELL_QUEUE_FIXED;
- q->u.fixed.cell = cell;
-
- return q;
-}
-
-/**
- * Allocate a new cell queue entry for a variable-size cell
- */
-
-static cell_queue_entry_t *
-cell_queue_entry_new_var(var_cell_t *var_cell)
-{
- cell_queue_entry_t *q = NULL;
-
- tor_assert(var_cell);
-
- q = tor_malloc(sizeof(*q));
- q->type = CELL_QUEUE_VAR;
- q->u.var.var_cell = var_cell;
-
- return q;
-}
-
-/**
- * Ask how big the cell contained in a cell_queue_entry_t is
- */
-
-static size_t
-channel_get_cell_queue_entry_size(channel_t *chan, cell_queue_entry_t *q)
-{
- size_t rv = 0;
-
- tor_assert(chan);
- tor_assert(q);
-
- switch (q->type) {
- case CELL_QUEUE_FIXED:
- rv = get_cell_network_size(chan->wide_circ_ids);
- break;
- case CELL_QUEUE_VAR:
- rv = get_var_cell_header_size(chan->wide_circ_ids) +
- (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);
- break;
- default:
- tor_assert_nonfatal_unreached_once();
- }
-
- return rv;
-}
-
-/**
- * Write to a channel based on a cell_queue_entry_t
*
- * Given a cell_queue_entry_t filled out by the caller, try to send the cell
- * and queue it if we can't.
+ * Two possible errors can happen. Either the channel is not opened or the
+ * lower layer (specialized channel) failed to write it. In both cases, it is
+ * the caller responsability to free the cell.
*/
-
-static void
-channel_write_cell_queue_entry(channel_t *chan, cell_queue_entry_t *q)
+static int
+write_packed_cell(channel_t *chan, packed_cell_t *cell)
{
- int result = 0, sent = 0;
- cell_queue_entry_t *tmp = NULL;
+ int ret = -1;
size_t cell_bytes;
tor_assert(chan);
diff --cc src/or/channel.h
index d88a77c9a,909813cee..0f685011a
--- a/src/or/channel.h
+++ b/src/or/channel.h
@@@ -457,9 -511,16 +457,12 @@@ void channel_close_from_lower_layer(cha
void channel_close_for_error(channel_t *chan);
void channel_closed(channel_t *chan);
-void channel_listener_close_from_lower_layer(channel_listener_t *chan_l);
-void channel_listener_close_for_error(channel_listener_t *chan_l);
-void channel_listener_closed(channel_listener_t *chan_l);
-
/* Free a channel */
- void channel_free(channel_t *chan);
- void channel_listener_free(channel_listener_t *chan_l);
+ void channel_free_(channel_t *chan);
+ #define channel_free(chan) FREE_AND_NULL(channel_t, channel_free_, (chan))
+ void channel_listener_free_(channel_listener_t *chan_l);
+ #define channel_listener_free(chan_l) \
+ FREE_AND_NULL(channel_listener_t, channel_listener_free_, (chan_l))
/* State/metadata setters */
diff --cc src/or/protover.h
index 83a728e62,2539c92c3..8bbc2fc71
--- a/src/or/protover.h
+++ b/src/or/protover.h
@@@ -82,10 -82,11 +82,12 @@@ STATIC smartlist_t *parse_protocol_list
STATIC char *encode_protocol_list(const smartlist_t *sl);
STATIC const char *protocol_type_to_str(protocol_type_t pr);
STATIC int str_to_protocol_type(const char *s, protocol_type_t *pr_out);
- STATIC void proto_entry_free(proto_entry_t *entry);
+ STATIC void proto_entry_free_(proto_entry_t *entry);
-#endif
+ #define proto_entry_free(entry) \
+ FREE_AND_NULL(proto_entry_t, proto_entry_free_, (entry))
+#endif /* !defined(HAVE_RUST) && defined(TOR_UNIT_TESTS) */
+
#endif /* defined(PROTOVER_PRIVATE) */
#endif /* !defined(TOR_PROTOVER_H) */
diff --cc src/or/rendservice.h
index 15badce6a,70ebd8786..88da7b866
--- a/src/or/rendservice.h
+++ b/src/or/rendservice.h
@@@ -183,11 -189,26 +189,17 @@@ void rend_service_init(void)
rend_service_port_config_t *rend_service_parse_port_config(const char *string,
const char *sep,
char **err_msg_out);
- void rend_service_port_config_free(rend_service_port_config_t *p);
-
- void rend_authorized_client_free(rend_authorized_client_t *client);
+ void rend_service_port_config_free_(rend_service_port_config_t *p);
+ #define rend_service_port_config_free(p) \
+ FREE_AND_NULL(rend_service_port_config_t, rend_service_port_config_free_, \
+ (p))
+
+ void rend_authorized_client_free_(rend_authorized_client_t *client);
+ #define rend_authorized_client_free(client) \
+ FREE_AND_NULL(rend_authorized_client_t, rend_authorized_client_free_, \
+ (client))
-/** Return value from rend_service_add_ephemeral. */
-typedef enum {
- RSAE_BADAUTH = -5, /**< Invalid auth_type/auth_clients */
- RSAE_BADVIRTPORT = -4, /**< Invalid VIRTPORT/TARGET(s) */
- RSAE_ADDREXISTS = -3, /**< Onion address collision */
- RSAE_BADPRIVKEY = -2, /**< Invalid public key */
- RSAE_INTERNAL = -1, /**< Internal error */
- RSAE_OKAY = 0 /**< Service added as expected */
-} rend_service_add_ephemeral_status_t;
-rend_service_add_ephemeral_status_t rend_service_add_ephemeral(crypto_pk_t *pk,
+hs_service_add_ephemeral_status_t rend_service_add_ephemeral(crypto_pk_t *pk,
smartlist_t *ports,
int max_streams_per_circuit,
int max_streams_close_circuit,
diff --cc src/test/test_channel.c
index 38b69a9ad,594372693..55d43a04e
--- a/src/test/test_channel.c
+++ b/src/test/test_channel.c
@@@ -523,162 -640,152 +523,162 @@@ test_channel_dumpstats(void *arg
return;
}
+/* Test outbound cell. The callstack is:
+ * channel_flush_some_cells()
+ * -> channel_flush_from_first_active_circuit()
+ * -> channel_write_packed_cell()
+ * -> write_packed_cell()
+ * -> chan->write_packed_cell() fct ptr.
+ *
+ * This test goes from a cell in a circuit up to the channel write handler
+ * that should put them on the connection outbuf. */
static void
-test_channel_flush(void *arg)
+test_channel_outbound_cell(void *arg)
{
- channel_t *ch = NULL;
- cell_t *cell = NULL;
- packed_cell_t *p_cell = NULL;
- var_cell_t *v_cell = NULL;
- int init_count;
-
- (void)arg;
+ int old_count;
+ channel_t *chan = NULL;
+ packed_cell_t *p_cell = NULL, *p_cell2 = NULL;
+ origin_circuit_t *circ = NULL;
+ cell_queue_t *queue;
- ch = new_fake_channel();
- tt_assert(ch);
+ (void) arg;
- /* Cache the original count */
- init_count = test_cells_written;
+ /* The channel will be freed so we need to hijack this so the scheduler
+ * doesn't get confused. */
+ MOCK(scheduler_release_channel, scheduler_release_channel_mock);
- /* Stop accepting so we can queue some */
- test_chan_accept_cells = 0;
+ /* Accept cells to lower layer */
+ test_chan_accept_cells = 1;
- /* Queue a regular cell */
- cell = tor_malloc_zero(sizeof(cell_t));
- make_fake_cell(cell);
- channel_write_cell(ch, cell);
- /* It should be queued, so assert that we didn't write it */
- tt_int_op(test_cells_written, OP_EQ, init_count);
-
- /* Queue a var cell */
- v_cell = tor_malloc_zero(sizeof(var_cell_t) + CELL_PAYLOAD_SIZE);
- make_fake_var_cell(v_cell);
- channel_write_var_cell(ch, v_cell);
- /* It should be queued, so assert that we didn't write it */
- tt_int_op(test_cells_written, OP_EQ, init_count);
-
- /* Try a packed cell now */
+ /* Setup a valid circuit to queue a cell. */
+ circ = origin_circuit_new();
+ tt_assert(circ);
+ /* Circuit needs an origin purpose to be considered origin. */
+ TO_CIRCUIT(circ)->purpose = CIRCUIT_PURPOSE_C_GENERAL;
+ TO_CIRCUIT(circ)->n_circ_id = 42;
+ /* This is the outbound test so use the next channel queue. */
+ queue = &TO_CIRCUIT(circ)->n_chan_cells;
+ /* Setup packed cell to queue on the circuit. */
p_cell = packed_cell_new();
tt_assert(p_cell);
- channel_write_packed_cell(ch, p_cell);
- /* It should be queued, so assert that we didn't write it */
- tt_int_op(test_cells_written, OP_EQ, init_count);
-
- /* Now allow writes through again */
- test_chan_accept_cells = 1;
-
- /* ...and flush */
- channel_flush_cells(ch);
-
- /* All three should have gone through */
- tt_int_op(test_cells_written, OP_EQ, init_count + 3);
-
- done:
- tor_free(ch);
-
- return;
-}
-
-/**
- * Channel flush tests that require cmux mocking
- */
-
-static void
-test_channel_flushmux(void *arg)
-{
- channel_t *ch = NULL;
- int old_count, q_len_before, q_len_after;
- ssize_t result;
-
- (void)arg;
-
- /* Install mocks we need for this test */
- MOCK(channel_flush_from_first_active_circuit,
- chan_test_channel_flush_from_first_active_circuit_mock);
- MOCK(circuitmux_num_cells,
- chan_test_circuitmux_num_cells_mock);
-
- ch = new_fake_channel();
- tt_assert(ch);
- ch->cmux = circuitmux_alloc();
-
+ p_cell2 = packed_cell_new();
+ tt_assert(p_cell2);
+ /* Setup a channel to put the circuit on. */
+ chan = new_fake_channel();
+ tt_assert(chan);
+ chan->state = CHANNEL_STATE_OPENING;
+ channel_change_state_open(chan);
+ /* Outbound channel. */
+ channel_mark_outgoing(chan);
+ /* Try to register it so we can clean it through the channel cleanup
+ * process. */
+ channel_register(chan);
+ tt_int_op(chan->registered, OP_EQ, 1);
+ /* Set EWMA policy so we can pick it when flushing. */
+ channel_set_cmux_policy_everywhere(&ewma_policy);
+ tt_ptr_op(circuitmux_get_policy(chan->cmux), OP_EQ, &ewma_policy);
+
+ /* Register circuit to the channel circid map which will attach the circuit
+ * to the channel's cmux as well. */
+ circuit_set_n_circid_chan(TO_CIRCUIT(circ), 42, chan);
+ tt_int_op(channel_num_circuits(chan), OP_EQ, 1);
+ tt_assert(!TO_CIRCUIT(circ)->next_active_on_n_chan);
+ tt_assert(!TO_CIRCUIT(circ)->prev_active_on_n_chan);
+ /* Test the cmux state. */
+ tt_ptr_op(TO_CIRCUIT(circ)->n_mux, OP_EQ, chan->cmux);
+ tt_int_op(circuitmux_is_circuit_attached(chan->cmux, TO_CIRCUIT(circ)),
+ OP_EQ, 1);
+
+ /* Flush the channel without any cell on it. */
old_count = test_cells_written;
-
- test_target_cmux = ch->cmux;
- test_cmux_cells = 1;
-
- /* Enable cell acceptance */
- test_chan_accept_cells = 1;
-
- result = channel_flush_some_cells(ch, 1);
-
- tt_int_op(result, OP_EQ, 1);
+ ssize_t flushed = channel_flush_some_cells(chan, 1);
+ tt_i64_op(flushed, OP_EQ, 0);
+ tt_int_op(test_cells_written, OP_EQ, old_count);
+ tt_int_op(channel_more_to_flush(chan), OP_EQ, 0);
+ tt_int_op(circuitmux_num_active_circuits(chan->cmux), OP_EQ, 0);
+ tt_int_op(circuitmux_num_cells(chan->cmux), OP_EQ, 0);
+ tt_int_op(circuitmux_is_circuit_active(chan->cmux, TO_CIRCUIT(circ)),
+ OP_EQ, 0);
+ tt_u64_op(chan->n_cells_xmitted, OP_EQ, 0);
+ tt_u64_op(chan->n_bytes_xmitted, OP_EQ, 0);
+
+ /* Queue cell onto the next queue that is the outbound direction. Than
+ * update its cmux so the circuit can be picked when flushing cells. */
+ cell_queue_append(queue, p_cell);
+ p_cell = NULL;
+ tt_int_op(queue->n, OP_EQ, 1);
+ cell_queue_append(queue, p_cell2);
+ p_cell2 = NULL;
+ tt_int_op(queue->n, OP_EQ, 2);
+
+ update_circuit_on_cmux(TO_CIRCUIT(circ), CELL_DIRECTION_OUT);
+ tt_int_op(circuitmux_num_active_circuits(chan->cmux), OP_EQ, 1);
+ tt_int_op(circuitmux_num_cells(chan->cmux), OP_EQ, 2);
+ tt_int_op(circuitmux_is_circuit_active(chan->cmux, TO_CIRCUIT(circ)),
+ OP_EQ, 1);
+
+ /* From this point on, we have a queued cell on an active circuit attached
+ * to the channel's cmux. */
+
+ /* Flush the first cell. This is going to go down the call stack. */
+ old_count = test_cells_written;
+ flushed = channel_flush_some_cells(chan, 1);
+ tt_i64_op(flushed, OP_EQ, 1);
tt_int_op(test_cells_written, OP_EQ, old_count + 1);
- tt_int_op(test_cmux_cells, OP_EQ, 0);
-
- /* Now try it without accepting to force them into the queue */
- test_chan_accept_cells = 0;
- test_cmux_cells = 1;
- q_len_before = chan_cell_queue_len(&(ch->outgoing_queue));
-
- result = channel_flush_some_cells(ch, 1);
-
- /* We should not have actually flushed any */
- tt_int_op(result, OP_EQ, 0);
+ tt_int_op(circuitmux_num_cells(chan->cmux), OP_EQ, 1);
+ tt_int_op(channel_more_to_flush(chan), OP_EQ, 1);
+ /* Circuit should remain active because there is a second cell queued. */
+ tt_int_op(circuitmux_is_circuit_active(chan->cmux, TO_CIRCUIT(circ)),
+ OP_EQ, 1);
+ /* Should still be attached. */
+ tt_int_op(circuitmux_is_circuit_attached(chan->cmux, TO_CIRCUIT(circ)),
+ OP_EQ, 1);
+ tt_u64_op(chan->n_cells_xmitted, OP_EQ, 1);
+ tt_u64_op(chan->n_bytes_xmitted, OP_EQ, get_cell_network_size(0));
+
+ /* Flush second cell. This is going to go down the call stack. */
+ old_count = test_cells_written;
+ flushed = channel_flush_some_cells(chan, 1);
+ tt_i64_op(flushed, OP_EQ, 1);
tt_int_op(test_cells_written, OP_EQ, old_count + 1);
- /* But we should have gotten to the fake cellgen loop */
- tt_int_op(test_cmux_cells, OP_EQ, 0);
- /* ...and we should have a queued cell */
- q_len_after = chan_cell_queue_len(&(ch->outgoing_queue));
- tt_int_op(q_len_after, OP_EQ, q_len_before + 1);
-
- /* Now accept cells again and drain the queue */
- test_chan_accept_cells = 1;
- channel_flush_cells(ch);
- tt_int_op(test_cells_written, OP_EQ, old_count + 2);
- tt_int_op(chan_cell_queue_len(&(ch->outgoing_queue)), OP_EQ, 0);
-
- test_target_cmux = NULL;
- test_cmux_cells = 0;
+ tt_int_op(circuitmux_num_cells(chan->cmux), OP_EQ, 0);
+ tt_int_op(channel_more_to_flush(chan), OP_EQ, 0);
+ /* No more cells should make the circuit inactive. */
+ tt_int_op(circuitmux_is_circuit_active(chan->cmux, TO_CIRCUIT(circ)),
+ OP_EQ, 0);
+ /* Should still be attached. */
+ tt_int_op(circuitmux_is_circuit_attached(chan->cmux, TO_CIRCUIT(circ)),
+ OP_EQ, 1);
+ tt_u64_op(chan->n_cells_xmitted, OP_EQ, 2);
+ tt_u64_op(chan->n_bytes_xmitted, OP_EQ, get_cell_network_size(0) * 2);
done:
- if (ch)
- circuitmux_free(ch->cmux);
- tor_free(ch);
-
- UNMOCK(channel_flush_from_first_active_circuit);
- UNMOCK(circuitmux_num_cells);
-
- test_chan_accept_cells = 0;
-
- return;
+ if (circ) {
- circuit_free(TO_CIRCUIT(circ));
++ circuit_free_(TO_CIRCUIT(circ));
+ }
+ tor_free(p_cell);
+ channel_free_all();
+ UNMOCK(scheduler_release_channel);
}
+/* Test inbound cell. The callstack is:
+ * channel_process_cell()
+ * -> chan->cell_handler()
+ *
+ * This test is about checking if we can process an inbound cell down to the
+ * channel handler. */
static void
-test_channel_incoming(void *arg)
+test_channel_inbound_cell(void *arg)
{
- channel_t *ch = NULL;
+ channel_t *chan = NULL;
cell_t *cell = NULL;
- var_cell_t *var_cell = NULL;
int old_count;
- (void)arg;
+ (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);
+ /* The channel will be freed so we need to hijack this so the scheduler
+ * doesn't get confused. */
+ MOCK(scheduler_release_channel, scheduler_release_channel_mock);
/* Accept cells to lower layer */
test_chan_accept_cells = 1;
_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits