Skip to content
Snippets Groups Projects
Commit a8fcdbf4 authored by George Kadianakis's avatar George Kadianakis
Browse files

Add the entrynodes.c unit tests.

parent 4245662b
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/test/include.am
+ 1
− 0
View file @ a8fcdbf4
......@@ -28,6 +28,7 @@ src_test_test_SOURCES = \
src/test/test_cell_queue.c \
src/test/test_data.c \
src/test/test_dir.c \
src/test/test_entrynodes.c \
src/test/test_extorport.c \
src/test/test_introduce.c \
src/test/test_logging.c \
......
src/test/test.c
+ 2
− 0
View file @ a8fcdbf4
......@@ -1306,6 +1306,7 @@ extern struct testcase_t circuitmux_tests[];
extern struct testcase_t cell_queue_tests[];
extern struct testcase_t options_tests[];
extern struct testcase_t socks_tests[];
extern struct testcase_t entrynodes_tests[];
extern struct testcase_t extorport_tests[];
extern struct testcase_t controller_event_tests[];
extern struct testcase_t logging_tests[];
......@@ -1337,6 +1338,7 @@ static struct testgroup_t testgroups[] = {
{ "circuitlist/", circuitlist_tests },
{ "circuitmux/", circuitmux_tests },
{ "options/", options_tests },
{ "entrynodes/", entrynodes_tests },
{ "extorport/", extorport_tests },
{ "control/", controller_event_tests },
{ "hs/", hs_tests },
......
src/test/test_entrynodes.c 0 → 100644
+ 572
− 0
View file @ a8fcdbf4
/* Copyright (c) 2014, The Tor Project, Inc. */
/* See LICENSE for licensing information */
#include "orconfig.h"
#define STATEFILE_PRIVATE
#define ENTRYNODES_PRIVATE
#define ROUTERLIST_PRIVATE
#include "or.h"
#include "test.h"
#include "entrynodes.h"
#include "routerparse.h"
#include "nodelist.h"
#include "util.h"
#include "routerlist.h"
#include "routerset.h"
#include "statefile.h"
#include "config.h"
/* TODO:
* choose_random_entry() test with state set.
*
* parse_state() tests with more than one guards.
*
* More tests for set_from_config(): Multiple nodes, use fingerprints,
* use country codes.
*/
/** Dummy Tor state used in unittests. */
static or_state_t *dummy_state = NULL;
static or_state_t *
get_or_state_replacement(void)
{
return dummy_state;
}
/* NOP replacement for router_descriptor_is_too_old() */
static int
router_descriptor_is_too_old_replacement(const routerinfo_t *router)
{
(void) router;
return 0;
}
/* Number of descriptors contained in test_descriptors.txt. */
#define NUMBER_OF_DESCRIPTORS 8
/** Parse a file containing router descriptors and load them to our
routerlist. This function is used to setup an artificial network
so that we can conduct entry guard tests. */
static void
setup_fake_routerlist(const char *fname)
{
int retval;
char *contents = NULL;
struct stat st;
routerlist_t *our_routerlist = NULL;
smartlist_t *our_nodelist = NULL;
/* Read the file that contains our test descriptors. */
test_assert(file_status(fname) == FN_FILE);
contents = read_file_to_str(fname, RFTS_BIN|RFTS_IGNORE_MISSING, &st);
test_assert(contents);
/* We need to mock this function otherwise the descriptors will not
accepted as they are too old. */
MOCK(router_descriptor_is_too_old,
router_descriptor_is_too_old_replacement);
/* Load all the test descriptors to the routerlist. */
retval = router_load_routers_from_string(contents, NULL, SAVED_IN_JOURNAL,
NULL, 0, NULL);
tt_int_op(retval, ==, NUMBER_OF_DESCRIPTORS);
/* Sanity checking of routerlist and nodelist. */
our_routerlist = router_get_routerlist();
tt_int_op(smartlist_len(our_routerlist->routers), ==, NUMBER_OF_DESCRIPTORS);
routerlist_assert_ok(our_routerlist);
our_nodelist = nodelist_get_list();
tt_int_op(smartlist_len(our_nodelist), ==, NUMBER_OF_DESCRIPTORS);
/* Mark all routers as non-guards but up and running! */
SMARTLIST_FOREACH_BEGIN(our_nodelist, node_t *, node) {
node->is_running = 1;
node->is_valid = 1;
node->is_possible_guard = 0;
} SMARTLIST_FOREACH_END(node);
done:
UNMOCK(router_descriptor_is_too_old);
tor_free(contents);
}
/* Unittest cleanup function: Cleanup the fake network. */
static int
fake_network_cleanup(const struct testcase_t *testcase, void *ptr)
{
(void) testcase;
(void) ptr;
routerlist_free_all();
nodelist_free_all();
entry_guards_free_all();
or_state_free(dummy_state);
return 1; /* NOP */
}
/* Unittest setup function: Setup a fake network. */
static void *
fake_network_setup(const struct testcase_t *testcase)
{
/* This is the file containing our test descriptors. */
const char *fname = BUILDDIR "/src/test/test_descriptors.txt";
(void) testcase;
/* Setup fake state */
dummy_state = tor_malloc_zero(sizeof(or_state_t));
MOCK(get_or_state,
get_or_state_replacement);
/* Setup fake routerlist. */
setup_fake_routerlist(fname);
/* Return anything but NULL (it's interpreted as test fail) */
return dummy_state;
}
/** Test choose_random_entry() with none of our routers being guard nodes. */
static void
test_choose_random_entry_no_guards(void *arg)
{
const node_t *chosen_entry = NULL;
(void) arg;
/* Try to pick an entry even though none of our routers are guards. */
chosen_entry = choose_random_entry(NULL);
/* Unintuitively, we actually pick a random node as our entry,
because router_choose_random_node() relaxes its constraints if it
can't find a proper entry guard. */
test_assert(chosen_entry);
done:
;
}
/** Test choose_random_entry() with only one of our routers being a
guard node. */
static void
test_choose_random_entry_one_possible_guard(void *arg)
{
const node_t *chosen_entry = NULL;
node_t *the_guard = NULL;
smartlist_t *our_nodelist = NULL;
(void) arg;
/* Set one of the nodes to be a guard. */
our_nodelist = nodelist_get_list();
the_guard = smartlist_get(our_nodelist, 4); /* chosen by fair dice roll */
the_guard->is_possible_guard = 1;
/* Pick an entry. Make sure we pick the node we marked as guard. */
chosen_entry = choose_random_entry(NULL);
tt_ptr_op(chosen_entry, ==, the_guard);
done:
;
}
/** Helper to conduct tests for populate_live_entry_guards().
This test adds some entry guards to our list, and then tests
populate_live_entry_guards() to mke sure it filters them correctly.
<b>num_needed</b> is the number of guard nodes we support. It's
configurable to make sure we function properly with 1 or 3 guard
nodes configured.
*/
static void
populate_live_entry_guards_test_helper(int num_needed)
{
smartlist_t *our_nodelist = NULL;
smartlist_t *live_entry_guards = smartlist_new();
const smartlist_t *all_entry_guards = get_entry_guards();
or_options_t *options = get_options_mutable();
int retval;
/* Set NumEntryGuards to the provided number. */
options->NumEntryGuards = num_needed;
tt_int_op(num_needed, ==, decide_num_guards(options, 0));
/* The global entry guards smartlist should be empty now. */
tt_int_op(smartlist_len(all_entry_guards), ==, 0);
/* Walk the nodelist and add all nodes as entry guards. */
our_nodelist = nodelist_get_list();
tt_int_op(smartlist_len(our_nodelist), ==, NUMBER_OF_DESCRIPTORS);
SMARTLIST_FOREACH_BEGIN(our_nodelist, const node_t *, node) {
const node_t *node_tmp;
node_tmp = add_an_entry_guard(node, 0, 1, 0, 0);
test_assert(node_tmp);
} SMARTLIST_FOREACH_END(node);
/* Make sure the nodes were added as entry guards. */
tt_int_op(smartlist_len(all_entry_guards), ==, NUMBER_OF_DESCRIPTORS);
/* Ensure that all the possible entry guards are enough to satisfy us. */
tt_int_op(smartlist_len(all_entry_guards), >=, num_needed);
/* Walk the entry guard list for some sanity checking */
SMARTLIST_FOREACH_BEGIN(all_entry_guards, const entry_guard_t *, entry) {
/* Since we called add_an_entry_guard() with 'for_discovery' being
False, all guards should have made_contact enabled. */
tt_int_op(entry->made_contact, ==, 1);
/* Since we don't have a routerstatus, all of the entry guards are
not directory servers. */
tt_int_op(entry->is_dir_cache, ==, 0);
} SMARTLIST_FOREACH_END(entry);
/* First, try to get some fast guards. This should fail. */
retval = populate_live_entry_guards(live_entry_guards,
all_entry_guards,
NULL,
NO_DIRINFO, /* Don't care about DIRINFO*/
0, 0,
1); /* We want fast guard! */
tt_int_op(retval, ==, 0);
tt_int_op(smartlist_len(live_entry_guards), ==, 0);
/* Now try to get some stable guards. This should fail too. */
retval = populate_live_entry_guards(live_entry_guards,
all_entry_guards,
NULL,
NO_DIRINFO,
0,
1, /* We want stable guard! */
0);
tt_int_op(retval, ==, 0);
tt_int_op(smartlist_len(live_entry_guards), ==, 0);
/* Now try to get any guard we can find. This should succeed. */
retval = populate_live_entry_guards(live_entry_guards,
all_entry_guards,
NULL,
NO_DIRINFO,
0, 0, 0); /* No restrictions! */
/* Since we had more than enough guards in 'all_entry_guards', we
should have added 'num_needed' of them to live_entry_guards.
'retval' should be 1 since we now have enough live entry guards
to pick one. */
tt_int_op(retval, ==, 1);
tt_int_op(smartlist_len(live_entry_guards), ==, num_needed);
done:
smartlist_free(live_entry_guards);
}
/* Test populate_live_entry_guards() for 1 guard node. */
static void
test_populate_live_entry_guards_1guard(void *arg)
{
(void) arg;
populate_live_entry_guards_test_helper(1);
}
/* Test populate_live_entry_guards() for 3 guard nodes. */
static void
test_populate_live_entry_guards_3guards(void *arg)
{
(void) arg;
populate_live_entry_guards_test_helper(3);
}
/** Append some EntryGuard lines to the Tor state at <b>state</b>.
<b>entry_guard_lines</b> is a smartlist containing 2-tuple
smartlists that carry the key and values of the statefile.
As an example:
entry_guard_lines =
(("EntryGuard", "name 67E72FF33D7D41BF11C569646A0A7B4B188340DF DirCache"),
("EntryGuardDownSince", "2014-06-07 16:02:46 2014-06-07 16:02:46"))
*/
static void
state_insert_entry_guard_helper(or_state_t *state,
smartlist_t *entry_guard_lines)
{
config_line_t **next, *line;
next = &state->EntryGuards;
*next = NULL;
/* Loop over all the state lines in the smartlist */
SMARTLIST_FOREACH_BEGIN(entry_guard_lines, const smartlist_t *,state_lines) {
/* Get key and value for each line */
const char *state_key = smartlist_get(state_lines, 0);
const char *state_value = smartlist_get(state_lines, 1);
*next = line = tor_malloc_zero(sizeof(config_line_t));
line->key = tor_strdup(state_key);
tor_asprintf(&line->value, "%s", state_value);
next = &(line->next);
} SMARTLIST_FOREACH_END(state_lines);
}
/** Free memory occupied by <b>entry_guard_lines</b>. */
static void
state_lines_free(smartlist_t *entry_guard_lines)
{
SMARTLIST_FOREACH_BEGIN(entry_guard_lines, smartlist_t *, state_lines) {
char *state_key = smartlist_get(state_lines, 0);
char *state_value = smartlist_get(state_lines, 1);
tor_free(state_key);
tor_free(state_value);
smartlist_free(state_lines);
} SMARTLIST_FOREACH_END(state_lines);
smartlist_free(entry_guard_lines);
}
/* Tests entry_guards_parse_state(). It creates a fake Tor state with
a saved entry guard and makes sure that Tor can parse it and
creates the right entry node out of it.
*/
static void
test_entry_guards_parse_state_simple(void *arg)
{
or_state_t *state = or_state_new();
const smartlist_t *all_entry_guards = get_entry_guards();
smartlist_t *entry_state_lines = smartlist_new();
char *msg = NULL;
int retval;
/* Details of our fake guard node */
const char *nickname = "hagbard";
const char *fpr = "B29D536DD1752D542E1FBB3C9CE4449D51298212";
const char *tor_version = "0.2.5.3-alpha-dev";
const char *added_at = "2014-05-22 02:40:47";
const char *unlisted_since = "2014-06-08 16:16:50";
(void) arg;
/* The global entry guards smartlist should be empty now. */
tt_int_op(smartlist_len(all_entry_guards), ==, 0);
{ /* Prepare the state entry */
/* Prepare the smartlist to hold the key/value of each line */
smartlist_t *state_line = smartlist_new();
smartlist_add_asprintf(state_line, "EntryGuard");
smartlist_add_asprintf(state_line, "%s %s %s", nickname, fpr, "DirCache");
smartlist_add(entry_state_lines, state_line);
state_line = smartlist_new();
smartlist_add_asprintf(state_line, "EntryGuardAddedBy");
smartlist_add_asprintf(state_line, "%s %s %s", fpr, tor_version, added_at);
smartlist_add(entry_state_lines, state_line);
state_line = smartlist_new();
smartlist_add_asprintf(state_line, "EntryGuardUnlistedSince");
smartlist_add_asprintf(state_line, "%s", unlisted_since);
smartlist_add(entry_state_lines, state_line);
}
/* Inject our lines in the state */
state_insert_entry_guard_helper(state, entry_state_lines);
/* Parse state */
retval = entry_guards_parse_state(state, 1, &msg);
tt_int_op(retval, >=, 0);
/* Test that the guard was registered.
We need to re-get the entry guard list since its pointer was
overwritten in entry_guards_parse_state(). */
all_entry_guards = get_entry_guards();
tt_int_op(smartlist_len(all_entry_guards), ==, 1);
{ /* Test the entry guard structure */
char hex_digest[1024];
char str_time[1024];
const entry_guard_t *e = smartlist_get(all_entry_guards, 0);
tt_str_op(e->nickname, ==, nickname); /* Verify nickname */
base16_encode(hex_digest, sizeof(hex_digest),
e->identity, DIGEST_LEN);
tt_str_op(hex_digest, ==, fpr); /* Verify fingerprint */
tt_assert(e->is_dir_cache); /* Verify dirness */
tt_str_op(e->chosen_by_version, ==, tor_version); /* Verify tor version */
tt_assert(e->made_contact); /* All saved guards have been contacted */
tt_assert(e->bad_since); /* Verify bad_since timestamp */
format_iso_time(str_time, e->bad_since);
tt_str_op(str_time, ==, unlisted_since);
/* The rest should be unset */
tt_assert(!e->unreachable_since);
tt_assert(!e->can_retry);
tt_assert(!e->path_bias_noticed);
tt_assert(!e->path_bias_warned);
tt_assert(!e->path_bias_extreme);
tt_assert(!e->path_bias_disabled);
tt_assert(!e->path_bias_use_noticed);
tt_assert(!e->path_bias_use_extreme);
tt_assert(!e->last_attempted);
}
done:
state_lines_free(entry_state_lines);
or_state_free(state);
}
/** Similar to test_entry_guards_parse_state_simple() but aims to test
the PathBias-related details of the entry guard. */
static void
test_entry_guards_parse_state_pathbias(void *arg)
{
or_state_t *state = or_state_new();
const smartlist_t *all_entry_guards = get_entry_guards();
char *msg = NULL;
int retval;
smartlist_t *entry_state_lines = smartlist_new();
/* Path bias details of the fake guard */
const double circ_attempts = 9;
const double circ_successes = 8;
const double successful_closed = 4;
const double collapsed = 2;
const double unusable = 0;
const double timeouts = 1;
(void) arg;
/* The global entry guards smartlist should be empty now. */
tt_int_op(smartlist_len(all_entry_guards), ==, 0);
{ /* Prepare the state entry */
/* Prepare the smartlist to hold the key/value of each line */
smartlist_t *state_line = smartlist_new();
smartlist_add_asprintf(state_line, "EntryGuard");
smartlist_add_asprintf(state_line,
"givethanks B29D536DD1752D542E1FBB3C9CE4449D51298212 NoDirCache");
smartlist_add(entry_state_lines, state_line);
state_line = smartlist_new();
smartlist_add_asprintf(state_line, "EntryGuardAddedBy");
smartlist_add_asprintf(state_line,
"B29D536DD1752D542E1FBB3C9CE4449D51298212 0.2.5.3-alpha-dev "
"2014-05-22 02:40:47");
smartlist_add(entry_state_lines, state_line);
state_line = smartlist_new();
smartlist_add_asprintf(state_line, "EntryGuardUnlistedSince");
smartlist_add_asprintf(state_line, "2014-06-08 16:16:50");
smartlist_add(entry_state_lines, state_line);
state_line = smartlist_new();
smartlist_add_asprintf(state_line, "EntryGuardPathBias");
smartlist_add_asprintf(state_line, "%f %f %f %f %f %f",
circ_attempts, circ_successes, successful_closed,
collapsed, unusable, timeouts);
smartlist_add(entry_state_lines, state_line);
}
/* Inject our lines in the state */
state_insert_entry_guard_helper(state, entry_state_lines);
/* Parse state */
retval = entry_guards_parse_state(state, 1, &msg);
tt_int_op(retval, >=, 0);
/* Test that the guard was registered */
all_entry_guards = get_entry_guards();
tt_int_op(smartlist_len(all_entry_guards), ==, 1);
{ /* Test the path bias of this guard */
const entry_guard_t *e = smartlist_get(all_entry_guards, 0);
tt_assert(!e->is_dir_cache);
tt_assert(!e->can_retry);
/* XXX tt_double_op doesn't support equality. Cast to int for now. */
tt_int_op((int)e->circ_attempts, ==, (int)circ_attempts);
tt_int_op((int)e->circ_successes, ==, (int)circ_successes);
tt_int_op((int)e->successful_circuits_closed, ==, (int)successful_closed);
tt_int_op((int)e->timeouts, ==, (int)timeouts);
tt_int_op((int)e->collapsed_circuits, ==, (int)collapsed);
tt_int_op((int)e->unusable_circuits, ==, (int)unusable);
}
done:
or_state_free(state);
state_lines_free(entry_state_lines);
}
/* Simple test of entry_guards_set_from_config() by specifying a
particular EntryNode and making sure it gets picked. */
static void
test_entry_guards_set_from_config(void *arg)
{
or_options_t *options = get_options_mutable();
const smartlist_t *all_entry_guards = get_entry_guards();
const char *entrynodes_str = "test003r";
const node_t *chosen_entry = NULL;
int retval;
(void) arg;
/* Prase EntryNodes as a routerset. */
options->EntryNodes = routerset_new();
retval = routerset_parse(options->EntryNodes,
entrynodes_str,
"test_entrynodes");
tt_int_op(retval, >=, 0);
/* Read nodes from EntryNodes */
entry_guards_set_from_config(options);
/* Test that only one guard was added. */
tt_int_op(smartlist_len(all_entry_guards), ==, 1);
/* Make sure it was the guard we specified. */
chosen_entry = choose_random_entry(NULL);
tt_str_op(chosen_entry->ri->nickname, ==, entrynodes_str);
done:
routerset_free(options->EntryNodes);
}
static const struct testcase_setup_t fake_network = {
fake_network_setup, fake_network_cleanup
};
struct testcase_t entrynodes_tests[] = {
{ "choose_random_entry_no_guards", test_choose_random_entry_no_guards,
TT_FORK, &fake_network, NULL },
{ "choose_random_entry_one_possibleguard",
test_choose_random_entry_one_possible_guard,
TT_FORK, &fake_network, NULL },
{ "populate_live_entry_guards_1guard",
test_populate_live_entry_guards_1guard,
TT_FORK, &fake_network, NULL },
{ "populate_live_entry_guards_3guards",
test_populate_live_entry_guards_3guards,
TT_FORK, &fake_network, NULL },
{ "entry_guards_parse_state_simple",
test_entry_guards_parse_state_simple,
TT_FORK, &fake_network, NULL },
{ "entry_guards_parse_state_pathbias",
test_entry_guards_parse_state_pathbias,
TT_FORK, &fake_network, NULL },
{ "entry_guards_set_from_config",
test_entry_guards_set_from_config,
TT_FORK, &fake_network, NULL },
END_OF_TESTCASES
};
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment