Add the entrynodes.c unit tests.

src/test/include.am

@@ -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

@@ -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,0 +1,572 @@
+/* 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
+};
+