Rip out all of the v2 directory code.

The remaining vestige is that we continue to publish the V2dir flag,
and that, for the controller, we continue to emit v2 directory
formats when requested.

1 files changed, 10 insertions, 233 deletions

diff --git a/src/or/routerlist.c b/src/or/routerlist.c
index c0c4d9a4c0..159f3ff0aa 100644
--- a/src/or/routerlist.c
+++ b/src/or/routerlist.c
@@ -220,8 +220,6 @@ download_status_is_ready_by_sk_in_cl(cert_list_t *cl,
   return rv;
 }
 
-#define get_n_v2_authorities() get_n_authorities(V2_DIRINFO)
-
 /** Helper: Return the cert_list_t for an authority whose authority ID is
  * <b>id_digest</b>, allocating a new list if necessary. */
 static cert_list_t *
@@ -1272,18 +1270,18 @@ router_pick_directory_server(dirinfo_type_t type, int flags)
   return choice;
 }
 
-/** Try to determine which fraction of v2 and v3 directory requests aimed at
- * caches will be sent to us. Set *<b>v2_share_out</b> and
- * *<b>v3_share_out</b> to the fractions of v2 and v3 protocol shares we
- * expect to see, respectively.  Return 0 on success, negative on failure. */
+/** Try to determine which fraction ofv3 directory requests aimed at
+ * caches will be sent to us. Set
+ * *<b>v3_share_out</b> to the fraction of v3 protocol shares we
+ * expect to see.  Return 0 on success, negative on failure. */
+/* XXXX This function is unused. */
 int
-router_get_my_share_of_directory_requests(double *v2_share_out,
-                                          double *v3_share_out)
+router_get_my_share_of_directory_requests(double *v3_share_out)
 {
   const routerinfo_t *me = router_get_my_routerinfo();
   const routerstatus_t *rs;
   const int pds_flags = PDS_ALLOW_SELF|PDS_IGNORE_FASCISTFIREWALL;
-  *v2_share_out = *v3_share_out = 0.0;
+  *v3_share_out = 0.0;
   if (!me)
     return -1;
   rs = router_get_consensus_status_by_id(me->cache_info.identity_digest);
@@ -1292,15 +1290,6 @@ router_get_my_share_of_directory_requests(double *v2_share_out,
 
   /* Calling for side effect */
   /* XXXX This is a bit of a kludge */
-  if (rs->is_v2_dir) {
-    sl_last_total_weighted_bw = 0;
-    router_pick_directory_server(V2_DIRINFO, pds_flags);
-    if (sl_last_total_weighted_bw != 0) {
-      *v2_share_out = U64_TO_DBL(sl_last_weighted_bw_of_me) /
-        U64_TO_DBL(sl_last_total_weighted_bw);
-    }
-  }
-
   {
     sl_last_total_weighted_bw = 0;
     router_pick_directory_server(V3_DIRINFO, pds_flags);
@@ -1472,8 +1461,6 @@ router_pick_directory_server_impl(dirinfo_type_t type, int flags)
     if (requireother && router_digest_is_me(node->identity))
       continue;
     is_trusted = router_digest_is_trusted_dir(node->identity);
-    if ((type & V2_DIRINFO) && !(node->rs->is_v2_dir || is_trusted))
-      continue;
     if ((type & EXTRAINFO_DIRINFO) &&
         !router_supports_extrainfo(node->identity, 0))
       continue;
@@ -1700,7 +1687,6 @@ mark_all_dirservers_up(smartlist_t *server_list)
       routerstatus_t *rs;
       node_t *node;
       dir->is_running = 1;
-      download_status_reset(&dir->v2_ns_dl_status);
       node = node_get_mutable_by_id(dir->digest);
       if (node)
         node->is_running = 1;
@@ -3354,7 +3340,6 @@ router_add_to_routerlist(routerinfo_t *router, const char **msg,
   routerinfo_t *old_router;
   networkstatus_t *consensus =
     networkstatus_get_latest_consensus_by_flavor(FLAV_NS);
-  const smartlist_t *networkstatus_v2_list = networkstatus_get_v2_list();
   int in_consensus = 0;
 
   tor_assert(msg);
@@ -3425,15 +3410,6 @@ router_add_to_routerlist(routerinfo_t *router, const char **msg,
   }
 
   /* We no longer need a router with this descriptor digest. */
-  SMARTLIST_FOREACH(networkstatus_v2_list, networkstatus_v2_t *, ns,
-  {
-    routerstatus_t *rs =
-      networkstatus_v2_find_mutable_entry(ns, id_digest);
-    if (rs && tor_memeq(rs->descriptor_digest,
-                      router->cache_info.signed_descriptor_digest,
-                      DIGEST_LEN))
-      rs->need_to_mirror = 0;
-  });
   if (consensus) {
     routerstatus_t *rs = networkstatus_vote_find_mutable_entry(
                                                      consensus, id_digest);
@@ -3441,7 +3417,6 @@ router_add_to_routerlist(routerinfo_t *router, const char **msg,
                       router->cache_info.signed_descriptor_digest,
                       DIGEST_LEN)) {
       in_consensus = 1;
-      rs->need_to_mirror = 0;
     }
   }
 
@@ -3680,11 +3655,7 @@ routerlist_remove_old_routers(void)
   routerinfo_t *router;
   signed_descriptor_t *sd;
   digestset_t *retain;
-  int caches = directory_caches_dir_info(get_options());
   const networkstatus_t *consensus = networkstatus_get_latest_consensus();
-  const smartlist_t *networkstatus_v2_list = networkstatus_get_v2_list();
-  int have_enough_v2;
-  const or_options_t *options = get_options();
 
   trusted_dirs_remove_old_certs();
 
@@ -3700,38 +3671,10 @@ routerlist_remove_old_routers(void)
   {
     /* We'll probably retain everything in the consensus. */
     int n_max_retain = smartlist_len(consensus->routerstatus_list);
-    if (caches && networkstatus_v2_list) {
-      /* If we care about v2 statuses, we'll retain at most as many as are
-         listed any of the v2 statues.  This will be at least the length of
-         the largest v2 networkstatus, and in the worst case, this set will be
-         equal to the sum of the lengths of all v2 consensuses.  Take the
-         worst case.
-      */
-      SMARTLIST_FOREACH(networkstatus_v2_list, networkstatus_v2_t *, ns,
-                        n_max_retain += smartlist_len(ns->entries));
-    }
     retain = digestset_new(n_max_retain);
   }
 
   cutoff = now - OLD_ROUTER_DESC_MAX_AGE;
-  /* Build a list of all the descriptors that _anybody_ lists. */
-  if (caches && networkstatus_v2_list) {
-    SMARTLIST_FOREACH_BEGIN(networkstatus_v2_list, networkstatus_v2_t *, ns) {
-      /* XXXX The inner loop here gets pretty expensive, and actually shows up
-       * on some profiles.  It may be the reason digestmap_set shows up in
-       * profiles too.  If instead we kept a per-descriptor digest count of
-       * how many networkstatuses recommended each descriptor, and changed
-       * that only when the networkstatuses changed, that would be a speed
-       * improvement, possibly 1-4% if it also removes digestmap_set from the
-       * profile.  Not worth it for 0.1.2.x, though.  The new directory
-       * system will obsolete this whole thing in 0.2.0.x. */
-      SMARTLIST_FOREACH_BEGIN(ns->entries, routerstatus_t *, rs) {
-        if (rs->published_on >= cutoff)
-          digestset_add(retain, rs->descriptor_digest);
-      } SMARTLIST_FOREACH_END(rs);
-    } SMARTLIST_FOREACH_END(ns);
-  }
-
   /* Retain anything listed in the consensus. */
   if (consensus) {
     SMARTLIST_FOREACH(consensus->routerstatus_list, routerstatus_t *, rs,
@@ -3739,18 +3682,13 @@ routerlist_remove_old_routers(void)
           digestset_add(retain, rs->descriptor_digest));
   }
 
-  /* If we have a consensus, and nearly as many v2 networkstatuses as we want,
+  /* If we have a consensus,
    * we should consider pruning current routers that are too old and that
    * nobody recommends.  (If we don't have a consensus or enough v2
    * networkstatuses, then we should get more before we decide to kill
    * routers.) */
-  /* we set this to true iff we don't care about v2 info, or we have enough. */
-  have_enough_v2 = !caches ||
-    !(authdir_mode_any_main(options) || options->FetchV2Networkstatus) ||
-    (networkstatus_v2_list &&
-     smartlist_len(networkstatus_v2_list) > get_n_v2_authorities() / 2);
 
-  if (have_enough_v2 && consensus) {
+  if (consensus) {
     cutoff = now - ROUTER_MAX_AGE;
     /* Remove too-old unrecommended members of routerlist->routers. */
     for (i = 0; i < smartlist_len(routerlist->routers); ++i) {
@@ -4049,8 +3987,6 @@ signed_desc_digest_is_recognized(signed_descriptor_t *desc)
 {
   const routerstatus_t *rs;
   networkstatus_t *consensus = networkstatus_get_latest_consensus();
-  int caches = directory_caches_dir_info(get_options());
-  const smartlist_t *networkstatus_v2_list = networkstatus_get_v2_list();
 
   if (consensus) {
     rs = networkstatus_vote_find_entry(consensus, desc->identity_digest);
@@ -4058,16 +3994,6 @@ signed_desc_digest_is_recognized(signed_descriptor_t *desc)
                       desc->signed_descriptor_digest, DIGEST_LEN))
       return 1;
   }
-  if (caches && networkstatus_v2_list) {
-    SMARTLIST_FOREACH(networkstatus_v2_list, networkstatus_v2_t *, ns,
-    {
-      if (!(rs = networkstatus_v2_find_entry(ns, desc->identity_digest)))
-        continue;
-      if (tor_memeq(rs->descriptor_digest,
-                  desc->signed_descriptor_digest, DIGEST_LEN))
-        return 1;
-    });
-  }
   return 0;
 }
 
@@ -4083,7 +4009,7 @@ update_all_descriptor_downloads(time_t now)
   launch_dummy_descriptor_download_as_needed(now, get_options());
 }
 
-/** Clear all our timeouts for fetching v2 and v3 directory stuff, and then
+/** Clear all our timeouts for fetching v3 directory stuff, and then
  * give it all a try again. */
 void
 routerlist_retry_directory_downloads(time_t now)
@@ -4564,152 +4490,6 @@ launch_descriptor_downloads(int purpose,
   }
 }
 
-/** Launch downloads for router status as needed, using the strategy used by
- * authorities and caches: based on the v2 networkstatuses we have, download
- * every descriptor we don't have but would serve, from a random authority
- * that lists it. */
-static void
-update_router_descriptor_cache_downloads_v2(time_t now)
-{
-  smartlist_t **downloadable; /* For each authority, what can we dl from it? */
-  smartlist_t **download_from; /*          ... and, what will we dl from it? */
-  digestmap_t *map; /* Which descs are in progress, or assigned? */
-  int i, j, n;
-  int n_download;
-  const or_options_t *options = get_options();
-  const smartlist_t *networkstatus_v2_list = networkstatus_get_v2_list();
-
-  if (! directory_fetches_dir_info_early(options)) {
-    log_warn(LD_BUG, "Called update_router_descriptor_cache_downloads_v2() "
-             "on a non-dir-mirror?");
-  }
-
-  if (!networkstatus_v2_list || !smartlist_len(networkstatus_v2_list))
-    return;
-
-  map = digestmap_new();
-  n = smartlist_len(networkstatus_v2_list);
-
-  downloadable = tor_malloc_zero(sizeof(smartlist_t*) * n);
-  download_from = tor_malloc_zero(sizeof(smartlist_t*) * n);
-
-  /* Set map[d]=1 for the digest of every descriptor that we are currently
-   * downloading. */
-  list_pending_descriptor_downloads(map, 0);
-
-  /* For the digest of every descriptor that we don't have, and that we aren't
-   * downloading, add d to downloadable[i] if the i'th networkstatus knows
-   * about that descriptor, and we haven't already failed to get that
-   * descriptor from the corresponding authority.
-   */
-  n_download = 0;
-  SMARTLIST_FOREACH_BEGIN(networkstatus_v2_list, networkstatus_v2_t *, ns) {
-      dir_server_t *ds;
-      smartlist_t *dl;
-      dl = downloadable[ns_sl_idx] = smartlist_new();
-      download_from[ns_sl_idx] = smartlist_new();
-      if (ns->published_on + MAX_NETWORKSTATUS_AGE+10*60 < now) {
-        /* Don't download if the networkstatus is almost ancient. */
-        /* Actually, I suspect what's happening here is that we ask
-         * for the descriptor when we have a given networkstatus,
-         * and then we get a newer networkstatus, and then we receive
-         * the descriptor. Having a networkstatus actually expire is
-         * probably a rare event, and we'll probably be happiest if
-         * we take this clause out. -RD */
-        continue;
-      }
-
-      /* Don't try dirservers that we think are down -- we might have
-       * just tried them and just marked them as down. */
-      ds = router_get_trusteddirserver_by_digest(ns->identity_digest);
-      if (ds && !ds->is_running)
-        continue;
-
-      SMARTLIST_FOREACH_BEGIN(ns->entries, routerstatus_t * , rs) {
-          if (!rs->need_to_mirror)
-            continue;
-          if (router_get_by_descriptor_digest(rs->descriptor_digest)) {
-            log_warn(LD_BUG,
-                     "We have a router descriptor, but need_to_mirror=1.");
-            rs->need_to_mirror = 0;
-            continue;
-          }
-          if (authdir_mode(options) && dirserv_would_reject_router(rs)) {
-            rs->need_to_mirror = 0;
-            continue;
-          }
-          if (digestmap_get(map, rs->descriptor_digest)) {
-            /* We're downloading it already. */
-            continue;
-          } else {
-            /* We could download it from this guy. */
-            smartlist_add(dl, rs->descriptor_digest);
-            ++n_download;
-          }
-      } SMARTLIST_FOREACH_END(rs);
-  } SMARTLIST_FOREACH_END(ns);
-
-  /* At random, assign descriptors to authorities such that:
-   * - if d is a member of some downloadable[x], d is a member of some
-   *   download_from[y].  (Everything we want to download, we try to download
-   *   from somebody.)
-   * - If d is a member of download_from[y], d is a member of downloadable[y].
-   *   (We only try to download descriptors from authorities who claim to have
-   *   them.)
-   * - No d is a member of download_from[x] and download_from[y] s.t. x != y.
-   *   (We don't try to download anything from two authorities concurrently.)
-   */
-  while (n_download) {
-    int which_ns = crypto_rand_int(n);
-    smartlist_t *dl = downloadable[which_ns];
-    int idx;
-    char *d;
-    if (!smartlist_len(dl))
-      continue;
-    idx = crypto_rand_int(smartlist_len(dl));
-    d = smartlist_get(dl, idx);
-    if (! digestmap_get(map, d)) {
-      smartlist_add(download_from[which_ns], d);
-      digestmap_set(map, d, (void*) 1);
-    }
-    smartlist_del(dl, idx);
-    --n_download;
-  }
-
-  /* Now, we can actually launch our requests. */
-  for (i=0; i<n; ++i) {
-    networkstatus_v2_t *ns = smartlist_get(networkstatus_v2_list, i);
-    dir_server_t *ds =
-      router_get_trusteddirserver_by_digest(ns->identity_digest);
-    smartlist_t *dl = download_from[i];
-    int pds_flags = PDS_RETRY_IF_NO_SERVERS;
-    if (! authdir_mode_any_nonhidserv(options))
-      pds_flags |= PDS_NO_EXISTING_SERVERDESC_FETCH; /* XXXX ignored*/
-
-    if (!ds) {
-      log_info(LD_DIR, "Networkstatus with no corresponding authority!");
-      continue;
-    }
-    if (! smartlist_len(dl))
-      continue;
-    log_info(LD_DIR, "Requesting %d descriptors from authority \"%s\"",
-             smartlist_len(dl), ds->nickname);
-    for (j=0; j < smartlist_len(dl); j += MAX_DL_PER_REQUEST) {
-      initiate_descriptor_downloads(&(ds->fake_status),
-                                    DIR_PURPOSE_FETCH_SERVERDESC, dl, j,
-                                    j+MAX_DL_PER_REQUEST, pds_flags);
-    }
-  }
-
-  for (i=0; i<n; ++i) {
-    smartlist_free(download_from[i]);
-    smartlist_free(downloadable[i]);
-  }
-  tor_free(download_from);
-  tor_free(downloadable);
-  digestmap_free(map,NULL);
-}
-
 /** For any descriptor that we want that's currently listed in
  * <b>consensus</b>, download it as appropriate. */
 void
@@ -4874,9 +4654,6 @@ update_router_descriptor_downloads(time_t now)
     return;
   if (!we_fetch_router_descriptors(options))
     return;
-  if (directory_fetches_dir_info_early(options)) {
-    update_router_descriptor_cache_downloads_v2(now);
-  }
 
   update_consensus_router_descriptor_downloads(now, 0,
                   networkstatus_get_reasonably_live_consensus(now, FLAV_NS));