Commit 66930319 authored by Nick Mathewson's avatar Nick Mathewson 🤹
Browse files

Use a separate type for "local view of router status". Also, even though I... 

Use a separate type for "local view of router status". Also, even though I told arma there was no need, replace an ugly O ( n lg n ) algorithm with a nice O ( n ) algorithm when stepping through servers. Some ugliness is just too bad to stand.


svn:r5109
parent 959598fa

src/or/directory.c

+1 −1
Original line number Diff line number Diff line
@@ -1557,7 +1557,7 @@ static void 
dir_routerdesc_download_failed(smartlist_t *failed)

{

  char digest[DIGEST_LEN];

  routerstatus_t *rs;

  local_routerstatus_t *rs;

  SMARTLIST_FOREACH(failed, const char *, cp,

  {

    base16_decode(digest, DIGEST_LEN, cp, strlen(cp));

src/or/or.h

+8 −4
Original line number Diff line number Diff line
@@ -800,11 +800,15 @@ typedef struct routerstatus_t { 
  unsigned int is_running:1; /**< True iff this router is up. */

  unsigned int is_named:1; /**< True iff "nickname" belongs to this router. */

  unsigned int is_valid:1; /**< True iff this router is validated. */

  uint8_t n_download_failures; /**< Only used in summary list: number of

                                * failures trying to download the most

                                * recent descriptor. */

} routerstatus_t;



/** DOCDOC */

typedef struct local_routerstatus_t {

  routerstatus_t status;

  uint8_t n_download_failures; /**< Number of failures trying to download the

                                * most recent descriptor. */

} local_routerstatus_t;



/*XXXX011 make this configurable? */

#define MAX_ROUTERDESC_DOWNLOAD_FAILURES 8
@@ -2116,7 +2120,7 @@ void add_trusted_dir_server(const char *addr, uint16_t port, 
                            const char *digest, int supports_v1);

void clear_trusted_dir_servers(void);

networkstatus_t *networkstatus_get_by_digest(const char *digest);

routerstatus_t *router_get_combined_status_by_digest(const char *digest);

local_routerstatus_t *router_get_combined_status_by_digest(const char *digest);

void update_networkstatus_cache_downloads(time_t now);

void update_networkstatus_client_downloads(time_t now);

void update_router_descriptor_downloads(time_t now);

src/or/routerlist.c

+79 −44
Original line number Diff line number Diff line
@@ -1554,7 +1554,7 @@ networkstatus_find_entry(networkstatus_t *ns, const char *digest) 
}



/*DOCDOC*/

routerstatus_t *

local_routerstatus_t *

router_get_combined_status_by_digest(const char *digest)

{

  if (!routerstatus_list)
@@ -2133,8 +2133,9 @@ routerstatus_list_update_from_networkstatus(time_t now) 
  int n_trusted, n_statuses, n_recent=0, n_naming=0;

  int n_distinct = 0;

  int i;

  smartlist_t *all_statuses, *result;

  routerstatus_t *prev_rs;

  int *index, *size;

  networkstatus_t **networkstatus;

  smartlist_t *result;



  networkstatus_list_update_recent(now);
@@ -2159,37 +2160,66 @@ routerstatus_list_update_from_networkstatus(time_t now) 


  log_fn(LOG_NOTICE, "rebuilding router status list.");



  all_statuses = smartlist_create();

  result = smartlist_create();



  SMARTLIST_FOREACH(networkstatus_list, networkstatus_t *, ns,

  {

    if (ns->binds_names)

  index = tor_malloc(sizeof(int)*n_statuses);

  size = tor_malloc(sizeof(int)*n_statuses);

  networkstatus = tor_malloc(sizeof(networkstatus_t *)*n_statuses);

  for (i = 0; i < n_statuses; ++i) {

    index[i] = 0;

    networkstatus[i] = smartlist_get(networkstatus_list, i);

    size[i] = smartlist_len(networkstatus[i]->entries);

    if (networkstatus[i]->binds_names)

      ++n_naming;

    if (ns->is_recent)

    if (networkstatus[i]->is_recent)

      ++n_recent;

    smartlist_add_all(all_statuses, ns->entries);

  });

  }



  result = smartlist_create();



  sort_routerstatus_entries(all_statuses);

  for (i=0; i < smartlist_len(all_statuses); ++i) {

  /* Iterate through all of the sorted routerstatus lists in step.

   * Invariants:

   *  - For 0 <= i < n_statuses: index[i] is an index into

   *    networkstatus[i]->entries, which has size[i] elements.

   *  - For i1, i2, j such that 0 <= i1 < n_statuses, 0 <= i2 < n_statues, 0 <=

   *    j < index[i1], networkstatus[i1]->entries[j]->identity_digest <

   *    networkstatus[i2]->entries[index[i2]]->identity_digest.

   *

   *    (That is, the indices are always advanced past lower digest before

   *    higher.)

   */

  while (1) {

    int n_running=0, n_named=0, n_valid=0, n_listing=0;

    const char *the_name = NULL;

    routerstatus_t *d_rs = smartlist_get(all_statuses, i);

    routerstatus_t *rs_out, *rs, *most_recent;

    if (i>0 && ! memcmp(d_rs->identity_digest,

            ((routerstatus_t*)smartlist_get(all_statuses,i-1))->identity_digest,

                        DIGEST_LEN))

      continue;

    local_routerstatus_t *rs_out, *rs_old;

    routerstatus_t *rs, *most_recent;

    networkstatus_t *ns;

    const char *lowest = NULL;

    /* Find out which of the digests appears first. */

    for (i = 0; i < n_statuses; ++i) {

      if (index[i] < size[i]) {

        rs = smartlist_get(networkstatus[i]->entries, index[i]);

        if (!lowest || memcmp(rs->identity_digest, lowest, DIGEST_LEN)<0)

          lowest = rs->identity_digest;

      }

    }

    if (!lowest) {

      /* We're out of routers. Great! */

      break;

    }

    /* Okay. The routers at networkstatus[i]->entries[index[i]] whose digests

     * match "lowest" are next in order. Iterate over them, incrementing those

     * index[i] as we go. */

    ++n_distinct;

    prev_rs = most_recent = d_rs;

    SMARTLIST_FOREACH(networkstatus_list, networkstatus_t *, ns,

    {

      rs = networkstatus_find_entry(ns, d_rs->identity_digest);

      if (!rs)

    most_recent = NULL;

    for (i = 0; i < n_statuses; ++i) {

      if (index[i] >= size[i])

        continue;

      ns = networkstatus[i];

      rs = smartlist_get(ns->entries, index[i]);

      if (memcmp(rs->identity_digest, lowest, DIGEST_LEN))

        continue;

      ++index[i];

      ++n_listing;

      if (rs->published_on > most_recent->published_on)

      if (!most_recent || rs->published_on > most_recent->published_on)

        most_recent = rs;

      if (rs->is_named && ns->binds_names) {

        if (!the_name)
@@ -2204,31 +2234,35 @@ routerstatus_list_update_from_networkstatus(time_t now) 
        ++n_valid;

      if (rs->is_running && ns->is_recent)

        ++n_running;

    });

    rs_out = tor_malloc(sizeof(routerstatus_t));

    memcpy(rs_out, most_recent, sizeof(routerstatus_t));

    if ((rs = router_get_combined_status_by_digest(d_rs->identity_digest))) {

      rs_out->n_download_failures = rs->n_download_failures;

    }

    rs_out = tor_malloc(sizeof(local_routerstatus_t));

    memcpy(&rs_out->status, most_recent, sizeof(routerstatus_t));

    if ((rs_old = router_get_combined_status_by_digest(lowest))) {

      rs_out->n_download_failures = rs_old->n_download_failures;

    }

    smartlist_add(result, rs_out);

    log_fn(LOG_DEBUG, "Router '%s' is listed by %d/%d directories, "

           "named by %d/%d, validated by %d/%d, and %d/%d recent directories "

           "think it's running.",

           rs_out->nickname,

           rs_out->status.nickname,

           n_listing, n_statuses, n_named, n_naming, n_valid, n_statuses,

           n_running, n_recent);

    rs_out->is_named = the_name && strcmp(the_name, "**mismatch**") &&

    rs_out->status.is_named = the_name && strcmp(the_name, "**mismatch**") &&

      n_named > n_naming/2;

    if (rs_out->is_named)

      strlcpy(rs_out->nickname, the_name, sizeof(rs_out->nickname));

    rs_out->is_valid = n_valid > n_statuses/2;

    rs_out->is_running = n_running > n_recent/2;

    if (rs_out->status.is_named)

      strlcpy(rs_out->status.nickname, the_name, sizeof(rs_out->status.nickname));

    rs_out->status.is_valid = n_valid > n_statuses/2;

    rs_out->status.is_running = n_running > n_recent/2;

  }

  SMARTLIST_FOREACH(routerstatus_list, routerstatus_t *, rs,

                    routerstatus_free(rs));

  smartlist_free(routerstatus_list);

  routerstatus_list = result;



  tor_free(networkstatus);

  tor_free(index);

  tor_free(size);



  networkstatus_list_has_changed = 0;

  routerstatus_list_has_changed = 1;

}
@@ -2240,7 +2274,7 @@ void 
routers_update_status_from_networkstatus(smartlist_t *routers, int reset_failures)

{

  trusted_dir_server_t *ds;

  routerstatus_t *rs;

  local_routerstatus_t *rs;

  or_options_t *options = get_options();

  int authdir = options->AuthoritativeDir;

  int namingdir =  options->NamingAuthoritativeDir;
@@ -2260,12 +2294,12 @@ routers_update_status_from_networkstatus(smartlist_t *routers, int reset_failure 
      rs->n_download_failures = 0;



    if (!namingdir)

      router->is_named = rs->is_named;

      router->is_named = rs->status.is_named;



    if (!authdir) {

      /* If we're an authdir, don't believe others. */

      router->is_verified = rs->is_valid;

      router->is_running = rs->is_running;

      router->is_verified = rs->status.is_valid;

      router->is_running = rs->status.is_running;



      if (router->is_running && ds) {

        /* XXXX011 NM Hm. What about authorities? When do they reset
@@ -2286,7 +2320,6 @@ router_list_downloadable(void) 
{

  smartlist_t *superseded = smartlist_create();

  strmap_iter_t *iter;

  routerstatus_t *rs;

  time_t now = time(NULL);

  strmap_t *status_map = NULL;

  char fp[HEX_DIGEST_LEN+1];
@@ -2297,15 +2330,16 @@ router_list_downloadable(void) 
  routerstatus_list_update_from_networkstatus(now);



  status_map = strmap_new();

  SMARTLIST_FOREACH(routerstatus_list, routerstatus_t *, rs,

  SMARTLIST_FOREACH(routerstatus_list, local_routerstatus_t *, rs,

  {

    base16_encode(fp, sizeof(fp), rs->identity_digest, DIGEST_LEN);

    base16_encode(fp, sizeof(fp), rs->status.identity_digest, DIGEST_LEN);

    strmap_set(status_map, fp, rs);

  });



  if (routerlist) {

    SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, ri,

    {

      routerstatus_t *rs;

      base16_encode(fp, sizeof(fp), ri->identity_digest, DIGEST_LEN);

      if (!(rs = strmap_get(status_map, fp))) {

        // log_fn(LOG_NOTICE, "No status for %s", fp);
@@ -2341,6 +2375,7 @@ router_list_downloadable(void) 
       iter = strmap_iter_next(status_map, iter)) {

    const char *key;

    void *val;

    local_routerstatus_t *rs;

    strmap_iter_get(iter, &key, &val);

    rs = val;

    if (rs->n_download_failures >= MAX_ROUTERDESC_DOWNLOAD_FAILURES)