Stop searching routerlist for routers with the same identity as other routers...

Changes in version 0.1.2.2-alpha - 2006-??-??

  o Minor Bugfixes

    - Small performance improvements on parsing and inserting

      descriptors.

    - Small performance improvements on parsing descriptors.

    - Major performance descriptor on inserting descriptors; change

      algorithm from O(n^2) to O(n). [Mostly.]

    - Make the common memory allocation path faster on machines where

      malloc(0) returns a pointer.

  /** How many times has a descriptor been posted and we believed

   * this router to be unreachable? We only actually warn on the third. */

  int num_unreachable_notifications;

  /** What position is this descriptor within routerlist->routers? -1 for

   * none. */

  int routerlist_index;

} routerinfo_t;

/** Contents of a single router entry in a network status object.

  }

  ri = tor_malloc_zero(sizeof(routerinfo_t));

  ri->routerlist_index = -1;

  ri->address = tor_dup_addr(addr);

  ri->nickname = tor_strdup(options->Nickname);

  ri->addr = addr;

  digestmap_set(rl->desc_digest_map, ri->cache_info.signed_descriptor_digest,

                &(ri->cache_info));

  smartlist_add(rl->routers, ri);

  ri->routerlist_index = smartlist_len(rl->routers) - 1;

  router_dir_info_changed();

  // routerlist_assert_ok(rl);

}

    signed_descriptor_t *sd = signed_descriptor_from_routerinfo(ri);

    digestmap_set(rl->desc_digest_map, sd->signed_descriptor_digest, sd);

    smartlist_add(rl->old_routers, sd);

    ri->routerlist_index = -1;

  } else {

    routerinfo_free(ri);

  }

  idx = _routerlist_find_elt(rl->routers, ri, idx);

  if (idx < 0)

    return;

  ri->routerlist_index = -1;

  smartlist_del(rl->routers, idx);

  if (idx < smartlist_len(rl->routers)) {

    routerinfo_t *r = smartlist_get(rl->routers, idx);

    r->routerlist_index = idx;

  }

  ri_tmp = digestmap_remove(rl->identity_map, ri->cache_info.identity_digest);

  router_dir_info_changed();

  tor_assert(ri_tmp == ri);

  router_dir_info_changed();

  if (idx >= 0) {

    smartlist_set(rl->routers, idx, ri_new);

    ri_old->routerlist_index = -1;

    ri_new->routerlist_index = idx;

  } else {

    log_warn(LD_BUG, "Appending entry from routerlist_replace.");

    routerlist_insert(rl, ri_new);

router_add_to_routerlist(routerinfo_t *router, const char **msg,

                         int from_cache, int from_fetch)

{

  int i;

  const char *id_digest;

  int authdir = get_options()->AuthoritativeDir;

  int authdir_believes_valid = 0;

  routerinfo_t *old_router;

  tor_assert(msg);

      rs->need_to_mirror = 0;

  });

  /* If we have a router with this name, and the identity key is the same,

   * choose the newer one. If the identity key has changed, and one of the

   * routers is named, drop the unnamed ones. (If more than one are named,

   * drop the old ones.)

   */

  for (i = 0; i < smartlist_len(routerlist->routers); ++i) {

    routerinfo_t *old_router = smartlist_get(routerlist->routers, i);

    /* XXXX This might be a slow point; can't we just look up in one of the

     * digestmaps? -NM */

    if (!memcmp(router->cache_info.identity_digest,

                old_router->cache_info.identity_digest, DIGEST_LEN)) {

  /* If we have a router with the same identity key, choose the newer one. */

  old_router = digestmap_get(routerlist->identity_map,

                             router->cache_info.identity_digest);

  if (old_router) {

    int pos = old_router->routerlist_index;

    tor_assert(smartlist_get(routerlist->routers, pos) == old_router);

    if (router->cache_info.published_on <=

        old_router->cache_info.published_on) {

      /* Same key, but old */

          router->num_unreachable_notifications++;

        }

      }

        routerlist_replace(routerlist, old_router, router, i, 1);

      routerlist_replace(routerlist, old_router, router, pos, 1);

      if (!from_cache) {

        router_append_to_journal(&router->cache_info);

      }

         "server as unapproved.)");

      return unreachable ? 1 : 0;

    }

  }

#if 1

  /* XXXX This block is slow, and could be smarter.  All it does is ensure

   * that if we have a named server called "Foo", we will never have another

   * server called "Foo."  router_get_by_nickname() already knows to prefer

   * named routers, so the problem only arises when there is a named router

   * called 'foo', but we don't have it.  If, instead, we kept a

   * name-to-identity-key mapping for each named router in the networkstatus

   * list, we could eliminate this block.

   *

   * Hm. perhaps we should; I don't see how this code is non-broken wrt named

   * routers. -NM

   */

  /* If the identity key has changed, and one of the

   * routers is named, drop the unnamed ones. (If more than one are named,

   * drop the old ones.)

   */

  for (i = 0; i < smartlist_len(routerlist->routers); ++i) {

    routerinfo_t *old_router = smartlist_get(routerlist->routers, i);

    if (!memcmp(router->cache_info.identity_digest,

                old_router->cache_info.identity_digest, DIGEST_LEN)) {

    } else if (!strcasecmp(router->nickname, old_router->nickname)) {

      /* nicknames match, keys don't. */

      if (router->is_named) {

      }

    }

  }

#endif

  /* We haven't seen a router with this name before.  Add it to the end of

   * the list. */

  routerlist_insert(routerlist, router);

    sd2 = digestmap_get(rl->desc_digest_map,

                        r->cache_info.signed_descriptor_digest);

    tor_assert(&(r->cache_info) == sd2);

    tor_assert(r->routerlist_index == r_sl_idx);

  });

  SMARTLIST_FOREACH(rl->old_routers, signed_descriptor_t *, sd,

  {

  }

  router = tor_malloc_zero(sizeof(routerinfo_t));

  router->routerlist_index = -1;

  if (cache_copy)

    router->cache_info.signed_descriptor_body = tor_strndup(s, end-s);

  router->cache_info.signed_descriptor_len = end-s;