routerlist.c
上传用户:awang829
上传日期:2019-07-14
资源大小:2356k
文件大小:184k
源码类别:

网络

开发平台:

Unix_Linux

  1. /* Copyright (c) 2001 Matej Pfajfar.
  2.  * Copyright (c) 2001-2004, Roger Dingledine.
  3.  * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  4.  * Copyright (c) 2007-2009, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  6. /**
  7.  * file routerlist.c
  8.  * brief Code to
  9.  * maintain and access the global list of routerinfos for known
  10.  * servers.
  11.  **/
  12. #include "or.h"
  13. // #define DEBUG_ROUTERLIST
  14. /****************************************************************************/
  15. /* static function prototypes */
  16. static routerstatus_t *router_pick_directory_server_impl(
  17.                                            authority_type_t auth, int flags);
  18. static routerstatus_t *router_pick_trusteddirserver_impl(
  19.                           authority_type_t auth, int flags, int *n_busy_out);
  20. static void mark_all_trusteddirservers_up(void);
  21. static int router_nickname_matches(routerinfo_t *router, const char *nickname);
  22. static void trusted_dir_server_free(trusted_dir_server_t *ds);
  23. static void launch_router_descriptor_downloads(smartlist_t *downloadable,
  24.                                                time_t now);
  25. static void update_consensus_router_descriptor_downloads(time_t now);
  26. static int signed_desc_digest_is_recognized(signed_descriptor_t *desc);
  27. static void update_router_have_minimum_dir_info(void);
  28. static const char *signed_descriptor_get_body_impl(signed_descriptor_t *desc,
  29.                                                    int with_annotations);
  30. static void list_pending_downloads(digestmap_t *result,
  31.                                    int purpose, const char *prefix);
  32. DECLARE_TYPED_DIGESTMAP_FNS(sdmap_, digest_sd_map_t, signed_descriptor_t)
  33. DECLARE_TYPED_DIGESTMAP_FNS(rimap_, digest_ri_map_t, routerinfo_t)
  34. DECLARE_TYPED_DIGESTMAP_FNS(eimap_, digest_ei_map_t, extrainfo_t)
  35. #define SDMAP_FOREACH(map, keyvar, valvar)                              
  36.   DIGESTMAP_FOREACH(sdmap_to_digestmap(map), keyvar, signed_descriptor_t *, 
  37.                     valvar)
  38. #define RIMAP_FOREACH(map, keyvar, valvar) 
  39.   DIGESTMAP_FOREACH(rimap_to_digestmap(map), keyvar, routerinfo_t *, valvar)
  40. #define EIMAP_FOREACH(map, keyvar, valvar) 
  41.   DIGESTMAP_FOREACH(eimap_to_digestmap(map), keyvar, extrainfo_t *, valvar)
  42. /****************************************************************************/
  43. /** Global list of a trusted_dir_server_t object for each trusted directory
  44.  * server. */
  45. static smartlist_t *trusted_dir_servers = NULL;
  46. /** List of for a given authority, and download status for latest certificate.
  47.  */
  48. typedef struct cert_list_t {
  49.   download_status_t dl_status;
  50.   smartlist_t *certs;
  51. } cert_list_t;
  52. /** Map from v3 identity key digest to cert_list_t. */
  53. static digestmap_t *trusted_dir_certs = NULL;
  54. /** True iff any key certificate in at least one member of
  55.  * <b>trusted_dir_certs</b> has changed since we last flushed the
  56.  * certificates to disk. */
  57. static int trusted_dir_servers_certs_changed = 0;
  58. /** Global list of all of the routers that we know about. */
  59. static routerlist_t *routerlist = NULL;
  60. /** List of strings for nicknames we've already warned about and that are
  61.  * still unknown / unavailable. */
  62. static smartlist_t *warned_nicknames = NULL;
  63. /** The last time we tried to download any routerdesc, or 0 for "never".  We
  64.  * use this to rate-limit download attempts when the number of routerdescs to
  65.  * download is low. */
  66. static time_t last_routerdesc_download_attempted = 0;
  67. /** When we last computed the weights to use for bandwidths on directory
  68.  * requests, what were the total weighted bandwidth, and our share of that
  69.  * bandwidth?  Used to determine what fraction of directory requests we should
  70.  * expect to see. */
  71. static uint64_t sl_last_total_weighted_bw = 0,
  72.   sl_last_weighted_bw_of_me = 0;
  73. /** Return the number of directory authorities whose type matches some bit set
  74.  * in <b>type</b>  */
  75. int
  76. get_n_authorities(authority_type_t type)
  77. {
  78.   int n = 0;
  79.   if (!trusted_dir_servers)
  80.     return 0;
  81.   SMARTLIST_FOREACH(trusted_dir_servers, trusted_dir_server_t *, ds,
  82.                     if (ds->type & type)
  83.                       ++n);
  84.   return n;
  85. }
  86. #define get_n_v2_authorities() get_n_authorities(V2_AUTHORITY)
  87. /** Helper: Return the cert_list_t for an authority whose authority ID is
  88.  * <b>id_digest</b>, allocating a new list if necessary. */
  89. static cert_list_t *
  90. get_cert_list(const char *id_digest)
  91. {
  92.   cert_list_t *cl;
  93.   if (!trusted_dir_certs)
  94.     trusted_dir_certs = digestmap_new();
  95.   cl = digestmap_get(trusted_dir_certs, id_digest);
  96.   if (!cl) {
  97.     cl = tor_malloc_zero(sizeof(cert_list_t));
  98.     cl->dl_status.schedule = DL_SCHED_CONSENSUS;
  99.     cl->certs = smartlist_create();
  100.     digestmap_set(trusted_dir_certs, id_digest, cl);
  101.   }
  102.   return cl;
  103. }
  104. /** Reload the cached v3 key certificates from the cached-certs file in
  105.  * the data directory. Return 0 on success, -1 on failure. */
  106. int
  107. trusted_dirs_reload_certs(void)
  108. {
  109.   char *filename;
  110.   char *contents;
  111.   int r;
  112.   filename = get_datadir_fname("cached-certs");
  113.   contents = read_file_to_str(filename, RFTS_IGNORE_MISSING, NULL);
  114.   tor_free(filename);
  115.   if (!contents)
  116.     return 0;
  117.   r = trusted_dirs_load_certs_from_string(contents, 1, 1);
  118.   tor_free(contents);
  119.   return r;
  120. }
  121. /** Helper: return true iff we already have loaded the exact cert
  122.  * <b>cert</b>. */
  123. static INLINE int
  124. already_have_cert(authority_cert_t *cert)
  125. {
  126.   cert_list_t *cl = get_cert_list(cert->cache_info.identity_digest);
  127.   SMARTLIST_FOREACH(cl->certs, authority_cert_t *, c,
  128.   {
  129.     if (!memcmp(c->cache_info.signed_descriptor_digest,
  130.                 cert->cache_info.signed_descriptor_digest,
  131.                 DIGEST_LEN))
  132.       return 1;
  133.   });
  134.   return 0;
  135. }
  136. /** Load a bunch of new key certificates from the string <b>contents</b>.  If
  137.  * <b>from_store</b> is true, the certificates are from the cache, and we
  138.  * don't need to flush them to disk.  If <b>from_store</b> is false, we need
  139.  * to flush any changed certificates to disk.  Return 0 on success, -1 on
  140.  * failure. */
  141. int
  142. trusted_dirs_load_certs_from_string(const char *contents, int from_store,
  143.                                     int flush)
  144. {
  145.   trusted_dir_server_t *ds;
  146.   const char *s, *eos;
  147.   for (s = contents; *s; s = eos) {
  148.     authority_cert_t *cert = authority_cert_parse_from_string(s, &eos);
  149.     cert_list_t *cl;
  150.     if (!cert)
  151.       break;
  152.     ds = trusteddirserver_get_by_v3_auth_digest(
  153.                                        cert->cache_info.identity_digest);
  154.     log_debug(LD_DIR, "Parsed certificate for %s",
  155.               ds ? ds->nickname : "unknown authority");
  156.     if (already_have_cert(cert)) {
  157.       /* we already have this one. continue. */
  158.       log_info(LD_DIR, "Skipping %s certificate for %s that we "
  159.                "already have.",
  160.                from_store ? "cached" : "downloaded",
  161.                ds ? ds->nickname : "??");
  162.       /* a duplicate on a download should be treated as a failure, since it
  163.        * probably means we wanted a different secret key or we are trying to
  164.        * replace an expired cert that has not in fact been updated. */
  165.       if (!from_store) {
  166.         log_warn(LD_DIR, "Got a certificate for %s that we already have. "
  167.                  "Maybe they haven't updated it.  Waiting for a while.",
  168.                  ds ? ds->nickname : "??");
  169.         authority_cert_dl_failed(cert->cache_info.identity_digest, 404);
  170.       }
  171.       authority_cert_free(cert);
  172.       continue;
  173.     }
  174.     if (ds) {
  175.       log_info(LD_DIR, "Adding %s certificate for directory authority %s with "
  176.                "signing key %s", from_store ? "cached" : "downloaded",
  177.                ds->nickname, hex_str(cert->signing_key_digest,DIGEST_LEN));
  178.     } else {
  179.       int adding = directory_caches_dir_info(get_options());
  180.       log_info(LD_DIR, "%s %s certificate for unrecognized directory "
  181.                "authority with signing key %s",
  182.                adding ? "Adding" : "Not adding",
  183.                from_store ? "cached" : "downloaded",
  184.                hex_str(cert->signing_key_digest,DIGEST_LEN));
  185.       if (!adding) {
  186.         authority_cert_free(cert);
  187.         continue;
  188.       }
  189.     }
  190.     cl = get_cert_list(cert->cache_info.identity_digest);
  191.     smartlist_add(cl->certs, cert);
  192.     if (ds && cert->cache_info.published_on > ds->addr_current_at) {
  193.       /* Check to see whether we should update our view of the authority's
  194.        * address. */
  195.       if (cert->addr && cert->dir_port &&
  196.           (ds->addr != cert->addr ||
  197.            ds->dir_port != cert->dir_port)) {
  198.         char *a = tor_dup_ip(cert->addr);
  199.         log_notice(LD_DIR, "Updating address for directory authority %s "
  200.                    "from %s:%d to %s:%d based on in certificate.",
  201.                    ds->nickname, ds->address, (int)ds->dir_port,
  202.                    a, cert->dir_port);
  203.         tor_free(a);
  204.         ds->addr = cert->addr;
  205.         ds->dir_port = cert->dir_port;
  206.       }
  207.       ds->addr_current_at = cert->cache_info.published_on;
  208.     }
  209.     if (!from_store)
  210.       trusted_dir_servers_certs_changed = 1;
  211.   }
  212.   if (flush)
  213.     trusted_dirs_flush_certs_to_disk();
  214.   networkstatus_note_certs_arrived();
  215.   return 0;
  216. }
  217. /** Save all v3 key certificates to the cached-certs file. */
  218. void
  219. trusted_dirs_flush_certs_to_disk(void)
  220. {
  221.   char *filename;
  222.   smartlist_t *chunks;
  223.   if (!trusted_dir_servers_certs_changed || !trusted_dir_certs)
  224.     return;
  225.   chunks = smartlist_create();
  226.   DIGESTMAP_FOREACH(trusted_dir_certs, key, cert_list_t *, cl) {
  227.     SMARTLIST_FOREACH(cl->certs, authority_cert_t *, cert,
  228.           {
  229.             sized_chunk_t *c = tor_malloc(sizeof(sized_chunk_t));
  230.             c->bytes = cert->cache_info.signed_descriptor_body;
  231.             c->len = cert->cache_info.signed_descriptor_len;
  232.             smartlist_add(chunks, c);
  233.           });
  234.   } DIGESTMAP_FOREACH_END;
  235.   filename = get_datadir_fname("cached-certs");
  236.   if (write_chunks_to_file(filename, chunks, 0)) {
  237.     log_warn(LD_FS, "Error writing certificates to disk.");
  238.   }
  239.   tor_free(filename);
  240.   SMARTLIST_FOREACH(chunks, sized_chunk_t *, c, tor_free(c));
  241.   smartlist_free(chunks);
  242.   trusted_dir_servers_certs_changed = 0;
  243. }
  244. /** Remove all v3 authority certificates that have been superseded for more
  245.  * than 48 hours.  (If the most recent cert was published more than 48 hours
  246.  * ago, then we aren't going to get any consensuses signed with older
  247.  * keys.) */
  248. static void
  249. trusted_dirs_remove_old_certs(void)
  250. {
  251.   time_t now = time(NULL);
  252. #define DEAD_CERT_LIFETIME (2*24*60*60)
  253. #define OLD_CERT_LIFETIME (7*24*60*60)
  254.   if (!trusted_dir_certs)
  255.     return;
  256.   DIGESTMAP_FOREACH(trusted_dir_certs, key, cert_list_t *, cl) {
  257.     authority_cert_t *newest = NULL;
  258.     SMARTLIST_FOREACH(cl->certs, authority_cert_t *, cert,
  259.           if (!newest || (cert->cache_info.published_on >
  260.                           newest->cache_info.published_on))
  261.             newest = cert);
  262.     if (newest) {
  263.       const time_t newest_published = newest->cache_info.published_on;
  264.       SMARTLIST_FOREACH_BEGIN(cl->certs, authority_cert_t *, cert) {
  265.         int expired;
  266.         time_t cert_published;
  267.         if (newest == cert)
  268.           continue;
  269.         expired = ftime_definitely_after(now, cert->expires);
  270.         cert_published = cert->cache_info.published_on;
  271.         /* Store expired certs for 48 hours after a newer arrives;
  272.          */
  273.         if (expired ?
  274.             (newest_published + DEAD_CERT_LIFETIME < now) :
  275.             (cert_published + OLD_CERT_LIFETIME < newest_published)) {
  276.           SMARTLIST_DEL_CURRENT(cl->certs, cert);
  277.           authority_cert_free(cert);
  278.           trusted_dir_servers_certs_changed = 1;
  279.         }
  280.       } SMARTLIST_FOREACH_END(cert);
  281.     }
  282.   } DIGESTMAP_FOREACH_END;
  283. #undef OLD_CERT_LIFETIME
  284.   trusted_dirs_flush_certs_to_disk();
  285. }
  286. /** Return the newest v3 authority certificate whose v3 authority identity key
  287.  * has digest <b>id_digest</b>.  Return NULL if no such authority is known,
  288.  * or it has no certificate. */
  289. authority_cert_t *
  290. authority_cert_get_newest_by_id(const char *id_digest)
  291. {
  292.   cert_list_t *cl;
  293.   authority_cert_t *best = NULL;
  294.   if (!trusted_dir_certs ||
  295.       !(cl = digestmap_get(trusted_dir_certs, id_digest)))
  296.     return NULL;
  297.   SMARTLIST_FOREACH(cl->certs, authority_cert_t *, cert,
  298.   {
  299.     if (!best || cert->cache_info.published_on > best->cache_info.published_on)
  300.       best = cert;
  301.   });
  302.   return best;
  303. }
  304. /** Return the newest v3 authority certificate whose directory signing key has
  305.  * digest <b>sk_digest</b>. Return NULL if no such certificate is known.
  306.  */
  307. authority_cert_t *
  308. authority_cert_get_by_sk_digest(const char *sk_digest)
  309. {
  310.   authority_cert_t *c;
  311.   if (!trusted_dir_certs)
  312.     return NULL;
  313.   if ((c = get_my_v3_authority_cert()) &&
  314.       !memcmp(c->signing_key_digest, sk_digest, DIGEST_LEN))
  315.     return c;
  316.   if ((c = get_my_v3_legacy_cert()) &&
  317.       !memcmp(c->signing_key_digest, sk_digest, DIGEST_LEN))
  318.     return c;
  319.   DIGESTMAP_FOREACH(trusted_dir_certs, key, cert_list_t *, cl) {
  320.     SMARTLIST_FOREACH(cl->certs, authority_cert_t *, cert,
  321.     {
  322.       if (!memcmp(cert->signing_key_digest, sk_digest, DIGEST_LEN))
  323.         return cert;
  324.     });
  325.   } DIGESTMAP_FOREACH_END;
  326.   return NULL;
  327. }
  328. /** Return the v3 authority certificate with signing key matching
  329.  * <b>sk_digest</b>, for the authority with identity digest <b>id_digest</b>.
  330.  * Return NULL if no such authority is known. */
  331. authority_cert_t *
  332. authority_cert_get_by_digests(const char *id_digest,
  333.                               const char *sk_digest)
  334. {
  335.   cert_list_t *cl;
  336.   if (!trusted_dir_certs ||
  337.       !(cl = digestmap_get(trusted_dir_certs, id_digest)))
  338.     return NULL;
  339.   SMARTLIST_FOREACH(cl->certs, authority_cert_t *, cert,
  340.     if (!memcmp(cert->signing_key_digest, sk_digest, DIGEST_LEN))
  341.       return cert; );
  342.   return NULL;
  343. }
  344. /** Add every known authority_cert_t to <b>certs_out</b>. */
  345. void
  346. authority_cert_get_all(smartlist_t *certs_out)
  347. {
  348.   tor_assert(certs_out);
  349.   if (!trusted_dir_certs)
  350.     return;
  351.   DIGESTMAP_FOREACH(trusted_dir_certs, key, cert_list_t *, cl) {
  352.     SMARTLIST_FOREACH(cl->certs, authority_cert_t *, c,
  353.                       smartlist_add(certs_out, c));
  354.   } DIGESTMAP_FOREACH_END;
  355. }
  356. /** Called when an attempt to download a certificate with the authority with
  357.  * ID <b>id_digest</b> fails with HTTP response code <b>status</b>: remember
  358.  * the failure, so we don't try again immediately. */
  359. void
  360. authority_cert_dl_failed(const char *id_digest, int status)
  361. {
  362.   cert_list_t *cl;
  363.   if (!trusted_dir_certs ||
  364.       !(cl = digestmap_get(trusted_dir_certs, id_digest)))
  365.     return;
  366.   download_status_failed(&cl->dl_status, status);
  367. }
  368. /** How many times will we try to fetch a certificate before giving up? */
  369. #define MAX_CERT_DL_FAILURES 8
  370. /** Try to download any v3 authority certificates that we may be missing.  If
  371.  * <b>status</b> is provided, try to get all the ones that were used to sign
  372.  * <b>status</b>.  Additionally, try to have a non-expired certificate for
  373.  * every V3 authority in trusted_dir_servers.  Don't fetch certificates we
  374.  * already have.
  375.  **/
  376. void
  377. authority_certs_fetch_missing(networkstatus_t *status, time_t now)
  378. {
  379.   digestmap_t *pending;
  380.   authority_cert_t *cert;
  381.   smartlist_t *missing_digests;
  382.   char *resource = NULL;
  383.   cert_list_t *cl;
  384.   const int cache = directory_caches_dir_info(get_options());
  385.   if (should_delay_dir_fetches(get_options()))
  386.     return;
  387.   pending = digestmap_new();
  388.   missing_digests = smartlist_create();
  389.   list_pending_downloads(pending, DIR_PURPOSE_FETCH_CERTIFICATE, "fp/");
  390.   if (status) {
  391.     SMARTLIST_FOREACH(status->voters, networkstatus_voter_info_t *, voter,
  392.       {
  393.         if (tor_digest_is_zero(voter->signing_key_digest))
  394.           continue; /* This authority never signed this consensus, so don't
  395.                      * go looking for a cert with key digest 0000000000. */
  396.         if (!cache &&
  397.             !trusteddirserver_get_by_v3_auth_digest(voter->identity_digest))
  398.           continue; /* We are not a cache, and we don't know this authority.*/
  399.         cl = get_cert_list(voter->identity_digest);
  400.         cert = authority_cert_get_by_digests(voter->identity_digest,
  401.                                              voter->signing_key_digest);
  402.         if (cert) {
  403.           if (now < cert->expires)
  404.             download_status_reset(&cl->dl_status);
  405.           continue;
  406.         }
  407.         if (download_status_is_ready(&cl->dl_status, now,
  408.                                      MAX_CERT_DL_FAILURES) &&
  409.             !digestmap_get(pending, voter->identity_digest)) {
  410.           log_notice(LD_DIR, "We're missing a certificate from authority "
  411.                      "with signing key %s: launching request.",
  412.                      hex_str(voter->signing_key_digest, DIGEST_LEN));
  413.           smartlist_add(missing_digests, voter->identity_digest);
  414.         }
  415.       });
  416.   }
  417.   SMARTLIST_FOREACH(trusted_dir_servers, trusted_dir_server_t *, ds,
  418.     {
  419.       int found = 0;
  420.       if (!(ds->type & V3_AUTHORITY))
  421.         continue;
  422.       if (smartlist_digest_isin(missing_digests, ds->v3_identity_digest))
  423.         continue;
  424.       cl = get_cert_list(ds->v3_identity_digest);
  425.       SMARTLIST_FOREACH(cl->certs, authority_cert_t *, cert,
  426.         {
  427.           if (!ftime_definitely_after(now, cert->expires)) {
  428.             /* It's not expired, and we weren't looking for something to
  429.              * verify a consensus with.  Call it done. */
  430.             download_status_reset(&cl->dl_status);
  431.             found = 1;
  432.             break;
  433.           }
  434.         });
  435.       if (!found &&
  436.           download_status_is_ready(&cl->dl_status, now,MAX_CERT_DL_FAILURES) &&
  437.           !digestmap_get(pending, ds->v3_identity_digest)) {
  438.         log_notice(LD_DIR, "No current certificate known for authority %s; "
  439.                    "launching request.", ds->nickname);
  440.         smartlist_add(missing_digests, ds->v3_identity_digest);
  441.       }
  442.     });
  443.   if (!smartlist_len(missing_digests)) {
  444.     goto done;
  445.   } else {
  446.     smartlist_t *fps = smartlist_create();
  447.     smartlist_add(fps, tor_strdup("fp/"));
  448.     SMARTLIST_FOREACH(missing_digests, const char *, d, {
  449.         char *fp;
  450.         if (digestmap_get(pending, d))
  451.           continue;
  452.         fp = tor_malloc(HEX_DIGEST_LEN+2);
  453.         base16_encode(fp, HEX_DIGEST_LEN+1, d, DIGEST_LEN);
  454.         fp[HEX_DIGEST_LEN] = '+';
  455.         fp[HEX_DIGEST_LEN+1] = '';
  456.         smartlist_add(fps, fp);
  457.       });
  458.     if (smartlist_len(fps) == 1) {
  459.       /* we didn't add any: they were all pending */
  460.       SMARTLIST_FOREACH(fps, char *, cp, tor_free(cp));
  461.       smartlist_free(fps);
  462.       goto done;
  463.     }
  464.     resource = smartlist_join_strings(fps, "", 0, NULL);
  465.     resource[strlen(resource)-1] = '';
  466.     SMARTLIST_FOREACH(fps, char *, cp, tor_free(cp));
  467.     smartlist_free(fps);
  468.   }
  469.   directory_get_from_dirserver(DIR_PURPOSE_FETCH_CERTIFICATE, 0,
  470.                                resource, PDS_RETRY_IF_NO_SERVERS);
  471.  done:
  472.   tor_free(resource);
  473.   smartlist_free(missing_digests);
  474.   digestmap_free(pending, NULL);
  475. }
  476. /* Router descriptor storage.
  477.  *
  478.  * Routerdescs are stored in a big file, named "cached-descriptors".  As new
  479.  * routerdescs arrive, we append them to a journal file named
  480.  * "cached-descriptors.new".
  481.  *
  482.  * From time to time, we replace "cached-descriptors" with a new file
  483.  * containing only the live, non-superseded descriptors, and clear
  484.  * cached-routers.new.
  485.  *
  486.  * On startup, we read both files.
  487.  */
  488. /** Helper: return 1 iff the router log is so big we want to rebuild the
  489.  * store. */
  490. static int
  491. router_should_rebuild_store(desc_store_t *store)
  492. {
  493.   if (store->store_len > (1<<16))
  494.     return (store->journal_len > store->store_len / 2 ||
  495.             store->bytes_dropped > store->store_len / 2);
  496.   else
  497.     return store->journal_len > (1<<15);
  498. }
  499. /** Return the desc_store_t in <b>rl</b> that should be used to store
  500.  * <b>sd</b>. */
  501. static INLINE desc_store_t *
  502. desc_get_store(routerlist_t *rl, signed_descriptor_t *sd)
  503. {
  504.   if (sd->is_extrainfo)
  505.     return &rl->extrainfo_store;
  506.   else
  507.     return &rl->desc_store;
  508. }
  509. /** Add the signed_descriptor_t in <b>desc</b> to the router
  510.  * journal; change its saved_location to SAVED_IN_JOURNAL and set its
  511.  * offset appropriately. */
  512. static int
  513. signed_desc_append_to_journal(signed_descriptor_t *desc,
  514.                               desc_store_t *store)
  515. {
  516.   char *fname = get_datadir_fname_suffix(store->fname_base, ".new");
  517.   const char *body = signed_descriptor_get_body_impl(desc,1);
  518.   size_t len = desc->signed_descriptor_len + desc->annotations_len;
  519.   tor_assert(len == strlen(body));
  520.   if (append_bytes_to_file(fname, body, len, 1)) {
  521.     log_warn(LD_FS, "Unable to store router descriptor");
  522.     tor_free(fname);
  523.     return -1;
  524.   }
  525.   desc->saved_location = SAVED_IN_JOURNAL;
  526.   tor_free(fname);
  527.   desc->saved_offset = store->journal_len;
  528.   store->journal_len += len;
  529.   return 0;
  530. }
  531. /** Sorting helper: return &lt;0, 0, or &gt;0 depending on whether the
  532.  * signed_descriptor_t* in *<b>a</b> is older, the same age as, or newer than
  533.  * the signed_descriptor_t* in *<b>b</b>. */
  534. static int
  535. _compare_signed_descriptors_by_age(const void **_a, const void **_b)
  536. {
  537.   const signed_descriptor_t *r1 = *_a, *r2 = *_b;
  538.   return (int)(r1->published_on - r2->published_on);
  539. }
  540. #define RRS_FORCE 1
  541. #define RRS_DONT_REMOVE_OLD 2
  542. /** If the journal of <b>store</b> is too long, or if RRS_FORCE is set in
  543.  * <b>flags</b>, then atomically replace the saved router store with the
  544.  * routers currently in our routerlist, and clear the journal.  Unless
  545.  * RRS_DONT_REMOVE_OLD is set in <b>flags</b>, delete expired routers before
  546.  * rebuilding the store.  Return 0 on success, -1 on failure.
  547.  */
  548. static int
  549. router_rebuild_store(int flags, desc_store_t *store)
  550. {
  551.   smartlist_t *chunk_list = NULL;
  552.   char *fname = NULL, *fname_tmp = NULL;
  553.   int r = -1;
  554.   off_t offset = 0;
  555.   smartlist_t *signed_descriptors = NULL;
  556.   int nocache=0;
  557.   size_t total_expected_len = 0;
  558.   int had_any;
  559.   int force = flags & RRS_FORCE;
  560.   if (!force && !router_should_rebuild_store(store)) {
  561.     r = 0;
  562.     goto done;
  563.   }
  564.   if (!routerlist) {
  565.     r = 0;
  566.     goto done;
  567.   }
  568.   if (store->type == EXTRAINFO_STORE)
  569.     had_any = !eimap_isempty(routerlist->extra_info_map);
  570.   else
  571.     had_any = (smartlist_len(routerlist->routers)+
  572.                smartlist_len(routerlist->old_routers))>0;
  573.   /* Don't save deadweight. */
  574.   if (!(flags & RRS_DONT_REMOVE_OLD))
  575.     routerlist_remove_old_routers();
  576.   log_info(LD_DIR, "Rebuilding %s cache", store->description);
  577.   fname = get_datadir_fname(store->fname_base);
  578.   fname_tmp = get_datadir_fname_suffix(store->fname_base, ".tmp");
  579.   chunk_list = smartlist_create();
  580.   /* We sort the routers by age to enhance locality on disk. */
  581.   signed_descriptors = smartlist_create();
  582.   if (store->type == EXTRAINFO_STORE) {
  583.     eimap_iter_t *iter;
  584.     for (iter = eimap_iter_init(routerlist->extra_info_map);
  585.          !eimap_iter_done(iter);
  586.          iter = eimap_iter_next(routerlist->extra_info_map, iter)) {
  587.       const char *key;
  588.       extrainfo_t *ei;
  589.       eimap_iter_get(iter, &key, &ei);
  590.       smartlist_add(signed_descriptors, &ei->cache_info);
  591.     }
  592.   } else {
  593.     SMARTLIST_FOREACH(routerlist->old_routers, signed_descriptor_t *, sd,
  594.                       smartlist_add(signed_descriptors, sd));
  595.     SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, ri,
  596.                       smartlist_add(signed_descriptors, &ri->cache_info));
  597.   }
  598.   smartlist_sort(signed_descriptors, _compare_signed_descriptors_by_age);
  599.   /* Now, add the appropriate members to chunk_list */
  600.   SMARTLIST_FOREACH(signed_descriptors, signed_descriptor_t *, sd,
  601.     {
  602.       sized_chunk_t *c;
  603.       const char *body = signed_descriptor_get_body_impl(sd, 1);
  604.       if (!body) {
  605.         log_warn(LD_BUG, "No descriptor available for router.");
  606.         goto done;
  607.       }
  608.       if (sd->do_not_cache) {
  609.         ++nocache;
  610.         continue;
  611.       }
  612.       c = tor_malloc(sizeof(sized_chunk_t));
  613.       c->bytes = body;
  614.       c->len = sd->signed_descriptor_len + sd->annotations_len;
  615.       total_expected_len += c->len;
  616.       smartlist_add(chunk_list, c);
  617.     });
  618.   if (write_chunks_to_file(fname_tmp, chunk_list, 1)<0) {
  619.     log_warn(LD_FS, "Error writing router store to disk.");
  620.     goto done;
  621.   }
  622.   /* Our mmap is now invalid. */
  623.   if (store->mmap) {
  624.     tor_munmap_file(store->mmap);
  625.     store->mmap = NULL;
  626.   }
  627.   if (replace_file(fname_tmp, fname)<0) {
  628.     log_warn(LD_FS, "Error replacing old router store: %s", strerror(errno));
  629.     goto done;
  630.   }
  631.   errno = 0;
  632.   store->mmap = tor_mmap_file(fname);
  633.   if (! store->mmap) {
  634.     if (errno == ERANGE) {
  635.       /* empty store.*/
  636.       if (total_expected_len) {
  637.         log_warn(LD_FS, "We wrote some bytes to a new descriptor file at '%s',"
  638.                  " but when we went to mmap it, it was empty!", fname);
  639.       } else if (had_any) {
  640.         log_info(LD_FS, "We just removed every descriptor in '%s'.  This is "
  641.                  "okay if we're just starting up after a long time. "
  642.                  "Otherwise, it's a bug.", fname);
  643.       }
  644.     } else {
  645.       log_warn(LD_FS, "Unable to mmap new descriptor file at '%s'.",fname);
  646.     }
  647.   }
  648.   log_info(LD_DIR, "Reconstructing pointers into cache");
  649.   offset = 0;
  650.   SMARTLIST_FOREACH(signed_descriptors, signed_descriptor_t *, sd,
  651.     {
  652.       if (sd->do_not_cache)
  653.         continue;
  654.       sd->saved_location = SAVED_IN_CACHE;
  655.       if (store->mmap) {
  656.         tor_free(sd->signed_descriptor_body); // sets it to null
  657.         sd->saved_offset = offset;
  658.       }
  659.       offset += sd->signed_descriptor_len + sd->annotations_len;
  660.       signed_descriptor_get_body(sd); /* reconstruct and assert */
  661.     });
  662.   tor_free(fname);
  663.   fname = get_datadir_fname_suffix(store->fname_base, ".new");
  664.   write_str_to_file(fname, "", 1);
  665.   r = 0;
  666.   store->store_len = (size_t) offset;
  667.   store->journal_len = 0;
  668.   store->bytes_dropped = 0;
  669.  done:
  670.   if (signed_descriptors)
  671.     smartlist_free(signed_descriptors);
  672.   tor_free(fname);
  673.   tor_free(fname_tmp);
  674.   if (chunk_list) {
  675.     SMARTLIST_FOREACH(chunk_list, sized_chunk_t *, c, tor_free(c));
  676.     smartlist_free(chunk_list);
  677.   }
  678.   return r;
  679. }
  680. /** Helper: Reload a cache file and its associated journal, setting metadata
  681.  * appropriately.  If <b>extrainfo</b> is true, reload the extrainfo store;
  682.  * else reload the router descriptor store. */
  683. static int
  684. router_reload_router_list_impl(desc_store_t *store)
  685. {
  686.   char *fname = NULL, *altname = NULL, *contents = NULL;
  687.   struct stat st;
  688.   int read_from_old_location = 0;
  689.   int extrainfo = (store->type == EXTRAINFO_STORE);
  690.   time_t now = time(NULL);
  691.   store->journal_len = store->store_len = 0;
  692.   fname = get_datadir_fname(store->fname_base);
  693.   if (store->fname_alt_base)
  694.     altname = get_datadir_fname(store->fname_alt_base);
  695.   if (store->mmap) /* get rid of it first */
  696.     tor_munmap_file(store->mmap);
  697.   store->mmap = NULL;
  698.   store->mmap = tor_mmap_file(fname);
  699.   if (!store->mmap && altname && file_status(altname) == FN_FILE) {
  700.     read_from_old_location = 1;
  701.     log_notice(LD_DIR, "Couldn't read %s; trying to load routers from old "
  702.                "location %s.", fname, altname);
  703.     if ((store->mmap = tor_mmap_file(altname)))
  704.       read_from_old_location = 1;
  705.   }
  706.   if (altname && !read_from_old_location) {
  707.     remove_file_if_very_old(altname, now);
  708.   }
  709.   if (store->mmap) {
  710.     store->store_len = store->mmap->size;
  711.     if (extrainfo)
  712.       router_load_extrainfo_from_string(store->mmap->data,
  713.                                         store->mmap->data+store->mmap->size,
  714.                                         SAVED_IN_CACHE, NULL, 0);
  715.     else
  716.       router_load_routers_from_string(store->mmap->data,
  717.                                       store->mmap->data+store->mmap->size,
  718.                                       SAVED_IN_CACHE, NULL, 0, NULL);
  719.   }
  720.   tor_free(fname);
  721.   fname = get_datadir_fname_suffix(store->fname_base, ".new");
  722.   if (file_status(fname) == FN_FILE)
  723.     contents = read_file_to_str(fname, RFTS_BIN|RFTS_IGNORE_MISSING, &st);
  724.   if (read_from_old_location) {
  725.     tor_free(altname);
  726.     altname = get_datadir_fname_suffix(store->fname_alt_base, ".new");
  727.     if (!contents)
  728.       contents = read_file_to_str(altname, RFTS_BIN|RFTS_IGNORE_MISSING, &st);
  729.     else
  730.       remove_file_if_very_old(altname, now);
  731.   }
  732.   if (contents) {
  733.     if (extrainfo)
  734.       router_load_extrainfo_from_string(contents, NULL,SAVED_IN_JOURNAL,
  735.                                         NULL, 0);
  736.     else
  737.       router_load_routers_from_string(contents, NULL, SAVED_IN_JOURNAL,
  738.                                       NULL, 0, NULL);
  739.     store->journal_len = (size_t) st.st_size;
  740.     tor_free(contents);
  741.   }
  742.   tor_free(fname);
  743.   tor_free(altname);
  744.   if (store->journal_len || read_from_old_location) {
  745.     /* Always clear the journal on startup.*/
  746.     router_rebuild_store(RRS_FORCE, store);
  747.   } else if (!extrainfo) {
  748.     /* Don't cache expired routers. (This is in an else because
  749.      * router_rebuild_store() also calls remove_old_routers().) */
  750.     routerlist_remove_old_routers();
  751.   }
  752.   return 0;
  753. }
  754. /** Load all cached router descriptors and extra-info documents from the
  755.  * store. Return 0 on success and -1 on failure.
  756.  */
  757. int
  758. router_reload_router_list(void)
  759. {
  760.   routerlist_t *rl = router_get_routerlist();
  761.   if (router_reload_router_list_impl(&rl->desc_store))
  762.     return -1;
  763.   if (router_reload_router_list_impl(&rl->extrainfo_store))
  764.     return -1;
  765.   return 0;
  766. }
  767. /** Return a smartlist containing a list of trusted_dir_server_t * for all
  768.  * known trusted dirservers.  Callers must not modify the list or its
  769.  * contents.
  770.  */
  771. smartlist_t *
  772. router_get_trusted_dir_servers(void)
  773. {
  774.   if (!trusted_dir_servers)
  775.     trusted_dir_servers = smartlist_create();
  776.   return trusted_dir_servers;
  777. }
  778. /** Try to find a running dirserver that supports operations of <b>type</b>.
  779.  *
  780.  * If there are no running dirservers in our routerlist and the
  781.  * <b>PDS_RETRY_IF_NO_SERVERS</b> flag is set, set all the authoritative ones
  782.  * as running again, and pick one.
  783.  *
  784.  * If the <b>PDS_IGNORE_FASCISTFIREWALL</b> flag is set, then include
  785.  * dirservers that we can't reach.
  786.  *
  787.  * If the <b>PDS_ALLOW_SELF</b> flag is not set, then don't include ourself
  788.  * (if we're a dirserver).
  789.  *
  790.  * Don't pick an authority if any non-authority is viable; try to avoid using
  791.  * servers that have returned 503 recently.
  792.  */
  793. routerstatus_t *
  794. router_pick_directory_server(authority_type_t type, int flags)
  795. {
  796.   routerstatus_t *choice;
  797.   if (get_options()->PreferTunneledDirConns)
  798.     flags |= _PDS_PREFER_TUNNELED_DIR_CONNS;
  799.   if (!routerlist)
  800.     return NULL;
  801.   choice = router_pick_directory_server_impl(type, flags);
  802.   if (choice || !(flags & PDS_RETRY_IF_NO_SERVERS))
  803.     return choice;
  804.   log_info(LD_DIR,
  805.            "No reachable router entries for dirservers. "
  806.            "Trying them all again.");
  807.   /* mark all authdirservers as up again */
  808.   mark_all_trusteddirservers_up();
  809.   /* try again */
  810.   choice = router_pick_directory_server_impl(type, flags);
  811.   return choice;
  812. }
  813. /** Try to determine which fraction of v2 and v3 directory requests aimed at
  814.  * caches will be sent to us. Set *<b>v2_share_out</b> and
  815.  * *<b>v3_share_out</b> to the fractions of v2 and v3 protocol shares we
  816.  * expect to see, respectively.  Return 0 on success, negative on failure. */
  817. int
  818. router_get_my_share_of_directory_requests(double *v2_share_out,
  819.                                           double *v3_share_out)
  820. {
  821.   routerinfo_t *me = router_get_my_routerinfo();
  822.   routerstatus_t *rs;
  823.   const int pds_flags = PDS_ALLOW_SELF|PDS_IGNORE_FASCISTFIREWALL;
  824.   *v2_share_out = *v3_share_out = 0.0;
  825.   if (!me)
  826.     return -1;
  827.   rs = router_get_consensus_status_by_id(me->cache_info.identity_digest);
  828.   if (!rs)
  829.     return -1;
  830.   /* Calling for side effect */
  831.   /* XXXX This is a bit of a kludge */
  832.   if (rs->is_v2_dir) {
  833.     sl_last_total_weighted_bw = 0;
  834.     router_pick_directory_server(V2_AUTHORITY, pds_flags);
  835.     if (sl_last_total_weighted_bw != 0) {
  836.       *v2_share_out = U64_TO_DBL(sl_last_weighted_bw_of_me) /
  837.         U64_TO_DBL(sl_last_total_weighted_bw);
  838.     }
  839.   }
  840.   if (rs->version_supports_v3_dir) {
  841.     sl_last_total_weighted_bw = 0;
  842.     router_pick_directory_server(V3_AUTHORITY, pds_flags);
  843.     if (sl_last_total_weighted_bw != 0) {
  844.       *v3_share_out = U64_TO_DBL(sl_last_weighted_bw_of_me) /
  845.         U64_TO_DBL(sl_last_total_weighted_bw);
  846.     }
  847.   }
  848.   return 0;
  849. }
  850. /** Return the trusted_dir_server_t for the directory authority whose identity
  851.  * key hashes to <b>digest</b>, or NULL if no such authority is known.
  852.  */
  853. trusted_dir_server_t *
  854. router_get_trusteddirserver_by_digest(const char *digest)
  855. {
  856.   if (!trusted_dir_servers)
  857.     return NULL;
  858.   SMARTLIST_FOREACH(trusted_dir_servers, trusted_dir_server_t *, ds,
  859.      {
  860.        if (!memcmp(ds->digest, digest, DIGEST_LEN))
  861.          return ds;
  862.      });
  863.   return NULL;
  864. }
  865. /** Return the trusted_dir_server_t for the directory authority whose identity
  866.  * key hashes to <b>digest</b>, or NULL if no such authority is known.
  867.  */
  868. trusted_dir_server_t *
  869. trusteddirserver_get_by_v3_auth_digest(const char *digest)
  870. {
  871.   if (!trusted_dir_servers)
  872.     return NULL;
  873.   SMARTLIST_FOREACH(trusted_dir_servers, trusted_dir_server_t *, ds,
  874.      {
  875.        if (!memcmp(ds->v3_identity_digest, digest, DIGEST_LEN) &&
  876.            (ds->type & V3_AUTHORITY))
  877.          return ds;
  878.      });
  879.   return NULL;
  880. }
  881. /** Try to find a running trusted dirserver.  Flags are as for
  882.  * router_pick_directory_server.
  883.  */
  884. routerstatus_t *
  885. router_pick_trusteddirserver(authority_type_t type, int flags)
  886. {
  887.   routerstatus_t *choice;
  888.   int busy = 0;
  889.   if (get_options()->PreferTunneledDirConns)
  890.     flags |= _PDS_PREFER_TUNNELED_DIR_CONNS;
  891.   choice = router_pick_trusteddirserver_impl(type, flags, &busy);
  892.   if (choice || !(flags & PDS_RETRY_IF_NO_SERVERS))
  893.     return choice;
  894.   if (busy) {
  895.     /* If the reason that we got no server is that servers are "busy",
  896.      * we must be excluding good servers because we already have serverdesc
  897.      * fetches with them.  Do not mark down servers up because of this. */
  898.     tor_assert((flags & PDS_NO_EXISTING_SERVERDESC_FETCH));
  899.     return NULL;
  900.   }
  901.   log_info(LD_DIR,
  902.            "No trusted dirservers are reachable. Trying them all again.");
  903.   mark_all_trusteddirservers_up();
  904.   return router_pick_trusteddirserver_impl(type, flags, NULL);
  905. }
  906. /** How long do we avoid using a directory server after it's given us a 503? */
  907. #define DIR_503_TIMEOUT (60*60)
  908. /** Pick a random running valid directory server/mirror from our
  909.  * routerlist.  Arguments are as for router_pick_directory_server(), except
  910.  * that RETRY_IF_NO_SERVERS is ignored, and:
  911.  *
  912.  * If the _PDS_PREFER_TUNNELED_DIR_CONNS flag is set, prefer directory servers
  913.  * that we can use with BEGINDIR.
  914.  */
  915. static routerstatus_t *
  916. router_pick_directory_server_impl(authority_type_t type, int flags)
  917. {
  918.   routerstatus_t *result;
  919.   smartlist_t *direct, *tunnel;
  920.   smartlist_t *trusted_direct, *trusted_tunnel;
  921.   smartlist_t *overloaded_direct, *overloaded_tunnel;
  922.   time_t now = time(NULL);
  923.   const networkstatus_t *consensus = networkstatus_get_latest_consensus();
  924.   int requireother = ! (flags & PDS_ALLOW_SELF);
  925.   int fascistfirewall = ! (flags & PDS_IGNORE_FASCISTFIREWALL);
  926.   int prefer_tunnel = (flags & _PDS_PREFER_TUNNELED_DIR_CONNS);
  927.   if (!consensus)
  928.     return NULL;
  929.   direct = smartlist_create();
  930.   tunnel = smartlist_create();
  931.   trusted_direct = smartlist_create();
  932.   trusted_tunnel = smartlist_create();
  933.   overloaded_direct = smartlist_create();
  934.   overloaded_tunnel = smartlist_create();
  935.   /* Find all the running dirservers we know about. */
  936.   SMARTLIST_FOREACH_BEGIN(consensus->routerstatus_list, routerstatus_t *,
  937.                           status) {
  938.     int is_trusted;
  939.     int is_overloaded = status->last_dir_503_at + DIR_503_TIMEOUT > now;
  940.     tor_addr_t addr;
  941.     if (!status->is_running || !status->dir_port || !status->is_valid)
  942.       continue;
  943.     if (status->is_bad_directory)
  944.       continue;
  945.     if (requireother && router_digest_is_me(status->identity_digest))
  946.       continue;
  947.     if (type & V3_AUTHORITY) {
  948.       if (!(status->version_supports_v3_dir ||
  949.             router_digest_is_trusted_dir_type(status->identity_digest,
  950.                                               V3_AUTHORITY)))
  951.         continue;
  952.     }
  953.     is_trusted = router_digest_is_trusted_dir(status->identity_digest);
  954.     if ((type & V2_AUTHORITY) && !(status->is_v2_dir || is_trusted))
  955.       continue;
  956.     if ((type & EXTRAINFO_CACHE) &&
  957.         !router_supports_extrainfo(status->identity_digest, 0))
  958.       continue;
  959.     /* XXXX IP6 proposal 118 */
  960.     tor_addr_from_ipv4h(&addr, status->addr);
  961.     if (prefer_tunnel &&
  962.         status->version_supports_begindir &&
  963.         (!fascistfirewall ||
  964.          fascist_firewall_allows_address_or(&addr, status->or_port)))
  965.       smartlist_add(is_trusted ? trusted_tunnel :
  966.                       is_overloaded ? overloaded_tunnel : tunnel, status);
  967.     else if (!fascistfirewall ||
  968.              fascist_firewall_allows_address_dir(&addr, status->dir_port))
  969.       smartlist_add(is_trusted ? trusted_direct :
  970.                       is_overloaded ? overloaded_direct : direct, status);
  971.   } SMARTLIST_FOREACH_END(status);
  972.   if (smartlist_len(tunnel)) {
  973.     result = routerstatus_sl_choose_by_bandwidth(tunnel);
  974.   } else if (smartlist_len(overloaded_tunnel)) {
  975.     result = routerstatus_sl_choose_by_bandwidth(overloaded_tunnel);
  976.   } else if (smartlist_len(trusted_tunnel)) {
  977.     /* FFFF We don't distinguish between trusteds and overloaded trusteds
  978.      * yet. Maybe one day we should. */
  979.     /* FFFF We also don't load balance over authorities yet. I think this
  980.      * is a feature, but it could easily be a bug. -RD */
  981.     result = smartlist_choose(trusted_tunnel);
  982.   } else if (smartlist_len(direct)) {
  983.     result = routerstatus_sl_choose_by_bandwidth(direct);
  984.   } else if (smartlist_len(overloaded_direct)) {
  985.     result = routerstatus_sl_choose_by_bandwidth(overloaded_direct);
  986.   } else {
  987.     result = smartlist_choose(trusted_direct);
  988.   }
  989.   smartlist_free(direct);
  990.   smartlist_free(tunnel);
  991.   smartlist_free(trusted_direct);
  992.   smartlist_free(trusted_tunnel);
  993.   smartlist_free(overloaded_direct);
  994.   smartlist_free(overloaded_tunnel);
  995.   return result;
  996. }
  997. /** Choose randomly from among the trusted dirservers that are up.  Flags
  998.  * are as for router_pick_directory_server_impl().
  999.  */
  1000. static routerstatus_t *
  1001. router_pick_trusteddirserver_impl(authority_type_t type, int flags,
  1002.                                   int *n_busy_out)
  1003. {
  1004.   smartlist_t *direct, *tunnel;
  1005.   smartlist_t *overloaded_direct, *overloaded_tunnel;
  1006.   routerinfo_t *me = router_get_my_routerinfo();
  1007.   routerstatus_t *result;
  1008.   time_t now = time(NULL);
  1009.   const int requireother = ! (flags & PDS_ALLOW_SELF);
  1010.   const int fascistfirewall = ! (flags & PDS_IGNORE_FASCISTFIREWALL);
  1011.   const int prefer_tunnel = (flags & _PDS_PREFER_TUNNELED_DIR_CONNS);
  1012.   const int no_serverdesc_fetching =(flags & PDS_NO_EXISTING_SERVERDESC_FETCH);
  1013.   int n_busy = 0;
  1014.   if (!trusted_dir_servers)
  1015.     return NULL;
  1016.   direct = smartlist_create();
  1017.   tunnel = smartlist_create();
  1018.   overloaded_direct = smartlist_create();
  1019.   overloaded_tunnel = smartlist_create();
  1020.   SMARTLIST_FOREACH_BEGIN(trusted_dir_servers, trusted_dir_server_t *, d)
  1021.     {
  1022.       int is_overloaded =
  1023.           d->fake_status.last_dir_503_at + DIR_503_TIMEOUT > now;
  1024.       tor_addr_t addr;
  1025.       if (!d->is_running) continue;
  1026.       if ((type & d->type) == 0)
  1027.         continue;
  1028.       if ((type & EXTRAINFO_CACHE) &&
  1029.           !router_supports_extrainfo(d->digest, 1))
  1030.         continue;
  1031.       if (requireother && me && router_digest_is_me(d->digest))
  1032.           continue;
  1033.       /* XXXX IP6 proposal 118 */
  1034.       tor_addr_from_ipv4h(&addr, d->addr);
  1035.       if (no_serverdesc_fetching) {
  1036.         if (connection_get_by_type_addr_port_purpose(
  1037.             CONN_TYPE_DIR, &addr, d->dir_port, DIR_PURPOSE_FETCH_SERVERDESC)
  1038.          || connection_get_by_type_addr_port_purpose(
  1039.              CONN_TYPE_DIR, &addr, d->dir_port, DIR_PURPOSE_FETCH_EXTRAINFO)) {
  1040.           //log_debug(LD_DIR, "We have an existing connection to fetch "
  1041.           //           "descriptor from %s; delaying",d->description);
  1042.           ++n_busy;
  1043.           continue;
  1044.         }
  1045.       }
  1046.       if (prefer_tunnel &&
  1047.           d->or_port &&
  1048.           (!fascistfirewall ||
  1049.            fascist_firewall_allows_address_or(&addr, d->or_port)))
  1050.         smartlist_add(is_overloaded ? overloaded_tunnel : tunnel,
  1051.                       &d->fake_status);
  1052.       else if (!fascistfirewall ||
  1053.                fascist_firewall_allows_address_dir(&addr, d->dir_port))
  1054.         smartlist_add(is_overloaded ? overloaded_direct : direct,
  1055.                       &d->fake_status);
  1056.     }
  1057.   SMARTLIST_FOREACH_END(d);
  1058.   if (smartlist_len(tunnel)) {
  1059.     result = smartlist_choose(tunnel);
  1060.   } else if (smartlist_len(overloaded_tunnel)) {
  1061.     result = smartlist_choose(overloaded_tunnel);
  1062.   } else if (smartlist_len(direct)) {
  1063.     result = smartlist_choose(direct);
  1064.   } else {
  1065.     result = smartlist_choose(overloaded_direct);
  1066.   }
  1067.   if (n_busy_out)
  1068.     *n_busy_out = n_busy;
  1069.   smartlist_free(direct);
  1070.   smartlist_free(tunnel);
  1071.   smartlist_free(overloaded_direct);
  1072.   smartlist_free(overloaded_tunnel);
  1073.   return result;
  1074. }
  1075. /** Go through and mark the authoritative dirservers as up. */
  1076. static void
  1077. mark_all_trusteddirservers_up(void)
  1078. {
  1079.   if (routerlist) {
  1080.     SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, router,
  1081.        if (router_digest_is_trusted_dir(router->cache_info.identity_digest) &&
  1082.          router->dir_port > 0) {
  1083.          router->is_running = 1;
  1084.        });
  1085.   }
  1086.   if (trusted_dir_servers) {
  1087.     SMARTLIST_FOREACH(trusted_dir_servers, trusted_dir_server_t *, dir,
  1088.     {
  1089.       routerstatus_t *rs;
  1090.       dir->is_running = 1;
  1091.       download_status_reset(&dir->v2_ns_dl_status);
  1092.       rs = router_get_consensus_status_by_id(dir->digest);
  1093.       if (rs && !rs->is_running) {
  1094.         rs->is_running = 1;
  1095.         rs->last_dir_503_at = 0;
  1096.         control_event_networkstatus_changed_single(rs);
  1097.       }
  1098.     });
  1099.   }
  1100.   router_dir_info_changed();
  1101. }
  1102. /** Reset all internal variables used to count failed downloads of network
  1103.  * status objects. */
  1104. void
  1105. router_reset_status_download_failures(void)
  1106. {
  1107.   mark_all_trusteddirservers_up();
  1108. }
  1109. /** Return true iff router1 and router2 have the same /16 network. */
  1110. static INLINE int
  1111. routers_in_same_network_family(routerinfo_t *r1, routerinfo_t *r2)
  1112. {
  1113.   return (r1->addr & 0xffff0000) == (r2->addr & 0xffff0000);
  1114. }
  1115. /** Look through the routerlist and identify routers that
  1116.  * advertise the same /16 network address as <b>router</b>.
  1117.  * Add each of them to <b>sl</b>.
  1118.  */
  1119. static void
  1120. routerlist_add_network_family(smartlist_t *sl, routerinfo_t *router)
  1121. {
  1122.   SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, r,
  1123.   {
  1124.     if (router != r && routers_in_same_network_family(router, r))
  1125.       smartlist_add(sl, r);
  1126.   });
  1127. }
  1128. /** Add all the family of <b>router</b> to the smartlist <b>sl</b>.
  1129.  * This is used to make sure we don't pick siblings in a single path,
  1130.  * or pick more than one relay from a family for our entry guard list.
  1131.  */
  1132. void
  1133. routerlist_add_family(smartlist_t *sl, routerinfo_t *router)
  1134. {
  1135.   routerinfo_t *r;
  1136.   config_line_t *cl;
  1137.   or_options_t *options = get_options();
  1138.   /* First, add any routers with similar network addresses. */
  1139.   if (options->EnforceDistinctSubnets)
  1140.     routerlist_add_network_family(sl, router);
  1141.   if (router->declared_family) {
  1142.     /* Add every r such that router declares familyness with r, and r
  1143.      * declares familyhood with router. */
  1144.     SMARTLIST_FOREACH(router->declared_family, const char *, n,
  1145.       {
  1146.         if (!(r = router_get_by_nickname(n, 0)))
  1147.           continue;
  1148.         if (!r->declared_family)
  1149.           continue;
  1150.         SMARTLIST_FOREACH(r->declared_family, const char *, n2,
  1151.           {
  1152.             if (router_nickname_matches(router, n2))
  1153.               smartlist_add(sl, r);
  1154.           });
  1155.       });
  1156.   }
  1157.   /* If the user declared any families locally, honor those too. */
  1158.   for (cl = options->NodeFamilies; cl; cl = cl->next) {
  1159.     if (router_nickname_is_in_list(router, cl->value)) {
  1160.       add_nickname_list_to_smartlist(sl, cl->value, 0);
  1161.     }
  1162.   }
  1163. }
  1164. /** Return true iff r is named by some nickname in <b>lst</b>. */
  1165. static INLINE int
  1166. router_in_nickname_smartlist(smartlist_t *lst, routerinfo_t *r)
  1167. {
  1168.   if (!lst) return 0;
  1169.   SMARTLIST_FOREACH(lst, const char *, name,
  1170.     if (router_nickname_matches(r, name))
  1171.       return 1;);
  1172.   return 0;
  1173. }
  1174. /** Return true iff r1 and r2 are in the same family, but not the same
  1175.  * router. */
  1176. int
  1177. routers_in_same_family(routerinfo_t *r1, routerinfo_t *r2)
  1178. {
  1179.   or_options_t *options = get_options();
  1180.   config_line_t *cl;
  1181.   if (options->EnforceDistinctSubnets && routers_in_same_network_family(r1,r2))
  1182.     return 1;
  1183.   if (router_in_nickname_smartlist(r1->declared_family, r2) &&
  1184.       router_in_nickname_smartlist(r2->declared_family, r1))
  1185.     return 1;
  1186.   for (cl = options->NodeFamilies; cl; cl = cl->next) {
  1187.     if (router_nickname_is_in_list(r1, cl->value) &&
  1188.         router_nickname_is_in_list(r2, cl->value))
  1189.       return 1;
  1190.   }
  1191.   return 0;
  1192. }
  1193. /** Given a (possibly NULL) comma-and-whitespace separated list of nicknames,
  1194.  * see which nicknames in <b>list</b> name routers in our routerlist, and add
  1195.  * the routerinfos for those routers to <b>sl</b>.  If <b>must_be_running</b>,
  1196.  * only include routers that we think are running.
  1197.  * Warn if any non-Named routers are specified by nickname.
  1198.  */
  1199. void
  1200. add_nickname_list_to_smartlist(smartlist_t *sl, const char *list,
  1201.                                int must_be_running)
  1202. {
  1203.   routerinfo_t *router;
  1204.   smartlist_t *nickname_list;
  1205.   int have_dir_info = router_have_minimum_dir_info();
  1206.   if (!list)
  1207.     return; /* nothing to do */
  1208.   tor_assert(sl);
  1209.   nickname_list = smartlist_create();
  1210.   if (!warned_nicknames)
  1211.     warned_nicknames = smartlist_create();
  1212.   smartlist_split_string(nickname_list, list, ",",
  1213.                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1214.   SMARTLIST_FOREACH(nickname_list, const char *, nick, {
  1215.     int warned;
  1216.     if (!is_legal_nickname_or_hexdigest(nick)) {
  1217.       log_warn(LD_CONFIG, "Nickname '%s' is misformed; skipping", nick);
  1218.       continue;
  1219.     }
  1220.     router = router_get_by_nickname(nick, 1);
  1221.     warned = smartlist_string_isin(warned_nicknames, nick);
  1222.     if (router) {
  1223.       if (!must_be_running || router->is_running) {
  1224.         smartlist_add(sl,router);
  1225.       }
  1226.     } else if (!router_get_consensus_status_by_nickname(nick,1)) {
  1227.       if (!warned) {
  1228.         log_fn(have_dir_info ? LOG_WARN : LOG_INFO, LD_CONFIG,
  1229.                "Nickname list includes '%s' which isn't a known router.",nick);
  1230.         smartlist_add(warned_nicknames, tor_strdup(nick));
  1231.       }
  1232.     }
  1233.   });
  1234.   SMARTLIST_FOREACH(nickname_list, char *, nick, tor_free(nick));
  1235.   smartlist_free(nickname_list);
  1236. }
  1237. /** Return 1 iff any member of the (possibly NULL) comma-separated list
  1238.  * <b>list</b> is an acceptable nickname or hexdigest for <b>router</b>.  Else
  1239.  * return 0.
  1240.  */
  1241. int
  1242. router_nickname_is_in_list(routerinfo_t *router, const char *list)
  1243. {
  1244.   smartlist_t *nickname_list;
  1245.   int v = 0;
  1246.   if (!list)
  1247.     return 0; /* definitely not */
  1248.   tor_assert(router);
  1249.   nickname_list = smartlist_create();
  1250.   smartlist_split_string(nickname_list, list, ",",
  1251.     SPLIT_SKIP_SPACE|SPLIT_STRIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1252.   SMARTLIST_FOREACH(nickname_list, const char *, cp,
  1253.                     if (router_nickname_matches(router, cp)) {v=1;break;});
  1254.   SMARTLIST_FOREACH(nickname_list, char *, cp, tor_free(cp));
  1255.   smartlist_free(nickname_list);
  1256.   return v;
  1257. }
  1258. /** Add every suitable router from our routerlist to <b>sl</b>, so that
  1259.  * we can pick a node for a circuit.
  1260.  */
  1261. static void
  1262. router_add_running_routers_to_smartlist(smartlist_t *sl, int allow_invalid,
  1263.                                         int need_uptime, int need_capacity,
  1264.                                         int need_guard)
  1265. {
  1266.   if (!routerlist)
  1267.     return;
  1268.   SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, router,
  1269.   {
  1270.     if (router->is_running &&
  1271.         router->purpose == ROUTER_PURPOSE_GENERAL &&
  1272.         (router->is_valid || allow_invalid) &&
  1273.         !router_is_unreliable(router, need_uptime,
  1274.                               need_capacity, need_guard)) {
  1275.       /* If it's running, and it's suitable according to the
  1276.        * other flags we had in mind */
  1277.       smartlist_add(sl, router);
  1278.     }
  1279.   });
  1280. }
  1281. /** Look through the routerlist until we find a router that has my key.
  1282.  Return it. */
  1283. routerinfo_t *
  1284. routerlist_find_my_routerinfo(void)
  1285. {
  1286.   if (!routerlist)
  1287.     return NULL;
  1288.   SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, router,
  1289.   {
  1290.     if (router_is_me(router))
  1291.       return router;
  1292.   });
  1293.   return NULL;
  1294. }
  1295. /** Find a router that's up, that has this IP address, and
  1296.  * that allows exit to this address:port, or return NULL if there
  1297.  * isn't a good one.
  1298.  */
  1299. routerinfo_t *
  1300. router_find_exact_exit_enclave(const char *address, uint16_t port)
  1301. {
  1302.   uint32_t addr;
  1303.   struct in_addr in;
  1304.   tor_addr_t a;
  1305.   if (!tor_inet_aton(address, &in))
  1306.     return NULL; /* it's not an IP already */
  1307.   addr = ntohl(in.s_addr);
  1308.   tor_addr_from_ipv4h(&a, addr);
  1309.   SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, router,
  1310.   {
  1311.     if (router->addr == addr &&
  1312.         router->is_running &&
  1313.         compare_tor_addr_to_addr_policy(&a, port, router->exit_policy) ==
  1314.           ADDR_POLICY_ACCEPTED)
  1315.       return router;
  1316.   });
  1317.   return NULL;
  1318. }
  1319. /** Return 1 if <b>router</b> is not suitable for these parameters, else 0.
  1320.  * If <b>need_uptime</b> is non-zero, we require a minimum uptime.
  1321.  * If <b>need_capacity</b> is non-zero, we require a minimum advertised
  1322.  * bandwidth.
  1323.  * If <b>need_guard</b>, we require that the router is a possible entry guard.
  1324.  */
  1325. int
  1326. router_is_unreliable(routerinfo_t *router, int need_uptime,
  1327.                      int need_capacity, int need_guard)
  1328. {
  1329.   if (need_uptime && !router->is_stable)
  1330.     return 1;
  1331.   if (need_capacity && !router->is_fast)
  1332.     return 1;
  1333.   if (need_guard && !router->is_possible_guard)
  1334.     return 1;
  1335.   return 0;
  1336. }
  1337. /** Return the smaller of the router's configured BandwidthRate
  1338.  * and its advertised capacity. */
  1339. uint32_t
  1340. router_get_advertised_bandwidth(routerinfo_t *router)
  1341. {
  1342.   if (router->bandwidthcapacity < router->bandwidthrate)
  1343.     return router->bandwidthcapacity;
  1344.   return router->bandwidthrate;
  1345. }
  1346. /** Do not weight any declared bandwidth more than this much when picking
  1347.  * routers by bandwidth. */
  1348. #define DEFAULT_MAX_BELIEVABLE_BANDWIDTH 10000000 /* 10 MB/sec */
  1349. /** Return the smaller of the router's configured BandwidthRate
  1350.  * and its advertised capacity, capped by max-believe-bw. */
  1351. uint32_t
  1352. router_get_advertised_bandwidth_capped(routerinfo_t *router)
  1353. {
  1354.   uint32_t result = router->bandwidthcapacity;
  1355.   if (result > router->bandwidthrate)
  1356.     result = router->bandwidthrate;
  1357.   if (result > DEFAULT_MAX_BELIEVABLE_BANDWIDTH)
  1358.     result = DEFAULT_MAX_BELIEVABLE_BANDWIDTH;
  1359.   return result;
  1360. }
  1361. /** Return bw*1000, unless bw*1000 would overflow, in which case return
  1362.  * INT32_MAX. */
  1363. static INLINE int32_t
  1364. kb_to_bytes(uint32_t bw)
  1365. {
  1366.   return (bw > (INT32_MAX/1000)) ? INT32_MAX : bw*1000;
  1367. }
  1368. /** Helper function:
  1369.  * choose a random element of smartlist <b>sl</b>, weighted by
  1370.  * the advertised bandwidth of each element.
  1371.  *
  1372.  * If <b>statuses</b> is zero, then <b>sl</b> is a list of
  1373.  * routerinfo_t's. Otherwise it's a list of routerstatus_t's.
  1374.  *
  1375.  * If <b>rule</b>==WEIGHT_FOR_EXIT. we're picking an exit node: consider all
  1376.  * nodes' bandwidth equally regardless of their Exit status, since there may
  1377.  * be some in the list because they exit to obscure ports. If
  1378.  * <b>rule</b>==NO_WEIGHTING, we're picking a non-exit node: weight
  1379.  * exit-node's bandwidth less depending on the smallness of the fraction of
  1380.  * Exit-to-total bandwidth.  If <b>rule</b>==WEIGHT_FOR_GUARD, we're picking a
  1381.  * guard node: consider all guard's bandwidth equally. Otherwise, weight
  1382.  * guards proportionally less.
  1383.  */
  1384. static void *
  1385. smartlist_choose_by_bandwidth(smartlist_t *sl, bandwidth_weight_rule_t rule,
  1386.                               int statuses)
  1387. {
  1388.   unsigned int i;
  1389.   routerinfo_t *router;
  1390.   routerstatus_t *status=NULL;
  1391.   int32_t *bandwidths;
  1392.   int is_exit;
  1393.   int is_guard;
  1394.   uint64_t total_nonexit_bw = 0, total_exit_bw = 0, total_bw = 0;
  1395.   uint64_t total_nonguard_bw = 0, total_guard_bw = 0;
  1396.   uint64_t rand_bw, tmp;
  1397.   double exit_weight;
  1398.   double guard_weight;
  1399.   int n_unknown = 0;
  1400.   bitarray_t *exit_bits;
  1401.   bitarray_t *guard_bits;
  1402.   int me_idx = -1;
  1403.   /* Can't choose exit and guard at same time */
  1404.   tor_assert(rule == NO_WEIGHTING ||
  1405.              rule == WEIGHT_FOR_EXIT ||
  1406.              rule == WEIGHT_FOR_GUARD);
  1407.   /* First count the total bandwidth weight, and make a list
  1408.    * of each value.  <0 means "unknown; no routerinfo."  We use the
  1409.    * bits of negative values to remember whether the router was fast (-x)&1
  1410.    * and whether it was an exit (-x)&2 or guard (-x)&4.  Yes, it's a hack. */
  1411.   bandwidths = tor_malloc(sizeof(int32_t)*smartlist_len(sl));
  1412.   exit_bits = bitarray_init_zero(smartlist_len(sl));
  1413.   guard_bits = bitarray_init_zero(smartlist_len(sl));
  1414.   /* Iterate over all the routerinfo_t or routerstatus_t, and */
  1415.   for (i = 0; i < (unsigned)smartlist_len(sl); ++i) {
  1416.     /* first, learn what bandwidth we think i has */
  1417.     int is_known = 1;
  1418.     int32_t flags = 0;
  1419.     uint32_t this_bw = 0;
  1420.     if (statuses) {
  1421.       status = smartlist_get(sl, i);
  1422.       if (router_digest_is_me(status->identity_digest))
  1423.         me_idx = i;
  1424.       router = router_get_by_digest(status->identity_digest);
  1425.       is_exit = status->is_exit;
  1426.       is_guard = status->is_possible_guard;
  1427.       if (status->has_bandwidth) {
  1428.         this_bw = kb_to_bytes(status->bandwidth);
  1429.       } else { /* guess */
  1430.         /* XXX022 once consensuses always list bandwidths, we can take
  1431.          * this guessing business out. -RD */
  1432.         is_known = 0;
  1433.         flags = status->is_fast ? 1 : 0;
  1434.         flags |= is_exit ? 2 : 0;
  1435.         flags |= is_guard ? 4 : 0;
  1436.       }
  1437.     } else {
  1438.       routerstatus_t *rs;
  1439.       router = smartlist_get(sl, i);
  1440.       rs = router_get_consensus_status_by_id(
  1441.              router->cache_info.identity_digest);
  1442.       if (router_digest_is_me(router->cache_info.identity_digest))
  1443.         me_idx = i;
  1444.       is_exit = router->is_exit;
  1445.       is_guard = router->is_possible_guard;
  1446.       if (rs && rs->has_bandwidth) {
  1447.         this_bw = kb_to_bytes(rs->bandwidth);
  1448.       } else if (rs) { /* guess; don't trust the descriptor */
  1449.         /* XXX022 once consensuses always list bandwidths, we can take
  1450.          * this guessing business out. -RD */
  1451.         is_known = 0;
  1452.         flags = router->is_fast ? 1 : 0;
  1453.         flags |= is_exit ? 2 : 0;
  1454.         flags |= is_guard ? 4 : 0;
  1455.       } else /* bridge or other descriptor not in our consensus */
  1456.         this_bw = router_get_advertised_bandwidth_capped(router);
  1457.     }
  1458.     if (is_exit)
  1459.       bitarray_set(exit_bits, i);
  1460.     if (is_guard)
  1461.       bitarray_set(guard_bits, i);
  1462.     if (is_known) {
  1463.       bandwidths[i] = (int32_t) this_bw; // safe since MAX_BELIEVABLE<INT32_MAX
  1464.       tor_assert(bandwidths[i] >= 0);
  1465.       if (is_guard)
  1466.         total_guard_bw += this_bw;
  1467.       else
  1468.         total_nonguard_bw += this_bw;
  1469.       if (is_exit)
  1470.         total_exit_bw += this_bw;
  1471.       else
  1472.         total_nonexit_bw += this_bw;
  1473.     } else {
  1474.       ++n_unknown;
  1475.       bandwidths[i] = -flags;
  1476.     }
  1477.   }
  1478.   /* Now, fill in the unknown values. */
  1479.   if (n_unknown) {
  1480.     int32_t avg_fast, avg_slow;
  1481.     if (total_exit_bw+total_nonexit_bw) {
  1482.       /* if there's some bandwidth, there's at least one known router,
  1483.        * so no worries about div by 0 here */
  1484.       int n_known = smartlist_len(sl)-n_unknown;
  1485.       avg_fast = avg_slow = (int32_t)
  1486.         ((total_exit_bw+total_nonexit_bw)/((uint64_t) n_known));
  1487.     } else {
  1488.       avg_fast = 40000;
  1489.       avg_slow = 20000;
  1490.     }
  1491.     for (i=0; i<(unsigned)smartlist_len(sl); ++i) {
  1492.       int32_t bw = bandwidths[i];
  1493.       if (bw>=0)
  1494.         continue;
  1495.       is_exit = ((-bw)&2);
  1496.       is_guard = ((-bw)&4);
  1497.       bandwidths[i] = ((-bw)&1) ? avg_fast : avg_slow;
  1498.       if (is_exit)
  1499.         total_exit_bw += bandwidths[i];
  1500.       else
  1501.         total_nonexit_bw += bandwidths[i];
  1502.       if (is_guard)
  1503.         total_guard_bw += bandwidths[i];
  1504.       else
  1505.         total_nonguard_bw += bandwidths[i];
  1506.     }
  1507.   }
  1508.   /* If there's no bandwidth at all, pick at random. */
  1509.   if (!(total_exit_bw+total_nonexit_bw)) {
  1510.     tor_free(bandwidths);
  1511.     tor_free(exit_bits);
  1512.     tor_free(guard_bits);
  1513.     return smartlist_choose(sl);
  1514.   }
  1515.   /* Figure out how to weight exits and guards */
  1516.   {
  1517.     double all_bw = U64_TO_DBL(total_exit_bw+total_nonexit_bw);
  1518.     double exit_bw = U64_TO_DBL(total_exit_bw);
  1519.     double guard_bw = U64_TO_DBL(total_guard_bw);
  1520.     /*
  1521.      * For detailed derivation of this formula, see
  1522.      *   http://archives.seul.org/or/dev/Jul-2007/msg00056.html
  1523.      */
  1524.     if (rule == WEIGHT_FOR_EXIT)
  1525.       exit_weight = 1.0;
  1526.     else
  1527.       exit_weight = 1.0 - all_bw/(3.0*exit_bw);
  1528.     if (rule == WEIGHT_FOR_GUARD)
  1529.       guard_weight = 1.0;
  1530.     else
  1531.       guard_weight = 1.0 - all_bw/(3.0*guard_bw);
  1532.     if (exit_weight <= 0.0)
  1533.       exit_weight = 0.0;
  1534.     if (guard_weight <= 0.0)
  1535.       guard_weight = 0.0;
  1536.     total_bw = 0;
  1537.     sl_last_weighted_bw_of_me = 0;
  1538.     for (i=0; i < (unsigned)smartlist_len(sl); i++) {
  1539.       uint64_t bw;
  1540.       is_exit = bitarray_is_set(exit_bits, i);
  1541.       is_guard = bitarray_is_set(guard_bits, i);
  1542.       if (is_exit && is_guard)
  1543.         bw = ((uint64_t)(bandwidths[i] * exit_weight * guard_weight));
  1544.       else if (is_guard)
  1545.         bw = ((uint64_t)(bandwidths[i] * guard_weight));
  1546.       else if (is_exit)
  1547.         bw = ((uint64_t)(bandwidths[i] * exit_weight));
  1548.       else
  1549.         bw = bandwidths[i];
  1550.       total_bw += bw;
  1551.       if (i == (unsigned) me_idx)
  1552.         sl_last_weighted_bw_of_me = bw;
  1553.     }
  1554.   }
  1555.   /* XXXX022 this is a kludge to expose these values. */
  1556.   sl_last_total_weighted_bw = total_bw;
  1557.   log_debug(LD_CIRC, "Total weighted bw = "U64_FORMAT
  1558.             ", exit bw = "U64_FORMAT
  1559.             ", nonexit bw = "U64_FORMAT", exit weight = %lf "
  1560.             "(for exit == %d)"
  1561.             ", guard bw = "U64_FORMAT
  1562.             ", nonguard bw = "U64_FORMAT", guard weight = %lf "
  1563.             "(for guard == %d)",
  1564.             U64_PRINTF_ARG(total_bw),
  1565.             U64_PRINTF_ARG(total_exit_bw), U64_PRINTF_ARG(total_nonexit_bw),
  1566.             exit_weight, (int)(rule == WEIGHT_FOR_EXIT),
  1567.             U64_PRINTF_ARG(total_guard_bw), U64_PRINTF_ARG(total_nonguard_bw),
  1568.             guard_weight, (int)(rule == WEIGHT_FOR_GUARD));
  1569.   /* Almost done: choose a random value from the bandwidth weights. */
  1570.   rand_bw = crypto_rand_uint64(total_bw);
  1571.   /* Last, count through sl until we get to the element we picked */
  1572.   tmp = 0;
  1573.   for (i=0; i < (unsigned)smartlist_len(sl); i++) {
  1574.     is_exit = bitarray_is_set(exit_bits, i);
  1575.     is_guard = bitarray_is_set(guard_bits, i);
  1576.     /* Weights can be 0 if not counting guards/exits */
  1577.     if (is_exit && is_guard)
  1578.       tmp += ((uint64_t)(bandwidths[i] * exit_weight * guard_weight));
  1579.     else if (is_guard)
  1580.       tmp += ((uint64_t)(bandwidths[i] * guard_weight));
  1581.     else if (is_exit)
  1582.       tmp += ((uint64_t)(bandwidths[i] * exit_weight));
  1583.     else
  1584.       tmp += bandwidths[i];
  1585.     if (tmp >= rand_bw)
  1586.       break;
  1587.   }
  1588.   if (i == (unsigned)smartlist_len(sl)) {
  1589.     /* This was once possible due to round-off error, but shouldn't be able
  1590.      * to occur any longer. */
  1591.     tor_fragile_assert();
  1592.     --i;
  1593.     log_warn(LD_BUG, "Round-off error in computing bandwidth had an effect on "
  1594.              " which router we chose. Please tell the developers. "
  1595.              U64_FORMAT " " U64_FORMAT " " U64_FORMAT, U64_PRINTF_ARG(tmp),
  1596.              U64_PRINTF_ARG(rand_bw), U64_PRINTF_ARG(total_bw));
  1597.   }
  1598.   tor_free(bandwidths);
  1599.   tor_free(exit_bits);
  1600.   tor_free(guard_bits);
  1601.   return smartlist_get(sl, i);
  1602. }
  1603. /** Choose a random element of router list <b>sl</b>, weighted by
  1604.  * the advertised bandwidth of each router.
  1605.  */
  1606. routerinfo_t *
  1607. routerlist_sl_choose_by_bandwidth(smartlist_t *sl,
  1608.                                   bandwidth_weight_rule_t rule)
  1609. {
  1610.   return smartlist_choose_by_bandwidth(sl, rule, 0);
  1611. }
  1612. /** Choose a random element of status list <b>sl</b>, weighted by
  1613.  * the advertised bandwidth of each status.
  1614.  */
  1615. routerstatus_t *
  1616. routerstatus_sl_choose_by_bandwidth(smartlist_t *sl)
  1617. {
  1618.   /* We are choosing neither exit nor guard here. Weight accordingly. */
  1619.   return smartlist_choose_by_bandwidth(sl, NO_WEIGHTING, 1);
  1620. }
  1621. /** Return a random running router from the routerlist.  If any node
  1622.  * named in <b>preferred</b> is available, pick one of those.  Never
  1623.  * pick a node whose routerinfo is in
  1624.  * <b>excludedsmartlist</b>, or whose routerinfo matches <b>excludedset</b>,
  1625.  * even if they are the only nodes
  1626.  * available.  If <b>CRN_STRICT_PREFERRED</b> is set in flags, never pick
  1627.  * any node besides those in <b>preferred</b>.
  1628.  * If <b>CRN_NEED_UPTIME</b> is set in flags and any router has more than
  1629.  * a minimum uptime, return one of those.
  1630.  * If <b>CRN_NEED_CAPACITY</b> is set in flags, weight your choice by the
  1631.  * advertised capacity of each router.
  1632.  * If <b>CRN_ALLOW_INVALID</b> is not set in flags, consider only Valid
  1633.  * routers.
  1634.  * If <b>CRN_NEED_GUARD</b> is set in flags, consider only Guard routers.
  1635.  * If <b>CRN_WEIGHT_AS_EXIT</b> is set in flags, we weight bandwidths as if
  1636.  * picking an exit node, otherwise we weight bandwidths for picking a relay
  1637.  * node (that is, possibly discounting exit nodes).
  1638.  */
  1639. routerinfo_t *
  1640. router_choose_random_node(const char *preferred,
  1641.                           smartlist_t *excludedsmartlist,
  1642.                           routerset_t *excludedset,
  1643.                           router_crn_flags_t flags)
  1644. {
  1645.   const int need_uptime = (flags & CRN_NEED_UPTIME) != 0;
  1646.   const int need_capacity = (flags & CRN_NEED_CAPACITY) != 0;
  1647.   const int need_guard = (flags & CRN_NEED_GUARD) != 0;
  1648.   const int allow_invalid = (flags & CRN_ALLOW_INVALID) != 0;
  1649.   const int strict = (flags & CRN_STRICT_PREFERRED) != 0;
  1650.   const int weight_for_exit = (flags & CRN_WEIGHT_AS_EXIT) != 0;
  1651.   smartlist_t *sl, *excludednodes;
  1652.   routerinfo_t *choice = NULL, *r;
  1653.   bandwidth_weight_rule_t rule;
  1654.   tor_assert(!(weight_for_exit && need_guard));
  1655.   rule = weight_for_exit ? WEIGHT_FOR_EXIT :
  1656.     (need_guard ? WEIGHT_FOR_GUARD : NO_WEIGHTING);
  1657.   excludednodes = smartlist_create();
  1658.   /* Exclude relays that allow single hop exit circuits, if the user
  1659.    * wants to (such relays might be risky) */
  1660.   if (get_options()->ExcludeSingleHopRelays) {
  1661.     routerlist_t *rl = router_get_routerlist();
  1662.     SMARTLIST_FOREACH(rl->routers, routerinfo_t *, r,
  1663.       if (r->allow_single_hop_exits) {
  1664.         smartlist_add(excludednodes, r);
  1665.       });
  1666.   }
  1667.   if ((r = routerlist_find_my_routerinfo())) {
  1668.     smartlist_add(excludednodes, r);
  1669.     routerlist_add_family(excludednodes, r);
  1670.   }
  1671.   /* Try the preferred nodes first. Ignore need_uptime and need_capacity
  1672.    * and need_guard, since the user explicitly asked for these nodes. */
  1673.   if (preferred) {
  1674.     sl = smartlist_create();
  1675.     add_nickname_list_to_smartlist(sl,preferred,1);
  1676.     smartlist_subtract(sl,excludednodes);
  1677.     if (excludedsmartlist)
  1678.       smartlist_subtract(sl,excludedsmartlist);
  1679.     if (excludedset)
  1680.       routerset_subtract_routers(sl,excludedset);
  1681.     choice = smartlist_choose(sl);
  1682.     smartlist_free(sl);
  1683.   }
  1684.   if (!choice && !strict) {
  1685.     /* Then give up on our preferred choices: any node
  1686.      * will do that has the required attributes. */
  1687.     sl = smartlist_create();
  1688.     router_add_running_routers_to_smartlist(sl, allow_invalid,
  1689.                                             need_uptime, need_capacity,
  1690.                                             need_guard);
  1691.     smartlist_subtract(sl,excludednodes);
  1692.     if (excludedsmartlist)
  1693.       smartlist_subtract(sl,excludedsmartlist);
  1694.     if (excludedset)
  1695.       routerset_subtract_routers(sl,excludedset);
  1696.     if (need_capacity || need_guard)
  1697.       choice = routerlist_sl_choose_by_bandwidth(sl, rule);
  1698.     else
  1699.       choice = smartlist_choose(sl);
  1700.     smartlist_free(sl);
  1701.     if (!choice && (need_uptime || need_capacity || need_guard)) {
  1702.       /* try once more -- recurse but with fewer restrictions. */
  1703.       log_info(LD_CIRC,
  1704.                "We couldn't find any live%s%s%s routers; falling back "
  1705.                "to list of all routers.",
  1706.                need_capacity?", fast":"",
  1707.                need_uptime?", stable":"",
  1708.                need_guard?", guard":"");
  1709.       flags &= ~ (CRN_NEED_UPTIME|CRN_NEED_CAPACITY|CRN_NEED_GUARD);
  1710.       choice = router_choose_random_node(
  1711.                        NULL, excludedsmartlist, excludedset, flags);
  1712.     }
  1713.   }
  1714.   smartlist_free(excludednodes);
  1715.   if (!choice) {
  1716.     if (strict) {
  1717.       log_warn(LD_CIRC, "All preferred nodes were down when trying to choose "
  1718.                "node, and the Strict[...]Nodes option is set. Failing.");
  1719.     } else {
  1720.       log_warn(LD_CIRC,
  1721.                "No available nodes when trying to choose node. Failing.");
  1722.     }
  1723.   }
  1724.   return choice;
  1725. }
  1726. /** Helper: Return true iff the <b>identity_digest</b> and <b>nickname</b>
  1727.  * combination of a router, encoded in hexadecimal, matches <b>hexdigest</b>
  1728.  * (which is optionally prefixed with a single dollar sign).  Return false if
  1729.  * <b>hexdigest</b> is malformed, or it doesn't match.  */
  1730. static INLINE int
  1731. hex_digest_matches(const char *hexdigest, const char *identity_digest,
  1732.                    const char *nickname, int is_named)
  1733. {
  1734.   char digest[DIGEST_LEN];
  1735.   size_t len;
  1736.   tor_assert(hexdigest);
  1737.   if (hexdigest[0] == '$')
  1738.     ++hexdigest;
  1739.   len = strlen(hexdigest);
  1740.   if (len < HEX_DIGEST_LEN)
  1741.     return 0;
  1742.   else if (len > HEX_DIGEST_LEN &&
  1743.            (hexdigest[HEX_DIGEST_LEN] == '=' ||
  1744.             hexdigest[HEX_DIGEST_LEN] == '~')) {
  1745.     if (strcasecmp(hexdigest+HEX_DIGEST_LEN+1, nickname))
  1746.       return 0;
  1747.     if (hexdigest[HEX_DIGEST_LEN] == '=' && !is_named)
  1748.       return 0;
  1749.   }
  1750.   if (base16_decode(digest, DIGEST_LEN, hexdigest, HEX_DIGEST_LEN)<0)
  1751.     return 0;
  1752.   return (!memcmp(digest, identity_digest, DIGEST_LEN));
  1753. }
  1754. /** Return true iff the digest of <b>router</b>'s identity key,
  1755.  * encoded in hexadecimal, matches <b>hexdigest</b> (which is
  1756.  * optionally prefixed with a single dollar sign).  Return false if
  1757.  * <b>hexdigest</b> is malformed, or it doesn't match.  */
  1758. static INLINE int
  1759. router_hex_digest_matches(routerinfo_t *router, const char *hexdigest)
  1760. {
  1761.   return hex_digest_matches(hexdigest, router->cache_info.identity_digest,
  1762.                             router->nickname, router->is_named);
  1763. }
  1764. /** Return true if <b>router</b>'s nickname matches <b>nickname</b>
  1765.  * (case-insensitive), or if <b>router's</b> identity key digest
  1766.  * matches a hexadecimal value stored in <b>nickname</b>.  Return
  1767.  * false otherwise. */
  1768. static int
  1769. router_nickname_matches(routerinfo_t *router, const char *nickname)
  1770. {
  1771.   if (nickname[0]!='$' && !strcasecmp(router->nickname, nickname))
  1772.     return 1;
  1773.   return router_hex_digest_matches(router, nickname);
  1774. }
  1775. /** Return the router in our routerlist whose (case-insensitive)
  1776.  * nickname or (case-sensitive) hexadecimal key digest is
  1777.  * <b>nickname</b>.  Return NULL if no such router is known.
  1778.  */
  1779. routerinfo_t *
  1780. router_get_by_nickname(const char *nickname, int warn_if_unnamed)
  1781. {
  1782.   int maybedigest;
  1783.   char digest[DIGEST_LEN];
  1784.   routerinfo_t *best_match=NULL;
  1785.   int n_matches = 0;
  1786.   const char *named_digest = NULL;
  1787.   tor_assert(nickname);
  1788.   if (!routerlist)
  1789.     return NULL;
  1790.   if (nickname[0] == '$')
  1791.     return router_get_by_hexdigest(nickname);
  1792.   if (!strcasecmp(nickname, UNNAMED_ROUTER_NICKNAME))
  1793.     return NULL;
  1794.   if (server_mode(get_options()) &&
  1795.       !strcasecmp(nickname, get_options()->Nickname))
  1796.     return router_get_my_routerinfo();
  1797.   maybedigest = (strlen(nickname) >= HEX_DIGEST_LEN) &&
  1798.     (base16_decode(digest,DIGEST_LEN,nickname,HEX_DIGEST_LEN) == 0);
  1799.   if ((named_digest = networkstatus_get_router_digest_by_nickname(nickname))) {
  1800.     return rimap_get(routerlist->identity_map, named_digest);
  1801.   }
  1802.   if (networkstatus_nickname_is_unnamed(nickname))
  1803.     return NULL;
  1804.   /* If we reach this point, there's no canonical value for the nickname. */
  1805.   SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, router,
  1806.   {
  1807.     if (!strcasecmp(router->nickname, nickname)) {
  1808.       ++n_matches;
  1809.       if (n_matches <= 1 || router->is_running)
  1810.         best_match = router;
  1811.     } else if (maybedigest &&
  1812.                !memcmp(digest, router->cache_info.identity_digest, DIGEST_LEN)
  1813.                ) {
  1814.       if (router_hex_digest_matches(router, nickname))
  1815.         return router;
  1816.       /* If we reach this point, we have a ID=name syntax that matches the
  1817.        * identity but not the name. That isn't an acceptable match. */
  1818.     }
  1819.   });
  1820.   if (best_match) {
  1821.     if (warn_if_unnamed && n_matches > 1) {
  1822.       smartlist_t *fps = smartlist_create();
  1823.       int any_unwarned = 0;
  1824.       SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, router,
  1825.         {
  1826.           routerstatus_t *rs;
  1827.           char *desc;
  1828.           size_t dlen;
  1829.           char fp[HEX_DIGEST_LEN+1];
  1830.           if (strcasecmp(router->nickname, nickname))
  1831.             continue;
  1832.           rs = router_get_consensus_status_by_id(
  1833.                                           router->cache_info.identity_digest);
  1834.           if (rs && !rs->name_lookup_warned) {
  1835.             rs->name_lookup_warned = 1;
  1836.             any_unwarned = 1;
  1837.           }
  1838.           base16_encode(fp, sizeof(fp),
  1839.                         router->cache_info.identity_digest, DIGEST_LEN);
  1840.           dlen = 32 + HEX_DIGEST_LEN + strlen(router->address);
  1841.           desc = tor_malloc(dlen);
  1842.           tor_snprintf(desc, dlen, ""$%s" for the one at %s:%d",
  1843.                        fp, router->address, router->or_port);
  1844.           smartlist_add(fps, desc);
  1845.         });
  1846.       if (any_unwarned) {
  1847.         char *alternatives = smartlist_join_strings(fps, "; ",0,NULL);
  1848.         log_warn(LD_CONFIG,
  1849.                  "There are multiple matches for the nickname "%s","
  1850.                  " but none is listed as named by the directory authorities. "
  1851.                  "Choosing one arbitrarily. If you meant one in particular, "
  1852.                  "you should say %s.", nickname, alternatives);
  1853.         tor_free(alternatives);
  1854.       }
  1855.       SMARTLIST_FOREACH(fps, char *, cp, tor_free(cp));
  1856.       smartlist_free(fps);
  1857.     } else if (warn_if_unnamed) {
  1858.       routerstatus_t *rs = router_get_consensus_status_by_id(
  1859.           best_match->cache_info.identity_digest);
  1860.       if (rs && !rs->name_lookup_warned) {
  1861.         char fp[HEX_DIGEST_LEN+1];
  1862.         base16_encode(fp, sizeof(fp),
  1863.                       best_match->cache_info.identity_digest, DIGEST_LEN);
  1864.         log_warn(LD_CONFIG, "You specified a server "%s" by name, but this "
  1865.              "name is not registered, so it could be used by any server, "
  1866.              "not just the one you meant. "
  1867.              "To make sure you get the same server in the future, refer to "
  1868.              "it by key, as "$%s".", nickname, fp);
  1869.         rs->name_lookup_warned = 1;
  1870.       }
  1871.     }
  1872.     return best_match;
  1873.   }
  1874.   return NULL;
  1875. }
  1876. /** Try to find a routerinfo for <b>digest</b>. If we don't have one,
  1877.  * return 1. If we do, ask tor_version_as_new_as() for the answer.
  1878.  */
  1879. int
  1880. router_digest_version_as_new_as(const char *digest, const char *cutoff)
  1881. {
  1882.   routerinfo_t *router = router_get_by_digest(digest);
  1883.   if (!router)
  1884.     return 1;
  1885.   return tor_version_as_new_as(router->platform, cutoff);
  1886. }
  1887. /** Return true iff <b>digest</b> is the digest of the identity key of a
  1888.  * trusted directory matching at least one bit of <b>type</b>.  If <b>type</b>
  1889.  * is zero, any authority is okay. */
  1890. int
  1891. router_digest_is_trusted_dir_type(const char *digest, authority_type_t type)
  1892. {
  1893.   if (!trusted_dir_servers)
  1894.     return 0;
  1895.   if (authdir_mode(get_options()) && router_digest_is_me(digest))
  1896.     return 1;
  1897.   SMARTLIST_FOREACH(trusted_dir_servers, trusted_dir_server_t *, ent,
  1898.     if (!memcmp(digest, ent->digest, DIGEST_LEN)) {
  1899.       return (!type) || ((type & ent->type) != 0);
  1900.     });
  1901.   return 0;
  1902. }
  1903. /** Return true iff <b>addr</b> is the address of one of our trusted
  1904.  * directory authorities. */
  1905. int
  1906. router_addr_is_trusted_dir(uint32_t addr)
  1907. {
  1908.   if (!trusted_dir_servers)
  1909.     return 0;
  1910.   SMARTLIST_FOREACH(trusted_dir_servers, trusted_dir_server_t *, ent,
  1911.     if (ent->addr == addr)
  1912.       return 1;
  1913.     );
  1914.   return 0;
  1915. }
  1916. /** If hexdigest is correctly formed, base16_decode it into
  1917.  * digest, which must have DIGEST_LEN space in it.
  1918.  * Return 0 on success, -1 on failure.
  1919.  */
  1920. int
  1921. hexdigest_to_digest(const char *hexdigest, char *digest)
  1922. {
  1923.   if (hexdigest[0]=='$')
  1924.     ++hexdigest;
  1925.   if (strlen(hexdigest) < HEX_DIGEST_LEN ||
  1926.       base16_decode(digest,DIGEST_LEN,hexdigest,HEX_DIGEST_LEN) < 0)
  1927.     return -1;
  1928.   return 0;
  1929. }
  1930. /** Return the router in our routerlist whose hexadecimal key digest
  1931.  * is <b>hexdigest</b>.  Return NULL if no such router is known. */
  1932. routerinfo_t *
  1933. router_get_by_hexdigest(const char *hexdigest)
  1934. {
  1935.   char digest[DIGEST_LEN];
  1936.   size_t len;
  1937.   routerinfo_t *ri;
  1938.   tor_assert(hexdigest);
  1939.   if (!routerlist)
  1940.     return NULL;
  1941.   if (hexdigest[0]=='$')
  1942.     ++hexdigest;
  1943.   len = strlen(hexdigest);
  1944.   if (hexdigest_to_digest(hexdigest, digest) < 0)
  1945.     return NULL;
  1946.   ri = router_get_by_digest(digest);
  1947.   if (ri && len > HEX_DIGEST_LEN) {
  1948.     if (hexdigest[HEX_DIGEST_LEN] == '=') {
  1949.       if (strcasecmp(ri->nickname, hexdigest+HEX_DIGEST_LEN+1) ||
  1950.           !ri->is_named)
  1951.         return NULL;
  1952.     } else if (hexdigest[HEX_DIGEST_LEN] == '~') {
  1953.       if (strcasecmp(ri->nickname, hexdigest+HEX_DIGEST_LEN+1))
  1954.         return NULL;
  1955.     } else {
  1956.       return NULL;
  1957.     }
  1958.   }
  1959.   return ri;
  1960. }
  1961. /** Return the router in our routerlist whose 20-byte key digest
  1962.  * is <b>digest</b>.  Return NULL if no such router is known. */
  1963. routerinfo_t *
  1964. router_get_by_digest(const char *digest)
  1965. {
  1966.   tor_assert(digest);
  1967.   if (!routerlist) return NULL;
  1968.   // routerlist_assert_ok(routerlist);
  1969.   return rimap_get(routerlist->identity_map, digest);
  1970. }
  1971. /** Return the router in our routerlist whose 20-byte descriptor
  1972.  * is <b>digest</b>.  Return NULL if no such router is known. */
  1973. signed_descriptor_t *
  1974. router_get_by_descriptor_digest(const char *digest)
  1975. {
  1976.   tor_assert(digest);
  1977.   if (!routerlist) return NULL;
  1978.   return sdmap_get(routerlist->desc_digest_map, digest);
  1979. }
  1980. /** Return the signed descriptor for the router in our routerlist whose
  1981.  * 20-byte extra-info digest is <b>digest</b>.  Return NULL if no such router
  1982.  * is known. */
  1983. signed_descriptor_t *
  1984. router_get_by_extrainfo_digest(const char *digest)
  1985. {
  1986.   tor_assert(digest);
  1987.   if (!routerlist) return NULL;
  1988.   return sdmap_get(routerlist->desc_by_eid_map, digest);
  1989. }
  1990. /** Return the signed descriptor for the extrainfo_t in our routerlist whose
  1991.  * extra-info-digest is <b>digest</b>. Return NULL if no such extra-info
  1992.  * document is known. */
  1993. signed_descriptor_t *
  1994. extrainfo_get_by_descriptor_digest(const char *digest)
  1995. {
  1996.   extrainfo_t *ei;
  1997.   tor_assert(digest);
  1998.   if (!routerlist) return NULL;
  1999.   ei = eimap_get(routerlist->extra_info_map, digest);
  2000.   return ei ? &ei->cache_info : NULL;
  2001. }
  2002. /** Return a pointer to the signed textual representation of a descriptor.
  2003.  * The returned string is not guaranteed to be NUL-terminated: the string's
  2004.  * length will be in desc->signed_descriptor_len.
  2005.  *
  2006.  * If <b>with_annotations</b> is set, the returned string will include
  2007.  * the annotations
  2008.  * (if any) preceding the descriptor.  This will increase the length of the
  2009.  * string by desc->annotations_len.
  2010.  *
  2011.  * The caller must not free the string returned.
  2012.  */
  2013. static const char *
  2014. signed_descriptor_get_body_impl(signed_descriptor_t *desc,
  2015.                                 int with_annotations)
  2016. {
  2017.   const char *r = NULL;
  2018.   size_t len = desc->signed_descriptor_len;
  2019.   off_t offset = desc->saved_offset;
  2020.   if (with_annotations)
  2021.     len += desc->annotations_len;
  2022.   else
  2023.     offset += desc->annotations_len;
  2024.   tor_assert(len > 32);
  2025.   if (desc->saved_location == SAVED_IN_CACHE && routerlist) {
  2026.     desc_store_t *store = desc_get_store(router_get_routerlist(), desc);
  2027.     if (store && store->mmap) {
  2028.       tor_assert(desc->saved_offset + len <= store->mmap->size);
  2029.       r = store->mmap->data + offset;
  2030.     } else if (store) {
  2031.       log_err(LD_DIR, "We couldn't read a descriptor that is supposedly "
  2032.               "mmaped in our cache.  Is another process running in our data "
  2033.               "directory?  Exiting.");
  2034.       exit(1);
  2035.     }
  2036.   }
  2037.   if (!r) /* no mmap, or not in cache. */
  2038.     r = desc->signed_descriptor_body +
  2039.       (with_annotations ? 0 : desc->annotations_len);
  2040.   tor_assert(r);
  2041.   if (!with_annotations) {
  2042.     if (memcmp("router ", r, 7) && memcmp("extra-info ", r, 11)) {
  2043.       char *cp = tor_strndup(r, 64);
  2044.       log_err(LD_DIR, "descriptor at %p begins with unexpected string %s.  "
  2045.               "Is another process running in our data directory?  Exiting.",
  2046.               desc, escaped(cp));
  2047.       exit(1);
  2048.     }
  2049.   }
  2050.   return r;
  2051. }
  2052. /** Return a pointer to the signed textual representation of a descriptor.
  2053.  * The returned string is not guaranteed to be NUL-terminated: the string's
  2054.  * length will be in desc->signed_descriptor_len.
  2055.  *
  2056.  * The caller must not free the string returned.
  2057.  */
  2058. const char *
  2059. signed_descriptor_get_body(signed_descriptor_t *desc)
  2060. {
  2061.   return signed_descriptor_get_body_impl(desc, 0);
  2062. }
  2063. /** As signed_descriptor_get_body(), but points to the beginning of the
  2064.  * annotations section rather than the beginning of the descriptor. */
  2065. const char *
  2066. signed_descriptor_get_annotations(signed_descriptor_t *desc)
  2067. {
  2068.   return signed_descriptor_get_body_impl(desc, 1);
  2069. }
  2070. /** Return the current list of all known routers. */
  2071. routerlist_t *
  2072. router_get_routerlist(void)
  2073. {
  2074.   if (PREDICT_UNLIKELY(!routerlist)) {
  2075.     routerlist = tor_malloc_zero(sizeof(routerlist_t));
  2076.     routerlist->routers = smartlist_create();
  2077.     routerlist->old_routers = smartlist_create();
  2078.     routerlist->identity_map = rimap_new();
  2079.     routerlist->desc_digest_map = sdmap_new();
  2080.     routerlist->desc_by_eid_map = sdmap_new();
  2081.     routerlist->extra_info_map = eimap_new();
  2082.     routerlist->desc_store.fname_base = "cached-descriptors";
  2083.     routerlist->desc_store.fname_alt_base = "cached-routers";
  2084.     routerlist->extrainfo_store.fname_base = "cached-extrainfo";
  2085.     routerlist->desc_store.type = ROUTER_STORE;
  2086.     routerlist->extrainfo_store.type = EXTRAINFO_STORE;
  2087.     routerlist->desc_store.description = "router descriptors";
  2088.     routerlist->extrainfo_store.description = "extra-info documents";
  2089.   }
  2090.   return routerlist;
  2091. }
  2092. /** Free all storage held by <b>router</b>. */
  2093. void
  2094. routerinfo_free(routerinfo_t *router)
  2095. {
  2096.   if (!router)
  2097.     return;
  2098.   tor_free(router->cache_info.signed_descriptor_body);
  2099.   tor_free(router->address);
  2100.   tor_free(router->nickname);
  2101.   tor_free(router->platform);
  2102.   tor_free(router->contact_info);
  2103.   if (router->onion_pkey)
  2104.     crypto_free_pk_env(router->onion_pkey);
  2105.   if (router->identity_pkey)
  2106.     crypto_free_pk_env(router->identity_pkey);
  2107.   if (router->declared_family) {
  2108.     SMARTLIST_FOREACH(router->declared_family, char *, s, tor_free(s));
  2109.     smartlist_free(router->declared_family);
  2110.   }
  2111.   addr_policy_list_free(router->exit_policy);
  2112.   /* XXXX Remove if this turns out to affect performance. */
  2113.   memset(router, 77, sizeof(routerinfo_t));
  2114.   tor_free(router);
  2115. }
  2116. /** Release all storage held by <b>extrainfo</b> */
  2117. void
  2118. extrainfo_free(extrainfo_t *extrainfo)
  2119. {
  2120.   if (!extrainfo)
  2121.     return;
  2122.   tor_free(extrainfo->cache_info.signed_descriptor_body);
  2123.   tor_free(extrainfo->pending_sig);
  2124.   /* XXXX remove this if it turns out to slow us down. */
  2125.   memset(extrainfo, 88, sizeof(extrainfo_t)); /* debug bad memory usage */
  2126.   tor_free(extrainfo);
  2127. }
  2128. /** Release storage held by <b>sd</b>. */
  2129. static void
  2130. signed_descriptor_free(signed_descriptor_t *sd)
  2131. {
  2132.   tor_free(sd->signed_descriptor_body);
  2133.   /* XXXX remove this once more bugs go away. */
  2134.   memset(sd, 99, sizeof(signed_descriptor_t)); /* Debug bad mem usage */
  2135.   tor_free(sd);
  2136. }
  2137. /** Extract a signed_descriptor_t from a routerinfo, and free the routerinfo.
  2138.  */
  2139. static signed_descriptor_t *
  2140. signed_descriptor_from_routerinfo(routerinfo_t *ri)
  2141. {
  2142.   signed_descriptor_t *sd = tor_malloc_zero(sizeof(signed_descriptor_t));
  2143.   memcpy(sd, &(ri->cache_info), sizeof(signed_descriptor_t));
  2144.   sd->routerlist_index = -1;
  2145.   ri->cache_info.signed_descriptor_body = NULL;
  2146.   routerinfo_free(ri);
  2147.   return sd;
  2148. }
  2149. /** Helper: free the storage held by the extrainfo_t in <b>e</b>. */
  2150. static void
  2151. _extrainfo_free(void *e)
  2152. {
  2153.   extrainfo_free(e);
  2154. }
  2155. /** Free all storage held by a routerlist <b>rl</b>. */
  2156. void
  2157. routerlist_free(routerlist_t *rl)
  2158. {
  2159.   tor_assert(rl);
  2160.   rimap_free(rl->identity_map, NULL);
  2161.   sdmap_free(rl->desc_digest_map, NULL);
  2162.   sdmap_free(rl->desc_by_eid_map, NULL);
  2163.   eimap_free(rl->extra_info_map, _extrainfo_free);
  2164.   SMARTLIST_FOREACH(rl->routers, routerinfo_t *, r,
  2165.                     routerinfo_free(r));
  2166.   SMARTLIST_FOREACH(rl->old_routers, signed_descriptor_t *, sd,
  2167.                     signed_descriptor_free(sd));
  2168.   smartlist_free(rl->routers);
  2169.   smartlist_free(rl->old_routers);
  2170.   if (routerlist->desc_store.mmap)
  2171.     tor_munmap_file(routerlist->desc_store.mmap);
  2172.   if (routerlist->extrainfo_store.mmap)
  2173.     tor_munmap_file(routerlist->extrainfo_store.mmap);
  2174.   tor_free(rl);
  2175.   router_dir_info_changed();
  2176. }
  2177. /** Log information about how much memory is being used for routerlist,
  2178.  * at log level <b>severity</b>. */
  2179. void
  2180. dump_routerlist_mem_usage(int severity)
  2181. {
  2182.   uint64_t livedescs = 0;
  2183.   uint64_t olddescs = 0;
  2184.   if (!routerlist)
  2185.     return;
  2186.   SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, r,
  2187.                     livedescs += r->cache_info.signed_descriptor_len);
  2188.   SMARTLIST_FOREACH(routerlist->old_routers, signed_descriptor_t *, sd,
  2189.                     olddescs += sd->signed_descriptor_len);
  2190.   log(severity, LD_DIR,
  2191.       "In %d live descriptors: "U64_FORMAT" bytes.  "
  2192.       "In %d old descriptors: "U64_FORMAT" bytes.",
  2193.       smartlist_len(routerlist->routers), U64_PRINTF_ARG(livedescs),
  2194.       smartlist_len(routerlist->old_routers), U64_PRINTF_ARG(olddescs));
  2195. #if 0
  2196.   {
  2197.     const smartlist_t *networkstatus_v2_list = networkstatus_get_v2_list();
  2198.     networkstatus_t *consensus = networkstatus_get_latest_consensus();
  2199.     log(severity, LD_DIR, "Now let's look through old_descriptors!");
  2200.     SMARTLIST_FOREACH(routerlist->old_routers, signed_descriptor_t *, sd, {
  2201.         int in_v2 = 0;
  2202.         int in_v3 = 0;
  2203.         char published[ISO_TIME_LEN+1];
  2204.         char last_valid_until[ISO_TIME_LEN+1];
  2205.         char last_served_at[ISO_TIME_LEN+1];
  2206.         char id[HEX_DIGEST_LEN+1];
  2207.         routerstatus_t *rs;
  2208.         format_iso_time(published, sd->published_on);
  2209.         format_iso_time(last_valid_until, sd->last_listed_as_valid_until);
  2210.         format_iso_time(last_served_at, sd->last_served_at);
  2211.         base16_encode(id, sizeof(id), sd->identity_digest, DIGEST_LEN);
  2212.         SMARTLIST_FOREACH(networkstatus_v2_list, networkstatus_v2_t *, ns,
  2213.           {
  2214.             rs = networkstatus_v2_find_entry(ns, sd->identity_digest);
  2215.             if (rs && !memcmp(rs->descriptor_digest,
  2216.                               sd->signed_descriptor_digest, DIGEST_LEN)) {
  2217.               in_v2 = 1; break;
  2218.             }
  2219.           });
  2220.         if (consensus) {
  2221.           rs = networkstatus_vote_find_entry(consensus, sd->identity_digest);
  2222.           if (rs && !memcmp(rs->descriptor_digest,
  2223.                             sd->signed_descriptor_digest, DIGEST_LEN))
  2224.             in_v3 = 1;
  2225.         }
  2226.         log(severity, LD_DIR,
  2227.             "Old descriptor for %s (published %s) %sin v2 ns, %sin v3 "
  2228.             "consensus.  Last valid until %s; last served at %s.",
  2229.             id, published, in_v2 ? "" : "not ", in_v3 ? "" : "not ",
  2230.             last_valid_until, last_served_at);
  2231.     });
  2232.   }
  2233. #endif
  2234. }
  2235. /** Debugging helper: If <b>idx</b> is nonnegative, assert that <b>ri</b> is
  2236.  * in <b>sl</b> at position <b>idx</b>. Otherwise, search <b>sl</b> for
  2237.  * <b>ri</b>.  Return the index of <b>ri</b> in <b>sl</b>, or -1 if <b>ri</b>
  2238.  * is not in <b>sl</b>. */
  2239. static INLINE int
  2240. _routerlist_find_elt(smartlist_t *sl, void *ri, int idx)
  2241. {
  2242.   if (idx < 0) {
  2243.     idx = -1;
  2244.     SMARTLIST_FOREACH(sl, routerinfo_t *, r,
  2245.                       if (r == ri) {
  2246.                         idx = r_sl_idx;
  2247.                         break;
  2248.                       });
  2249.   } else {
  2250.     tor_assert(idx < smartlist_len(sl));
  2251.     tor_assert(smartlist_get(sl, idx) == ri);
  2252.   };
  2253.   return idx;
  2254. }
  2255. /** Insert an item <b>ri</b> into the routerlist <b>rl</b>, updating indices
  2256.  * as needed.  There must be no previous member of <b>rl</b> with the same
  2257.  * identity digest as <b>ri</b>: If there is, call routerlist_replace
  2258.  * instead.
  2259.  */
  2260. static void
  2261. routerlist_insert(routerlist_t *rl, routerinfo_t *ri)
  2262. {
  2263.   routerinfo_t *ri_old;
  2264.   {
  2265.     /* XXXX Remove if this slows us down. */
  2266.     routerinfo_t *ri_generated = router_get_my_routerinfo();
  2267.     tor_assert(ri_generated != ri);
  2268.   }
  2269.   tor_assert(ri->cache_info.routerlist_index == -1);
  2270.   ri_old = rimap_set(rl->identity_map, ri->cache_info.identity_digest, ri);
  2271.   tor_assert(!ri_old);
  2272.   sdmap_set(rl->desc_digest_map, ri->cache_info.signed_descriptor_digest,
  2273.             &(ri->cache_info));
  2274.   if (!tor_digest_is_zero(ri->cache_info.extra_info_digest))
  2275.     sdmap_set(rl->desc_by_eid_map, ri->cache_info.extra_info_digest,
  2276.               &ri->cache_info);
  2277.   smartlist_add(rl->routers, ri);
  2278.   ri->cache_info.routerlist_index = smartlist_len(rl->routers) - 1;
  2279.   router_dir_info_changed();
  2280. #ifdef DEBUG_ROUTERLIST
  2281.   routerlist_assert_ok(rl);
  2282. #endif
  2283. }
  2284. /** Adds the extrainfo_t <b>ei</b> to the routerlist <b>rl</b>, if there is a
  2285.  * corresponding router in rl->routers or rl->old_routers.  Return true iff
  2286.  * we actually inserted <b>ei</b>.  Free <b>ei</b> if it isn't inserted. */
  2287. static int
  2288. extrainfo_insert(routerlist_t *rl, extrainfo_t *ei)
  2289. {
  2290.   int r = 0;
  2291.   routerinfo_t *ri = rimap_get(rl->identity_map,
  2292.                                ei->cache_info.identity_digest);
  2293.   signed_descriptor_t *sd =
  2294.     sdmap_get(rl->desc_by_eid_map, ei->cache_info.signed_descriptor_digest);
  2295.   extrainfo_t *ei_tmp;
  2296.   {
  2297.     /* XXXX remove this code if it slows us down. */
  2298.     extrainfo_t *ei_generated = router_get_my_extrainfo();
  2299.     tor_assert(ei_generated != ei);
  2300.   }
  2301.   if (!ri) {
  2302.     /* This router is unknown; we can't even verify the signature. Give up.*/
  2303.     goto done;
  2304.   }
  2305.   if (routerinfo_incompatible_with_extrainfo(ri, ei, sd, NULL)) {
  2306.     goto done;
  2307.   }
  2308.   /* Okay, if we make it here, we definitely have a router corresponding to
  2309.    * this extrainfo. */
  2310.   ei_tmp = eimap_set(rl->extra_info_map,
  2311.                      ei->cache_info.signed_descriptor_digest,
  2312.                      ei);
  2313.   r = 1;
  2314.   if (ei_tmp) {
  2315.     rl->extrainfo_store.bytes_dropped +=
  2316.       ei_tmp->cache_info.signed_descriptor_len;
  2317.     extrainfo_free(ei_tmp);
  2318.   }
  2319.  done:
  2320.   if (r == 0)
  2321.     extrainfo_free(ei);
  2322. #ifdef DEBUG_ROUTERLIST
  2323.   routerlist_assert_ok(rl);
  2324. #endif
  2325.   return r;
  2326. }
  2327. #define should_cache_old_descriptors() 
  2328.   directory_caches_dir_info(get_options())
  2329. /** If we're a directory cache and routerlist <b>rl</b> doesn't have
  2330.  * a copy of router <b>ri</b> yet, add it to the list of old (not
  2331.  * recommended but still served) descriptors. Else free it. */
  2332. static void
  2333. routerlist_insert_old(routerlist_t *rl, routerinfo_t *ri)
  2334. {
  2335.   {
  2336.     /* XXXX remove this code if it slows us down. */
  2337.     routerinfo_t *ri_generated = router_get_my_routerinfo();
  2338.     tor_assert(ri_generated != ri);
  2339.   }
  2340.   tor_assert(ri->cache_info.routerlist_index == -1);
  2341.   if (should_cache_old_descriptors() &&
  2342.       ri->purpose == ROUTER_PURPOSE_GENERAL &&
  2343.       !sdmap_get(rl->desc_digest_map,
  2344.                  ri->cache_info.signed_descriptor_digest)) {
  2345.     signed_descriptor_t *sd = signed_descriptor_from_routerinfo(ri);
  2346.     sdmap_set(rl->desc_digest_map, sd->signed_descriptor_digest, sd);
  2347.     smartlist_add(rl->old_routers, sd);
  2348.     sd->routerlist_index = smartlist_len(rl->old_routers)-1;
  2349.     if (!tor_digest_is_zero(sd->extra_info_digest))
  2350.       sdmap_set(rl->desc_by_eid_map, sd->extra_info_digest, sd);
  2351.   } else {
  2352.     routerinfo_free(ri);
  2353.   }
  2354. #ifdef DEBUG_ROUTERLIST
  2355.   routerlist_assert_ok(rl);
  2356. #endif
  2357. }
  2358. /** Remove an item <b>ri</b> from the routerlist <b>rl</b>, updating indices
  2359.  * as needed. If <b>idx</b> is nonnegative and smartlist_get(rl-&gt;routers,
  2360.  * idx) == ri, we don't need to do a linear search over the list to decide
  2361.  * which to remove.  We fill the gap in rl-&gt;routers with a later element in
  2362.  * the list, if any exists. <b>ri</b> is freed.
  2363.  *
  2364.  * If <b>make_old</b> is true, instead of deleting the router, we try adding
  2365.  * it to rl-&gt;old_routers. */
  2366. void
  2367. routerlist_remove(routerlist_t *rl, routerinfo_t *ri, int make_old, time_t now)
  2368. {
  2369.   routerinfo_t *ri_tmp;
  2370.   extrainfo_t *ei_tmp;
  2371.   int idx = ri->cache_info.routerlist_index;
  2372.   tor_assert(0 <= idx && idx < smartlist_len(rl->routers));
  2373.   tor_assert(smartlist_get(rl->routers, idx) == ri);
  2374.   /* make sure the rephist module knows that it's not running */
  2375.   rep_hist_note_router_unreachable(ri->cache_info.identity_digest, now);
  2376.   ri->cache_info.routerlist_index = -1;
  2377.   smartlist_del(rl->routers, idx);
  2378.   if (idx < smartlist_len(rl->routers)) {
  2379.     routerinfo_t *r = smartlist_get(rl->routers, idx);
  2380.     r->cache_info.routerlist_index = idx;
  2381.   }
  2382.   ri_tmp = rimap_remove(rl->identity_map, ri->cache_info.identity_digest);
  2383.   router_dir_info_changed();
  2384.   tor_assert(ri_tmp == ri);
  2385.   if (make_old && should_cache_old_descriptors() &&
  2386.       ri->purpose == ROUTER_PURPOSE_GENERAL) {
  2387.     signed_descriptor_t *sd;
  2388.     sd = signed_descriptor_from_routerinfo(ri);
  2389.     smartlist_add(rl->old_routers, sd);
  2390.     sd->routerlist_index = smartlist_len(rl->old_routers)-1;
  2391.     sdmap_set(rl->desc_digest_map, sd->signed_descriptor_digest, sd);
  2392.     if (!tor_digest_is_zero(sd->extra_info_digest))
  2393.       sdmap_set(rl->desc_by_eid_map, sd->extra_info_digest, sd);
  2394.   } else {
  2395.     signed_descriptor_t *sd_tmp;
  2396.     sd_tmp = sdmap_remove(rl->desc_digest_map,
  2397.                           ri->cache_info.signed_descriptor_digest);
  2398.     tor_assert(sd_tmp == &(ri->cache_info));
  2399.     rl->desc_store.bytes_dropped += ri->cache_info.signed_descriptor_len;
  2400.     ei_tmp = eimap_remove(rl->extra_info_map,
  2401.                           ri->cache_info.extra_info_digest);
  2402.     if (ei_tmp) {
  2403.       rl->extrainfo_store.bytes_dropped +=
  2404.         ei_tmp->cache_info.signed_descriptor_len;
  2405.       extrainfo_free(ei_tmp);
  2406.     }
  2407.     if (!tor_digest_is_zero(ri->cache_info.extra_info_digest))
  2408.       sdmap_remove(rl->desc_by_eid_map, ri->cache_info.extra_info_digest);
  2409.     routerinfo_free(ri);
  2410.   }
  2411. #ifdef DEBUG_ROUTERLIST
  2412.   routerlist_assert_ok(rl);
  2413. #endif
  2414. }
  2415. /** Remove a signed_descriptor_t <b>sd</b> from <b>rl</b>->old_routers, and
  2416.  * adjust <b>rl</b> as appropriate.  <b>idx</b> is -1, or the index of
  2417.  * <b>sd</b>. */
  2418. static void
  2419. routerlist_remove_old(routerlist_t *rl, signed_descriptor_t *sd, int idx)
  2420. {
  2421.   signed_descriptor_t *sd_tmp;
  2422.   extrainfo_t *ei_tmp;
  2423.   desc_store_t *store;
  2424.   if (idx == -1) {
  2425.     idx = sd->routerlist_index;
  2426.   }
  2427.   tor_assert(0 <= idx && idx < smartlist_len(rl->old_routers));
  2428.   /* XXXX edmanm's bridge relay triggered the following assert while
  2429.    * running 0.2.0.12-alpha.  If anybody triggers this again, see if we
  2430.    * can get a backtrace. */
  2431.   tor_assert(smartlist_get(rl->old_routers, idx) == sd);
  2432.   tor_assert(idx == sd->routerlist_index);
  2433.   sd->routerlist_index = -1;
  2434.   smartlist_del(rl->old_routers, idx);
  2435.   if (idx < smartlist_len(rl->old_routers)) {
  2436.     signed_descriptor_t *d = smartlist_get(rl->old_routers, idx);
  2437.     d->routerlist_index = idx;
  2438.   }
  2439.   sd_tmp = sdmap_remove(rl->desc_digest_map,
  2440.                         sd->signed_descriptor_digest);
  2441.   tor_assert(sd_tmp == sd);
  2442.   store = desc_get_store(rl, sd);
  2443.   if (store)
  2444.     store->bytes_dropped += sd->signed_descriptor_len;
  2445.   ei_tmp = eimap_remove(rl->extra_info_map,