|
|
@@ -45,41 +45,6 @@ get_or_state_replacement(void)
|
|
|
return dummy_state;
|
|
|
}
|
|
|
|
|
|
-#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
|
-/* 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)
|
|
|
-{
|
|
|
- (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. */
|
|
|
- helper_setup_fake_routerlist();
|
|
|
-
|
|
|
- /* Return anything but NULL (it's interpreted as test fail) */
|
|
|
- return dummy_state;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
static networkstatus_t *dummy_consensus = NULL;
|
|
|
|
|
|
static smartlist_t *big_fake_net_nodes = NULL;
|
|
|
@@ -202,697 +167,6 @@ mock_get_options(void)
|
|
|
return &mocked_options;
|
|
|
}
|
|
|
|
|
|
-#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
|
-/** 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;
|
|
|
-
|
|
|
- MOCK(get_options, mock_get_options);
|
|
|
-
|
|
|
- /* Check that we get a guard if it passes preferred
|
|
|
- * address settings */
|
|
|
- memset(&mocked_options, 0, sizeof(mocked_options));
|
|
|
- mocked_options.ClientUseIPv4 = 1;
|
|
|
- mocked_options.ClientPreferIPv6ORPort = 0;
|
|
|
- mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
|
-
|
|
|
- /* 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. */
|
|
|
- tt_assert(chosen_entry);
|
|
|
-
|
|
|
- /* And with the other IP version active */
|
|
|
- mocked_options.ClientUseIPv6 = 1;
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
- tt_assert(chosen_entry);
|
|
|
-
|
|
|
- /* And with the preference on auto */
|
|
|
- mocked_options.ClientPreferIPv6ORPort = -1;
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
- tt_assert(chosen_entry);
|
|
|
-
|
|
|
- /* Check that we don't get a guard if it doesn't pass mandatory address
|
|
|
- * settings */
|
|
|
- memset(&mocked_options, 0, sizeof(mocked_options));
|
|
|
- mocked_options.ClientUseIPv4 = 0;
|
|
|
- mocked_options.ClientPreferIPv6ORPort = 0;
|
|
|
- mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
|
-
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
-
|
|
|
- /* If we don't allow IPv4 at all, we don't get a guard*/
|
|
|
- tt_assert(!chosen_entry);
|
|
|
-
|
|
|
- /* Check that we get a guard if it passes allowed but not preferred address
|
|
|
- * settings */
|
|
|
- memset(&mocked_options, 0, sizeof(mocked_options));
|
|
|
- mocked_options.ClientUseIPv4 = 1;
|
|
|
- mocked_options.ClientUseIPv6 = 1;
|
|
|
- mocked_options.ClientPreferIPv6ORPort = 1;
|
|
|
- mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
|
-
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
- tt_assert(chosen_entry);
|
|
|
-
|
|
|
- /* Check that we get a guard if it passes preferred address settings when
|
|
|
- * they're auto */
|
|
|
- memset(&mocked_options, 0, sizeof(mocked_options));
|
|
|
- mocked_options.ClientUseIPv4 = 1;
|
|
|
- mocked_options.ClientPreferIPv6ORPort = -1;
|
|
|
- mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
|
-
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
- tt_assert(chosen_entry);
|
|
|
-
|
|
|
- /* And with IPv6 active */
|
|
|
- mocked_options.ClientUseIPv6 = 1;
|
|
|
-
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
- tt_assert(chosen_entry);
|
|
|
-
|
|
|
- done:
|
|
|
- memset(&mocked_options, 0, sizeof(mocked_options));
|
|
|
- UNMOCK(get_options);
|
|
|
-}
|
|
|
-
|
|
|
-/** 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;
|
|
|
-
|
|
|
- MOCK(get_options, mock_get_options);
|
|
|
-
|
|
|
- /* 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;
|
|
|
-
|
|
|
- /* Check that we get the guard if it passes preferred
|
|
|
- * address settings */
|
|
|
- memset(&mocked_options, 0, sizeof(mocked_options));
|
|
|
- mocked_options.ClientUseIPv4 = 1;
|
|
|
- mocked_options.ClientPreferIPv6ORPort = 0;
|
|
|
- mocked_options.UseDeprecatedGuardAlgorithm = 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, OP_EQ, the_guard);
|
|
|
-
|
|
|
- /* And with the other IP version active */
|
|
|
- mocked_options.ClientUseIPv6 = 1;
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
- tt_ptr_op(chosen_entry, OP_EQ, the_guard);
|
|
|
-
|
|
|
- /* And with the preference on auto */
|
|
|
- mocked_options.ClientPreferIPv6ORPort = -1;
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
- tt_ptr_op(chosen_entry, OP_EQ, the_guard);
|
|
|
-
|
|
|
- /* Check that we don't get a guard if it doesn't pass mandatory address
|
|
|
- * settings */
|
|
|
- memset(&mocked_options, 0, sizeof(mocked_options));
|
|
|
- mocked_options.ClientUseIPv4 = 0;
|
|
|
- mocked_options.ClientPreferIPv6ORPort = 0;
|
|
|
- mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
|
-
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
-
|
|
|
- /* If we don't allow IPv4 at all, we don't get a guard*/
|
|
|
- tt_assert(!chosen_entry);
|
|
|
-
|
|
|
- /* Check that we get a node if it passes allowed but not preferred
|
|
|
- * address settings */
|
|
|
- memset(&mocked_options, 0, sizeof(mocked_options));
|
|
|
- mocked_options.ClientUseIPv4 = 1;
|
|
|
- mocked_options.ClientUseIPv6 = 1;
|
|
|
- mocked_options.ClientPreferIPv6ORPort = 1;
|
|
|
- mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
|
-
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
-
|
|
|
- /* We disable the guard check and the preferred address check at the same
|
|
|
- * time, so we can't be sure we get the guard */
|
|
|
- tt_assert(chosen_entry);
|
|
|
-
|
|
|
- /* Check that we get a node if it is allowed but not preferred when settings
|
|
|
- * are auto */
|
|
|
- memset(&mocked_options, 0, sizeof(mocked_options));
|
|
|
- mocked_options.ClientUseIPv4 = 1;
|
|
|
- mocked_options.ClientPreferIPv6ORPort = -1;
|
|
|
- mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
|
-
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
-
|
|
|
- /* We disable the guard check and the preferred address check at the same
|
|
|
- * time, so we can't be sure we get the guard */
|
|
|
- tt_assert(chosen_entry);
|
|
|
-
|
|
|
- /* and with IPv6 active */
|
|
|
- mocked_options.ClientUseIPv6 = 1;
|
|
|
-
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
- tt_assert(chosen_entry);
|
|
|
-
|
|
|
- done:
|
|
|
- memset(&mocked_options, 0, sizeof(mocked_options));
|
|
|
- UNMOCK(get_options);
|
|
|
-}
|
|
|
-
|
|
|
-/** 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();
|
|
|
- guard_selection_t *gs = get_guard_selection_info();
|
|
|
- const smartlist_t *all_entry_guards =
|
|
|
- get_entry_guards_for_guard_selection(gs);
|
|
|
- or_options_t *options = get_options_mutable();
|
|
|
- int retval;
|
|
|
-
|
|
|
- /* Set NumEntryGuards to the provided number. */
|
|
|
- options->NumEntryGuards = num_needed;
|
|
|
- tt_int_op(num_needed, OP_EQ, decide_num_guards(options, 0));
|
|
|
-
|
|
|
- /* The global entry guards smartlist should be empty now. */
|
|
|
- tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);
|
|
|
-
|
|
|
- /* Walk the nodelist and add all nodes as entry guards. */
|
|
|
- our_nodelist = nodelist_get_list();
|
|
|
- tt_int_op(smartlist_len(our_nodelist), OP_EQ, HELPER_NUMBER_OF_DESCRIPTORS);
|
|
|
-
|
|
|
- SMARTLIST_FOREACH_BEGIN(our_nodelist, const node_t *, node) {
|
|
|
- const node_t *node_tmp;
|
|
|
- node_tmp = add_an_entry_guard(gs, node, 0, 1, 0, 0);
|
|
|
- tt_assert(node_tmp);
|
|
|
- } SMARTLIST_FOREACH_END(node);
|
|
|
-
|
|
|
- /* Make sure the nodes were added as entry guards. */
|
|
|
- tt_int_op(smartlist_len(all_entry_guards), OP_EQ,
|
|
|
- HELPER_NUMBER_OF_DESCRIPTORS);
|
|
|
-
|
|
|
- /* Ensure that all the possible entry guards are enough to satisfy us. */
|
|
|
- tt_int_op(smartlist_len(all_entry_guards), OP_GE, 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, OP_EQ, 1);
|
|
|
-
|
|
|
- } 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, OP_EQ, 0);
|
|
|
- tt_int_op(smartlist_len(live_entry_guards), OP_EQ, 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, OP_EQ, 0);
|
|
|
- tt_int_op(smartlist_len(live_entry_guards), OP_EQ, 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, OP_EQ, 1);
|
|
|
- tt_int_op(smartlist_len(live_entry_guards), OP_EQ, 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_options_t *options = get_options_mutable();
|
|
|
- options->UseDeprecatedGuardAlgorithm = 1;
|
|
|
- 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 = get_yesterday_date_str();
|
|
|
- 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), OP_EQ, 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, OP_GE, 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), OP_EQ, 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, OP_EQ, nickname); /* Verify nickname */
|
|
|
-
|
|
|
- base16_encode(hex_digest, sizeof(hex_digest),
|
|
|
- e->identity, DIGEST_LEN);
|
|
|
- tt_str_op(hex_digest, OP_EQ, fpr); /* Verify fingerprint */
|
|
|
-
|
|
|
- tt_assert(e->is_dir_cache); /* Verify dirness */
|
|
|
-
|
|
|
- tt_str_op(e->chosen_by_version, OP_EQ, tor_version); /* Verify 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, OP_EQ, unlisted_since);
|
|
|
-
|
|
|
- /* The rest should be unset */
|
|
|
- tt_assert(!e->unreachable_since);
|
|
|
- tt_assert(!e->can_retry);
|
|
|
- tt_assert(!e->pb.path_bias_noticed);
|
|
|
- tt_assert(!e->pb.path_bias_warned);
|
|
|
- tt_assert(!e->pb.path_bias_extreme);
|
|
|
- tt_assert(!e->pb.path_bias_disabled);
|
|
|
- tt_assert(!e->pb.path_bias_use_noticed);
|
|
|
- tt_assert(!e->pb.path_bias_use_extreme);
|
|
|
- tt_assert(!e->last_attempted);
|
|
|
- }
|
|
|
-
|
|
|
- done:
|
|
|
- state_lines_free(entry_state_lines);
|
|
|
- or_state_free(state);
|
|
|
- tor_free(msg);
|
|
|
-}
|
|
|
-
|
|
|
-/** 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_options_t *options = get_options_mutable();
|
|
|
- options->UseDeprecatedGuardAlgorithm = 1;
|
|
|
- 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), OP_EQ, 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 "
|
|
|
- "%s", get_yesterday_date_str());
|
|
|
- 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, OP_GE, 0);
|
|
|
-
|
|
|
- /* Test that the guard was registered */
|
|
|
- all_entry_guards = get_entry_guards();
|
|
|
- tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 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->pb.circ_attempts, OP_EQ, (int)circ_attempts);
|
|
|
- tt_int_op((int)e->pb.circ_successes, OP_EQ, (int)circ_successes);
|
|
|
- tt_int_op((int)e->pb.successful_circuits_closed, OP_EQ,
|
|
|
- (int)successful_closed);
|
|
|
- tt_int_op((int)e->pb.timeouts, OP_EQ, (int)timeouts);
|
|
|
- tt_int_op((int)e->pb.collapsed_circuits, OP_EQ, (int)collapsed);
|
|
|
- tt_int_op((int)e->pb.unusable_circuits, OP_EQ, (int)unusable);
|
|
|
- }
|
|
|
-
|
|
|
- done:
|
|
|
- or_state_free(state);
|
|
|
- state_lines_free(entry_state_lines);
|
|
|
- tor_free(msg);
|
|
|
-}
|
|
|
-
|
|
|
-/* 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();
|
|
|
- options->UseDeprecatedGuardAlgorithm = 1;
|
|
|
- guard_selection_t *gs = get_guard_selection_info();
|
|
|
- const smartlist_t *all_entry_guards =
|
|
|
- get_entry_guards_for_guard_selection(gs);
|
|
|
- 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, OP_GE, 0);
|
|
|
-
|
|
|
- /* Read nodes from EntryNodes */
|
|
|
- entry_guards_set_from_config(gs, options);
|
|
|
-
|
|
|
- /* Test that only one guard was added. */
|
|
|
- tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 1);
|
|
|
-
|
|
|
- /* Make sure it was the guard we specified. */
|
|
|
- chosen_entry = choose_random_entry(NULL);
|
|
|
- tt_str_op(chosen_entry->ri->nickname, OP_EQ, entrynodes_str);
|
|
|
-
|
|
|
- done:
|
|
|
- routerset_free(options->EntryNodes);
|
|
|
-}
|
|
|
-
|
|
|
-static void
|
|
|
-test_entry_is_time_to_retry(void *arg)
|
|
|
-{
|
|
|
- entry_guard_t *test_guard;
|
|
|
- time_t now;
|
|
|
- int retval;
|
|
|
- (void)arg;
|
|
|
-
|
|
|
- now = time(NULL);
|
|
|
-
|
|
|
- test_guard = tor_malloc_zero(sizeof(entry_guard_t));
|
|
|
-
|
|
|
- test_guard->last_attempted = now - 10;
|
|
|
- test_guard->unreachable_since = now - 1;
|
|
|
-
|
|
|
- retval = entry_is_time_to_retry(test_guard,now);
|
|
|
- tt_int_op(retval,OP_EQ,1);
|
|
|
-
|
|
|
- test_guard->unreachable_since = now - (6*60*60 - 1);
|
|
|
- test_guard->last_attempted = now - (60*60 + 1);
|
|
|
-
|
|
|
- retval = entry_is_time_to_retry(test_guard,now);
|
|
|
- tt_int_op(retval,OP_EQ,1);
|
|
|
-
|
|
|
- test_guard->last_attempted = now - (60*60 - 1);
|
|
|
-
|
|
|
- retval = entry_is_time_to_retry(test_guard,now);
|
|
|
- tt_int_op(retval,OP_EQ,0);
|
|
|
-
|
|
|
- test_guard->unreachable_since = now - (6*60*60 + 1);
|
|
|
- test_guard->last_attempted = now - (4*60*60 + 1);
|
|
|
-
|
|
|
- retval = entry_is_time_to_retry(test_guard,now);
|
|
|
- tt_int_op(retval,OP_EQ,1);
|
|
|
-
|
|
|
- test_guard->unreachable_since = now - (3*24*60*60 - 1);
|
|
|
- test_guard->last_attempted = now - (4*60*60 + 1);
|
|
|
-
|
|
|
- retval = entry_is_time_to_retry(test_guard,now);
|
|
|
- tt_int_op(retval,OP_EQ,1);
|
|
|
-
|
|
|
- test_guard->unreachable_since = now - (3*24*60*60 + 1);
|
|
|
- test_guard->last_attempted = now - (18*60*60 + 1);
|
|
|
-
|
|
|
- retval = entry_is_time_to_retry(test_guard,now);
|
|
|
- tt_int_op(retval,OP_EQ,1);
|
|
|
-
|
|
|
- test_guard->unreachable_since = now - (7*24*60*60 - 1);
|
|
|
- test_guard->last_attempted = now - (18*60*60 + 1);
|
|
|
-
|
|
|
- retval = entry_is_time_to_retry(test_guard,now);
|
|
|
- tt_int_op(retval,OP_EQ,1);
|
|
|
-
|
|
|
- test_guard->last_attempted = now - (18*60*60 - 1);
|
|
|
-
|
|
|
- retval = entry_is_time_to_retry(test_guard,now);
|
|
|
- tt_int_op(retval,OP_EQ,0);
|
|
|
-
|
|
|
- test_guard->unreachable_since = now - (7*24*60*60 + 1);
|
|
|
- test_guard->last_attempted = now - (36*60*60 + 1);
|
|
|
-
|
|
|
- retval = entry_is_time_to_retry(test_guard,now);
|
|
|
- tt_int_op(retval,OP_EQ,1);
|
|
|
-
|
|
|
- test_guard->unreachable_since = now - (7*24*60*60 + 1);
|
|
|
- test_guard->last_attempted = now - (36*60*60 + 1);
|
|
|
-
|
|
|
- retval = entry_is_time_to_retry(test_guard,now);
|
|
|
- tt_int_op(retval,OP_EQ,1);
|
|
|
-
|
|
|
- done:
|
|
|
- tor_free(test_guard);
|
|
|
-}
|
|
|
-
|
|
|
-/** XXX Do some tests that entry_is_live() */
|
|
|
-static void
|
|
|
-test_entry_is_live(void *arg)
|
|
|
-{
|
|
|
- smartlist_t *our_nodelist = NULL;
|
|
|
- guard_selection_t *gs = get_guard_selection_info();
|
|
|
- const smartlist_t *all_entry_guards =
|
|
|
- get_entry_guards_for_guard_selection(gs);
|
|
|
- const node_t *test_node = NULL;
|
|
|
- const entry_guard_t *test_entry = NULL;
|
|
|
- const char *msg;
|
|
|
- int which_node;
|
|
|
-
|
|
|
- (void) arg;
|
|
|
-
|
|
|
- /* The global entry guards smartlist should be empty now. */
|
|
|
- tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);
|
|
|
-
|
|
|
- /* Walk the nodelist and add all nodes as entry guards. */
|
|
|
- our_nodelist = nodelist_get_list();
|
|
|
- tt_int_op(smartlist_len(our_nodelist), OP_EQ, HELPER_NUMBER_OF_DESCRIPTORS);
|
|
|
-
|
|
|
- SMARTLIST_FOREACH_BEGIN(our_nodelist, const node_t *, node) {
|
|
|
- const node_t *node_tmp;
|
|
|
- node_tmp = add_an_entry_guard(gs, node, 0, 1, 0, 0);
|
|
|
- tt_assert(node_tmp);
|
|
|
-
|
|
|
- tt_int_op(node->is_stable, OP_EQ, 0);
|
|
|
- tt_int_op(node->is_fast, OP_EQ, 0);
|
|
|
- } SMARTLIST_FOREACH_END(node);
|
|
|
-
|
|
|
- /* Make sure the nodes were added as entry guards. */
|
|
|
- tt_int_op(smartlist_len(all_entry_guards), OP_EQ,
|
|
|
- HELPER_NUMBER_OF_DESCRIPTORS);
|
|
|
-
|
|
|
- /* Now get a random test entry that we will use for this unit test. */
|
|
|
- which_node = 3; /* (chosen by fair dice roll) */
|
|
|
- test_entry = smartlist_get(all_entry_guards, which_node);
|
|
|
-
|
|
|
- /* Let's do some entry_is_live() tests! */
|
|
|
-
|
|
|
- /* Require the node to be stable, but it's not. Should fail.
|
|
|
- Also enable 'assume_reachable' because why not. */
|
|
|
- test_node = entry_is_live(test_entry,
|
|
|
- ENTRY_NEED_UPTIME | ENTRY_ASSUME_REACHABLE,
|
|
|
- &msg);
|
|
|
- tt_assert(!test_node);
|
|
|
-
|
|
|
- /* Require the node to be fast, but it's not. Should fail. */
|
|
|
- test_node = entry_is_live(test_entry,
|
|
|
- ENTRY_NEED_CAPACITY | ENTRY_ASSUME_REACHABLE,
|
|
|
- &msg);
|
|
|
- tt_assert(!test_node);
|
|
|
-
|
|
|
- /* Don't impose any restrictions on the node. Should succeed. */
|
|
|
- test_node = entry_is_live(test_entry, 0, &msg);
|
|
|
- tt_assert(test_node);
|
|
|
- tt_ptr_op(test_node, OP_EQ, node_get_by_id(test_entry->identity));
|
|
|
-
|
|
|
- /* Require descriptor for this node. It has one so it should succeed. */
|
|
|
- test_node = entry_is_live(test_entry, ENTRY_NEED_DESCRIPTOR, &msg);
|
|
|
- tt_assert(test_node);
|
|
|
- tt_ptr_op(test_node, OP_EQ, node_get_by_id(test_entry->identity));
|
|
|
-
|
|
|
- done:
|
|
|
- ; /* XXX */
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
#define TEST_IPV4_ADDR "123.45.67.89"
|
|
|
#define TEST_IPV6_ADDR "[1234:5678:90ab:cdef::]"
|
|
|
|
|
|
@@ -1473,14 +747,6 @@ test_entry_guard_parse_from_state_broken(void *arg)
|
|
|
gs_df = get_guard_selection_by_name("default", GS_TYPE_NORMAL, 0);
|
|
|
tt_assert(gs_df != NULL);
|
|
|
tt_int_op(smartlist_len(gs_df->sampled_entry_guards), OP_EQ, 1);
|
|
|
- guard_selection_t *gs_legacy =
|
|
|
- get_guard_selection_by_name("legacy", GS_TYPE_LEGACY, 0);
|
|
|
-#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
|
- tt_assert(gs_legacy != NULL);
|
|
|
- tt_int_op(smartlist_len(gs_legacy->chosen_entry_guards), OP_EQ, 0);
|
|
|
-#else
|
|
|
- tt_assert(gs_legacy == NULL);
|
|
|
-#endif
|
|
|
|
|
|
done:
|
|
|
config_free_lines(lines);
|
|
|
@@ -1520,17 +786,6 @@ test_entry_guard_get_guard_selection_by_name(void *arg)
|
|
|
tt_assert(gs3 != gs1);
|
|
|
tt_assert(gs3 == get_guard_selection_info());
|
|
|
|
|
|
- or_options_t *options = get_options_mutable();
|
|
|
- options->UseDeprecatedGuardAlgorithm = 1;
|
|
|
- update_guard_selection_choice(options);
|
|
|
- guard_selection_t *gs4 = get_guard_selection_info();
|
|
|
- tt_assert(gs4 != gs3);
|
|
|
- tt_assert(gs4 == get_guard_selection_by_name("legacy", GS_TYPE_LEGACY, 1));
|
|
|
-
|
|
|
- options->UseDeprecatedGuardAlgorithm = 0;
|
|
|
- update_guard_selection_choice(options);
|
|
|
- tt_assert(gs3 == get_guard_selection_info());
|
|
|
-
|
|
|
done:
|
|
|
entry_guards_free_all();
|
|
|
}
|
|
|
@@ -1555,14 +810,6 @@ test_entry_guard_choose_selection_initial(void *arg)
|
|
|
tt_int_op(type, OP_EQ, GS_TYPE_BRIDGE);
|
|
|
get_options_mutable()->UseBridges = 0;
|
|
|
|
|
|
- /* If we're using legacy guards, we get the legacy selection */
|
|
|
- get_options_mutable()->UseDeprecatedGuardAlgorithm = 1;
|
|
|
- name = choose_guard_selection(get_options(),
|
|
|
- dummy_consensus, NULL, &type);
|
|
|
- tt_str_op(name, OP_EQ, "legacy");
|
|
|
- tt_int_op(type, OP_EQ, GS_TYPE_LEGACY);
|
|
|
- get_options_mutable()->UseDeprecatedGuardAlgorithm = 0;
|
|
|
-
|
|
|
/* If we discard >99% of our guards, though, we should be in the restricted
|
|
|
* set. */
|
|
|
tt_assert(get_options_mutable()->EntryNodes == NULL);
|
|
|
@@ -3361,12 +2608,6 @@ test_enty_guard_should_expire_waiting(void *arg)
|
|
|
tor_free(fake_state);
|
|
|
}
|
|
|
|
|
|
-#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
|
-static const struct testcase_setup_t fake_network = {
|
|
|
- fake_network_setup, fake_network_cleanup
|
|
|
-};
|
|
|
-#endif
|
|
|
-
|
|
|
static const struct testcase_setup_t big_fake_network = {
|
|
|
big_fake_network_setup, big_fake_network_cleanup
|
|
|
};
|
|
|
@@ -3383,33 +2624,6 @@ static const struct testcase_setup_t upgrade_circuits = {
|
|
|
(void*)(arg) }
|
|
|
|
|
|
struct testcase_t entrynodes_tests[] = {
|
|
|
-#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
|
- { "entry_is_time_to_retry", test_entry_is_time_to_retry,
|
|
|
- TT_FORK, NULL, NULL },
|
|
|
- { "choose_random_entry_no_guards", test_choose_random_entry_no_guards,
|
|
|
- TT_FORK, &fake_network, NULL },
|
|
|
- { "choose_random_entry_one_possible_guard",
|
|
|
- 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 },
|
|
|
- { "entry_is_live",
|
|
|
- test_entry_is_live,
|
|
|
- TT_FORK, &fake_network, NULL },
|
|
|
-#endif
|
|
|
{ "node_preferred_orport",
|
|
|
test_node_preferred_orport,
|
|
|
0, NULL, NULL },
|
Nick Mathewson