Merge remote-tracking branch 'public/bug11243_squashed'

1 files changed, 507 insertions, 2 deletions

diff --git a/src/test/test_dir.c b/src/test/test_dir.c
index 3042ec281f..e03efbeff5 100644
--- a/src/test/test_dir.c
+++ b/src/test/test_dir.c
@@ -186,7 +186,7 @@ test_dir_formats(void *arg)
   buf = router_dump_router_to_string(r1, pk2);
   tt_assert(buf);
   cp = buf;
-  rp1 = router_parse_entry_from_string((const char*)cp,NULL,1,0,NULL);
+  rp1 = router_parse_entry_from_string((const char*)cp,NULL,1,0,NULL,NULL);
   tt_assert(rp1);
   tt_int_op(rp1->addr,==, r1->addr);
   tt_int_op(rp1->or_port,==, r1->or_port);
@@ -231,7 +231,7 @@ test_dir_formats(void *arg)
 
   buf = router_dump_router_to_string(r2, pk1);
   cp = buf;
-  rp2 = router_parse_entry_from_string((const char*)cp,NULL,1,0,NULL);
+  rp2 = router_parse_entry_from_string((const char*)cp,NULL,1,0,NULL,NULL);
   tt_assert(rp2);
   tt_int_op(rp2->addr,==, r2->addr);
   tt_int_op(rp2->or_port,==, r2->or_port);
@@ -294,6 +294,506 @@ test_dir_formats(void *arg)
   tor_free(dir2); /* And more !*/
 }
 
+#include "failing_routerdescs.inc"
+
+static void
+test_dir_routerparse_bad(void *arg)
+{
+  (void) arg;
+
+  int again;
+  routerinfo_t *ri = NULL;
+
+#define CHECK_OK(s)                                                     \
+  do {                                                                  \
+    routerinfo_free(ri);                                                \
+    ri = router_parse_entry_from_string((s), NULL, 0, 0, NULL, NULL);   \
+    tt_assert(ri);                                                      \
+  } while (0)
+#define CHECK_FAIL(s, againval)                                         \
+  do {                                                                  \
+    routerinfo_free(ri);                                                \
+    again = 999;                                                        \
+    ri = router_parse_entry_from_string((s), NULL, 0, 0, NULL, &again); \
+    tt_assert(ri == NULL);                                              \
+    tt_int_op(again, ==, (againval));                                   \
+  } while (0)
+
+  CHECK_OK(EX_RI_MINIMAL);
+  CHECK_OK(EX_RI_MAXIMAL);
+
+  /* good annotations prepended */
+  routerinfo_free(ri);
+  ri = router_parse_entry_from_string(EX_RI_MINIMAL, NULL, 0, 0,
+                                      "@purpose bridge\n", NULL);
+  tt_assert(ri != NULL);
+  tt_assert(ri->purpose == ROUTER_PURPOSE_BRIDGE);
+  routerinfo_free(ri);
+
+  /* bad annotations prepended. */
+  ri = router_parse_entry_from_string(EX_RI_MINIMAL,
+                                      NULL, 0, 0, "@purpose\n", NULL);
+  tt_assert(ri == NULL);
+
+  /* bad annotations on router. */
+  ri = router_parse_entry_from_string("@purpose\nrouter x\n", NULL, 0, 1,
+                                      NULL, NULL);
+  tt_assert(ri == NULL);
+
+  /* unwanted annotations on router. */
+  ri = router_parse_entry_from_string("@purpose foo\nrouter x\n", NULL, 0, 0,
+                                      NULL, NULL);
+  tt_assert(ri == NULL);
+
+  /* No signature. */
+  ri = router_parse_entry_from_string("router x\n", NULL, 0, 0,
+                                      NULL, NULL);
+  tt_assert(ri == NULL);
+
+  /* Not a router */
+  routerinfo_free(ri);
+  ri = router_parse_entry_from_string("hello\n", NULL, 0, 0, NULL, NULL);
+  tt_assert(ri == NULL);
+
+  CHECK_FAIL(EX_RI_BAD_SIG1, 1);
+  CHECK_FAIL(EX_RI_BAD_SIG2, 1);
+  CHECK_FAIL(EX_RI_BAD_TOKENS, 0);
+  CHECK_FAIL(EX_RI_BAD_PUBLISHED, 0);
+  CHECK_FAIL(EX_RI_NEG_BANDWIDTH, 0);
+  CHECK_FAIL(EX_RI_BAD_BANDWIDTH, 0);
+  CHECK_FAIL(EX_RI_BAD_BANDWIDTH2, 0);
+  CHECK_FAIL(EX_RI_BAD_ONIONKEY1, 0);
+  CHECK_FAIL(EX_RI_BAD_ONIONKEY2, 0);
+  CHECK_FAIL(EX_RI_BAD_PORTS, 0);
+  CHECK_FAIL(EX_RI_BAD_IP, 0);
+  CHECK_FAIL(EX_RI_BAD_DIRPORT, 0);
+  CHECK_FAIL(EX_RI_BAD_NAME2, 0);
+  CHECK_FAIL(EX_RI_BAD_UPTIME, 0);
+
+  CHECK_FAIL(EX_RI_BAD_BANDWIDTH3, 0);
+  CHECK_FAIL(EX_RI_BAD_NTOR_KEY, 0);
+  CHECK_FAIL(EX_RI_BAD_FINGERPRINT, 0);
+  CHECK_FAIL(EX_RI_MISMATCHED_FINGERPRINT, 0);
+  CHECK_FAIL(EX_RI_BAD_HAS_ACCEPT6, 0);
+  CHECK_FAIL(EX_RI_BAD_NO_EXIT_POLICY, 0);
+  CHECK_FAIL(EX_RI_BAD_IPV6_EXIT_POLICY, 0);
+  CHECK_FAIL(EX_RI_BAD_FAMILY, 0);
+  CHECK_FAIL(EX_RI_ZERO_ORPORT, 0);
+
+  /* This is allowed; we just ignore it. */
+  CHECK_OK(EX_RI_BAD_EI_DIGEST);
+
+#undef CHECK_FAIL
+#undef CHECK_OK
+ done:
+  routerinfo_free(ri);
+}
+
+#include "example_extrainfo.inc"
+
+static void
+test_dir_extrainfo_parsing(void *arg)
+{
+  (void) arg;
+
+#define CHECK_OK(s)                                                     \
+  do {                                                                  \
+    extrainfo_free(ei);                                                 \
+    ei = extrainfo_parse_entry_from_string((s), NULL, 0, map, NULL);    \
+    tt_assert(ei);                                                      \
+  } while (0)
+#define CHECK_FAIL(s, againval)                                         \
+  do {                                                                  \
+    extrainfo_free(ei);                                                 \
+    again = 999;                                                        \
+    ei = extrainfo_parse_entry_from_string((s), NULL, 0, map, &again);  \
+    tt_assert(ei == NULL);                                              \
+    tt_int_op(again, ==, (againval));                                   \
+  } while (0)
+#define ADD(name)                                                       \
+  do {                                                                  \
+    ri = tor_malloc_zero(sizeof(routerinfo_t));                         \
+    crypto_pk_t *pk = ri->identity_pkey = crypto_pk_new();              \
+    tt_assert(! crypto_pk_read_public_key_from_string(pk,               \
+                                      name##_KEY, strlen(name##_KEY))); \
+    tt_int_op(0,==,base16_decode(d, 20, name##_FP, strlen(name##_FP))); \
+    digestmap_set((digestmap_t*)map, d, ri);                            \
+    ri = NULL;                                                          \
+  } while (0)
+
+  routerinfo_t *ri = NULL;
+  char d[20];
+  struct digest_ri_map_t *map = NULL;
+  extrainfo_t *ei = NULL;
+  int again;
+
+  CHECK_OK(EX_EI_MINIMAL);
+  tt_assert(ei->pending_sig);
+  CHECK_OK(EX_EI_MAXIMAL);
+  tt_assert(ei->pending_sig);
+
+  map = (struct digest_ri_map_t *)digestmap_new();
+  ADD(EX_EI_MINIMAL);
+  ADD(EX_EI_MAXIMAL);
+  ADD(EX_EI_BAD_FP);
+  ADD(EX_EI_BAD_NICKNAME);
+  ADD(EX_EI_BAD_TOKENS);
+  ADD(EX_EI_BAD_START);
+  ADD(EX_EI_BAD_PUBLISHED);
+
+  CHECK_OK(EX_EI_MINIMAL);
+  tt_assert(!ei->pending_sig);
+  CHECK_OK(EX_EI_MAXIMAL);
+  tt_assert(!ei->pending_sig);
+
+  CHECK_FAIL(EX_EI_BAD_SIG1,1);
+  CHECK_FAIL(EX_EI_BAD_SIG2,1);
+  CHECK_FAIL(EX_EI_BAD_SIG3,1);
+  CHECK_FAIL(EX_EI_BAD_FP,0);
+  CHECK_FAIL(EX_EI_BAD_NICKNAME,0);
+  CHECK_FAIL(EX_EI_BAD_TOKENS,0);
+  CHECK_FAIL(EX_EI_BAD_START,0);
+  CHECK_FAIL(EX_EI_BAD_PUBLISHED,0);
+
+#undef CHECK_OK
+#undef CHECK_FAIL
+
+ done:
+  routerinfo_free(ri);
+  /* XXXX elements should get freed too */
+  digestmap_free((digestmap_t*)map, NULL);
+}
+
+static void
+test_dir_parse_router_list(void *arg)
+{
+  (void) arg;
+  smartlist_t *invalid = smartlist_new();
+  smartlist_t *dest = smartlist_new();
+  smartlist_t *chunks = smartlist_new();
+  int dest_has_ri = 1;
+  char *list = NULL;
+  const char *cp;
+  digestmap_t *map = NULL;
+  char *mem_op_hex_tmp = NULL;
+  routerinfo_t *ri = NULL;
+  char d[DIGEST_LEN];
+
+  smartlist_add(chunks, tor_strdup(EX_RI_MINIMAL));     // ri 0
+  smartlist_add(chunks, tor_strdup(EX_RI_BAD_PORTS));   // bad ri 0
+  smartlist_add(chunks, tor_strdup(EX_EI_MAXIMAL));     // ei 0
+  smartlist_add(chunks, tor_strdup(EX_EI_BAD_SIG2));    // bad ei --
+  smartlist_add(chunks, tor_strdup(EX_EI_BAD_NICKNAME));// bad ei 0
+  smartlist_add(chunks, tor_strdup(EX_RI_BAD_SIG1));    // bad ri --
+  smartlist_add(chunks, tor_strdup(EX_EI_BAD_PUBLISHED));  // bad ei 1
+  smartlist_add(chunks, tor_strdup(EX_RI_MAXIMAL));     // ri 1
+  smartlist_add(chunks, tor_strdup(EX_RI_BAD_FAMILY));  // bad ri 1
+  smartlist_add(chunks, tor_strdup(EX_EI_MINIMAL));     // ei 1
+
+  list = smartlist_join_strings(chunks, "", 0, NULL);
+
+  /* First, parse the routers. */
+  cp = list;
+  tt_int_op(0,==,
+            router_parse_list_from_string(&cp, NULL, dest, SAVED_NOWHERE,
+                                          0, 0, NULL, invalid));
+  tt_int_op(2, ==, smartlist_len(dest));
+  tt_ptr_op(cp, ==, list + strlen(list));
+
+  routerinfo_t *r = smartlist_get(dest, 0);
+  tt_mem_op(r->cache_info.signed_descriptor_body, ==,
+            EX_RI_MINIMAL, strlen(EX_RI_MINIMAL));
+  r = smartlist_get(dest, 1);
+  tt_mem_op(r->cache_info.signed_descriptor_body, ==,
+            EX_RI_MAXIMAL, strlen(EX_RI_MAXIMAL));
+
+  tt_int_op(2, ==, smartlist_len(invalid));
+  test_memeq_hex(smartlist_get(invalid, 0),
+                 "ab9eeaa95e7d45740185b4e519c76ead756277a9");
+  test_memeq_hex(smartlist_get(invalid, 1),
+                 "9a651ee03b64325959e8f1b46f2b689b30750b4c");
+
+  /* Now tidy up */
+  SMARTLIST_FOREACH(dest, routerinfo_t *, ri, routerinfo_free(ri));
+  SMARTLIST_FOREACH(invalid, uint8_t *, d, tor_free(d));
+  smartlist_clear(dest);
+  smartlist_clear(invalid);
+
+  /* And check extrainfos. */
+  dest_has_ri = 0;
+  map = (digestmap_t*)router_get_routerlist()->identity_map;
+  ADD(EX_EI_MINIMAL);
+  ADD(EX_EI_MAXIMAL);
+  ADD(EX_EI_BAD_NICKNAME);
+  ADD(EX_EI_BAD_PUBLISHED);
+  cp = list;
+  tt_int_op(0,==,
+            router_parse_list_from_string(&cp, NULL, dest, SAVED_NOWHERE,
+                                          1, 0, NULL, invalid));
+  tt_int_op(2, ==, smartlist_len(dest));
+  extrainfo_t *e = smartlist_get(dest, 0);
+  tt_mem_op(e->cache_info.signed_descriptor_body, ==,
+            EX_EI_MAXIMAL, strlen(EX_EI_MAXIMAL));
+  e = smartlist_get(dest, 1);
+  tt_mem_op(e->cache_info.signed_descriptor_body, ==,
+            EX_EI_MINIMAL, strlen(EX_EI_MINIMAL));
+
+  tt_int_op(2, ==, smartlist_len(invalid));
+  test_memeq_hex(smartlist_get(invalid, 0),
+                 "d5df4aa62ee9ffc9543d41150c9864908e0390af");
+  test_memeq_hex(smartlist_get(invalid, 1),
+                 "f61efd2a7f4531f3687a9043e0de90a862ec64ba");
+
+ done:
+  tor_free(list);
+  if (dest_has_ri)
+    SMARTLIST_FOREACH(dest, routerinfo_t *, rt, routerinfo_free(rt));
+  else
+    SMARTLIST_FOREACH(dest, extrainfo_t *, ei, extrainfo_free(ei));
+  smartlist_free(dest);
+  SMARTLIST_FOREACH(invalid, uint8_t *, d, tor_free(d));
+  smartlist_free(invalid);
+  SMARTLIST_FOREACH(chunks, char *, cp, tor_free(cp));
+  smartlist_free(chunks);
+  routerinfo_free(ri);
+  /* XXXX this leaks: */
+  if (map) {
+    digestmap_free((digestmap_t*)map, NULL);
+    router_get_routerlist()->identity_map =
+      (struct digest_ri_map_t*)digestmap_new();
+  }
+  tor_free(mem_op_hex_tmp);
+
+#undef ADD
+}
+
+static download_status_t dls_minimal;
+static download_status_t dls_maximal;
+static download_status_t dls_bad_fingerprint;
+static download_status_t dls_bad_sig2;
+static download_status_t dls_bad_ports;
+static download_status_t dls_bad_tokens;
+
+static int mock_router_get_dl_status_unrecognized = 0;
+static int mock_router_get_dl_status_calls = 0;
+
+static download_status_t *
+mock_router_get_dl_status(const char *d)
+{
+  ++mock_router_get_dl_status_calls;
+  char hex[HEX_DIGEST_LEN+1];
+  base16_encode(hex, sizeof(hex), d, DIGEST_LEN);
+  if (!strcmp(hex, "3E31D19A69EB719C00B02EC60D13356E3F7A3452")) {
+    return &dls_minimal;
+  } else if (!strcmp(hex, "581D8A368A0FA854ECDBFAB841D88B3F1B004038")) {
+    return &dls_maximal;
+  } else if (!strcmp(hex, "2578AE227C6116CDE29B3F0E95709B9872DEE5F1")) {
+    return &dls_bad_fingerprint;
+  } else if (!strcmp(hex, "16D387D3A58F7DB3CF46638F8D0B90C45C7D769C")) {
+    return &dls_bad_sig2;
+  } else if (!strcmp(hex, "AB9EEAA95E7D45740185B4E519C76EAD756277A9")) {
+    return &dls_bad_ports;
+  } else if (!strcmp(hex, "A0CC2CEFAD59DBF19F468BFEE60E0868C804B422")) {
+    return &dls_bad_tokens;
+  } else {
+    ++mock_router_get_dl_status_unrecognized;
+    return NULL;
+  }
+}
+
+static void
+test_dir_load_routers(void *arg)
+{
+  (void) arg;
+  smartlist_t *chunks = smartlist_new();
+  smartlist_t *wanted = smartlist_new();
+  char buf[DIGEST_LEN];
+  char *mem_op_hex_tmp = NULL;
+
+#define ADD(str)                                                        \
+  do {                                                                  \
+    tt_int_op(0,==,router_get_router_hash(str, strlen(str), buf));      \
+    smartlist_add(wanted, tor_strdup(hex_str(buf, DIGEST_LEN)));        \
+  } while (0)
+
+  MOCK(router_get_dl_status_by_descriptor_digest, mock_router_get_dl_status);
+
+  update_approx_time(1412510400);
+
+  smartlist_add(chunks, tor_strdup(EX_RI_MINIMAL));
+  smartlist_add(chunks, tor_strdup(EX_RI_BAD_FINGERPRINT));
+  smartlist_add(chunks, tor_strdup(EX_RI_BAD_SIG2));
+  smartlist_add(chunks, tor_strdup(EX_RI_MAXIMAL));
+  smartlist_add(chunks, tor_strdup(EX_RI_BAD_PORTS));
+  smartlist_add(chunks, tor_strdup(EX_RI_BAD_TOKENS));
+
+  /* not ADDing MINIMIAL */
+  ADD(EX_RI_MAXIMAL);
+  ADD(EX_RI_BAD_FINGERPRINT);
+  ADD(EX_RI_BAD_SIG2);
+  /* Not ADDing BAD_PORTS */
+  ADD(EX_RI_BAD_TOKENS);
+
+  char *list = smartlist_join_strings(chunks, "", 0, NULL);
+  tt_int_op(1, ==,
+            router_load_routers_from_string(list, NULL, SAVED_IN_JOURNAL,
+                                            wanted, 1, NULL));
+
+  /* The "maximal" router was added. */
+  /* "minimal" was not. */
+  tt_int_op(smartlist_len(router_get_routerlist()->routers),==,1);
+  routerinfo_t *r = smartlist_get(router_get_routerlist()->routers, 0);
+  test_memeq_hex(r->cache_info.signed_descriptor_digest,
+                 "581D8A368A0FA854ECDBFAB841D88B3F1B004038");
+  tt_int_op(dls_minimal.n_download_failures, ==, 0);
+  tt_int_op(dls_maximal.n_download_failures, ==, 0);
+
+  /* "Bad fingerprint" and "Bad tokens" should have gotten marked
+   * non-retriable. */
+  tt_want_int_op(mock_router_get_dl_status_calls, ==, 2);
+  tt_want_int_op(mock_router_get_dl_status_unrecognized, ==, 0);
+  tt_int_op(dls_bad_fingerprint.n_download_failures, ==, 255);
+  tt_int_op(dls_bad_tokens.n_download_failures, ==, 255);
+
+  /* bad_sig2 and bad ports" are retriable -- one since only the signature
+   * was bad, and one because we didn't ask for it. */
+  tt_int_op(dls_bad_sig2.n_download_failures, ==, 0);
+  tt_int_op(dls_bad_ports.n_download_failures, ==, 0);
+
+  /* Wanted still contains "BAD_SIG2" */
+  tt_int_op(smartlist_len(wanted), ==, 1);
+  tt_str_op(smartlist_get(wanted, 0), ==,
+            "E0A3753CEFD54128EAB239F294954121DB23D2EF");
+
+#undef ADD
+
+ done:
+  tor_free(mem_op_hex_tmp);
+  UNMOCK(router_get_dl_status_by_descriptor_digest);
+  SMARTLIST_FOREACH(chunks, char *, cp, tor_free(cp));
+  smartlist_free(chunks);
+  SMARTLIST_FOREACH(wanted, char *, cp, tor_free(cp));
+  smartlist_free(wanted);
+}
+
+static int mock_get_by_ei_dd_calls = 0;
+static int mock_get_by_ei_dd_unrecognized = 0;
+
+static signed_descriptor_t sd_ei_minimal;
+static signed_descriptor_t sd_ei_bad_nickname;
+static signed_descriptor_t sd_ei_maximal;
+static signed_descriptor_t sd_ei_bad_tokens;
+static signed_descriptor_t sd_ei_bad_sig2;
+
+static signed_descriptor_t *
+mock_get_by_ei_desc_digest(const char *d)
+{
+
+  ++mock_get_by_ei_dd_calls;
+  char hex[HEX_DIGEST_LEN+1];
+  base16_encode(hex, sizeof(hex), d, DIGEST_LEN);
+
+  if (!strcmp(hex, "11E0EDF526950739F7769810FCACAB8C882FAEEE")) {
+    return &sd_ei_minimal;
+  } else if (!strcmp(hex, "47803B02A0E70E9E8BDA226CB1D74DE354D67DFF")) {
+    return &sd_ei_maximal;
+  } else if (!strcmp(hex, "D5DF4AA62EE9FFC9543D41150C9864908E0390AF")) {
+    return &sd_ei_bad_nickname;
+  } else if (!strcmp(hex, "16D387D3A58F7DB3CF46638F8D0B90C45C7D769C")) {
+    return &sd_ei_bad_sig2;
+  } else if (!strcmp(hex, "9D90F8C42955BBC57D54FB05E54A3F083AF42E8B")) {
+    return &sd_ei_bad_tokens;
+  } else {
+    ++mock_get_by_ei_dd_unrecognized;
+    return NULL;
+  }
+}
+
+static smartlist_t *mock_ei_insert_list = NULL;
+static was_router_added_t
+mock_ei_insert(routerlist_t *rl, extrainfo_t *ei)
+{
+  (void) rl;
+  smartlist_add(mock_ei_insert_list, ei);
+  return ROUTER_ADDED_SUCCESSFULLY;
+}
+
+static void
+test_dir_load_extrainfo(void *arg)
+{
+  (void) arg;
+  smartlist_t *chunks = smartlist_new();
+  smartlist_t *wanted = smartlist_new();
+  char buf[DIGEST_LEN];
+  char *mem_op_hex_tmp = NULL;
+
+#define ADD(str)                                                        \
+  do {                                                                  \
+    tt_int_op(0,==,router_get_extrainfo_hash(str, strlen(str), buf));   \
+    smartlist_add(wanted, tor_strdup(hex_str(buf, DIGEST_LEN)));        \
+  } while (0)
+
+  mock_ei_insert_list = smartlist_new();
+  MOCK(router_get_by_extrainfo_digest, mock_get_by_ei_desc_digest);
+  MOCK(extrainfo_insert, mock_ei_insert);
+
+  smartlist_add(chunks, tor_strdup(EX_EI_MINIMAL));
+  smartlist_add(chunks, tor_strdup(EX_EI_BAD_NICKNAME));
+  smartlist_add(chunks, tor_strdup(EX_EI_MAXIMAL));
+  smartlist_add(chunks, tor_strdup(EX_EI_BAD_PUBLISHED));
+  smartlist_add(chunks, tor_strdup(EX_EI_BAD_TOKENS));
+
+  /* not ADDing MINIMIAL */
+  ADD(EX_EI_MAXIMAL);
+  ADD(EX_EI_BAD_NICKNAME);
+  /* Not ADDing BAD_PUBLISHED */
+  ADD(EX_EI_BAD_TOKENS);
+  ADD(EX_EI_BAD_SIG2);
+
+  char *list = smartlist_join_strings(chunks, "", 0, NULL);
+  router_load_extrainfo_from_string(list, NULL, SAVED_IN_JOURNAL, wanted, 1);
+
+  /* The "maximal" router was added. */
+  /* "minimal" was also added, even though we didn't ask for it, since
+   * that's what we do with extrainfos. */
+  tt_int_op(smartlist_len(mock_ei_insert_list),==,2);
+
+  extrainfo_t *e = smartlist_get(mock_ei_insert_list, 0);
+  test_memeq_hex(e->cache_info.signed_descriptor_digest,
+                 "11E0EDF526950739F7769810FCACAB8C882FAEEE");
+
+  e = smartlist_get(mock_ei_insert_list, 1);
+  test_memeq_hex(e->cache_info.signed_descriptor_digest,
+                 "47803B02A0E70E9E8BDA226CB1D74DE354D67DFF");
+  tt_int_op(dls_minimal.n_download_failures, ==, 0);
+  tt_int_op(dls_maximal.n_download_failures, ==, 0);
+
+  /* "Bad nickname" and "Bad tokens" should have gotten marked
+   * non-retriable. */
+  tt_want_int_op(mock_get_by_ei_dd_calls, ==, 2);
+  tt_want_int_op(mock_get_by_ei_dd_unrecognized, ==, 0);
+  tt_int_op(sd_ei_bad_nickname.ei_dl_status.n_download_failures, ==, 255);
+  tt_int_op(sd_ei_bad_tokens.ei_dl_status.n_download_failures, ==, 255);
+
+  /* bad_ports is retriable -- because we didn't ask for it. */
+  tt_int_op(dls_bad_ports.n_download_failures, ==, 0);
+
+  /* Wanted still contains "BAD_SIG2" */
+  tt_int_op(smartlist_len(wanted), ==, 1);
+  tt_str_op(smartlist_get(wanted, 0), ==,
+            "16D387D3A58F7DB3CF46638F8D0B90C45C7D769C");
+
+#undef ADD
+
+ done:
+  tor_free(mem_op_hex_tmp);
+  UNMOCK(router_get_by_extrainfo_digest);
+  SMARTLIST_FOREACH(chunks, char *, cp, tor_free(cp));
+  smartlist_free(chunks);
+  SMARTLIST_FOREACH(wanted, char *, cp, tor_free(cp));
+  smartlist_free(wanted);
+}
+
 static void
 test_dir_versions(void *arg)
 {
@@ -2393,6 +2893,11 @@ test_dir_http_handling(void *args)
 struct testcase_t dir_tests[] = {
   DIR_LEGACY(nicknames),
   DIR_LEGACY(formats),
+  DIR(routerparse_bad, 0),
+  DIR(extrainfo_parsing, 0),
+  DIR(parse_router_list, TT_FORK),
+  DIR(load_routers, TT_FORK),
+  DIR(load_extrainfo, TT_FORK),
   DIR_LEGACY(versions),
   DIR_LEGACY(fp_pairs),
   DIR(split_fps, 0),