diff options
Diffstat (limited to 'src/or/entrynodes.c')
| -rw-r--r-- | src/or/entrynodes.c | 2149 |
1 files changed, 188 insertions, 1961 deletions
diff --git a/src/or/entrynodes.c b/src/or/entrynodes.c index e26f32d56e..b7c05f1930 100644 --- a/src/or/entrynodes.c +++ b/src/or/entrynodes.c @@ -11,11 +11,6 @@ * Entry nodes can be guards (for general use) or bridges (for censorship * circumvention). * - * XXXX prop271 This module is in flux, since I'm currently in the middle of - * implementation proposal 271. The module documentation here will describe - * the new algorithm and data structures; the old ones should get removed as - * proposal 271 is completed. - * * In general, we use entry guards to prevent traffic-sampling attacks: * if we chose every circuit independently, an adversary controlling * some fraction of paths on the network would observe a sample of every @@ -151,13 +146,6 @@ static guard_selection_t *curr_guard_context = NULL; * and those changes need to be flushed to disk. */ static int entry_guards_dirty = 0; -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM -static const node_t *choose_random_entry_impl(guard_selection_t *gs, - cpath_build_state_t *state, - int for_directory, - dirinfo_type_t dirtype, - int *n_options_out); -#endif static void entry_guard_set_filtered_flags(const or_options_t *options, guard_selection_t *gs, entry_guard_t *guard); @@ -197,6 +185,16 @@ should_apply_guardfraction(const networkstatus_t *ns) return options->UseGuardFraction; } +/** Return true iff we know a descriptor for <b>guard</b> */ +static int +guard_has_descriptor(const entry_guard_t *guard) +{ + const node_t *node = node_get_by_id(guard->identity); + if (!node) + return 0; + return node_has_descriptor(node); +} + /** * Try to determine the correct type for a selection named "name", * if <b>type</b> is GS_TYPE_INFER. @@ -206,9 +204,7 @@ guard_selection_infer_type(guard_selection_type_t type, const char *name) { if (type == GS_TYPE_INFER) { - if (!strcmp(name, "legacy")) - type = GS_TYPE_LEGACY; - else if (!strcmp(name, "bridges")) + if (!strcmp(name, "bridges")) type = GS_TYPE_BRIDGE; else if (!strcmp(name, "restricted")) type = GS_TYPE_RESTRICTED; @@ -232,9 +228,6 @@ guard_selection_new(const char *name, gs = tor_malloc_zero(sizeof(*gs)); gs->name = tor_strdup(name); gs->type = type; -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - gs->chosen_entry_guards = smartlist_new(); -#endif gs->sampled_entry_guards = smartlist_new(); gs->confirmed_entry_guards = smartlist_new(); gs->primary_entry_guards = smartlist_new(); @@ -304,35 +297,6 @@ get_guard_selection_info(void) return curr_guard_context; } -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM -/** Return the list of entry guards for a guard_selection_t, creating it - * if necessary. */ -const smartlist_t * -get_entry_guards_for_guard_selection(guard_selection_t *gs) -{ - tor_assert(gs != NULL); - tor_assert(gs->chosen_entry_guards != NULL); - - return gs->chosen_entry_guards; -} - -/** Return the list of entry guards for the default guard_selection_t, - * creating it if necessary. */ -const smartlist_t * -get_entry_guards(void) -{ - return get_entry_guards_for_guard_selection(get_guard_selection_info()); -} - -/** Helper: mark an entry guard as not usable. */ -void -entry_guard_mark_bad(entry_guard_t *guard) -{ - guard->bad_since = approx_time(); - entry_guards_changed(); -} -#endif - /** Return a statically allocated human-readable description of <b>guard</b> */ const char * @@ -413,9 +377,6 @@ get_max_sample_size_absolute(void) } /** * We always try to make our sample contain at least this many guards. - * - * XXXX prop271 spec deviation There was a MIN_SAMPLE_THRESHOLD in the - * proposal, but I removed it in favor of MIN_FILTERED_SAMPLE_SIZE. -NM */ STATIC int get_min_filtered_sample_size(void) @@ -631,10 +592,6 @@ choose_guard_selection(const or_options_t *options, { tor_assert(options); tor_assert(type_out); - if (options->UseDeprecatedGuardAlgorithm) { - *type_out = GS_TYPE_LEGACY; - return "legacy"; - } if (options->UseBridges) { *type_out = GS_TYPE_BRIDGE; @@ -658,8 +615,8 @@ choose_guard_selection(const or_options_t *options, } } SMARTLIST_FOREACH_END(node); - /* XXXX prop271 spec deviation -- separate 'high' and 'low' thresholds - * to prevent flapping */ + /* We use separate 'high' and 'low' thresholds here to prevent flapping + * back and forth */ const int meaningful_threshold_high = (int)(n_guards * get_meaningful_restriction_threshold() * 1.05); const int meaningful_threshold_mid = @@ -778,7 +735,6 @@ node_is_possible_guard(const node_t *node) /* The "GUARDS" set is all nodes in the nodelist for which this predicate * holds. */ - /* XXXX -- prop271 spec deviation. We require node_is_dir() here. */ tor_assert(node); return (node->is_possible_guard && node->is_stable && @@ -1032,14 +988,14 @@ get_max_sample_size(guard_selection_t *gs, const int using_bridges = (gs->type == GS_TYPE_BRIDGE); const int min_sample = get_min_filtered_sample_size(); - /* XXXX prop271 spec deviation with bridges, max_sample is "all of them" */ + /* With bridges, max_sample is "all of them" */ if (using_bridges) return n_guards; const int max_sample_by_pct = (int)(n_guards * get_max_sample_threshold()); const int max_sample_absolute = get_max_sample_size_absolute(); const int max_sample = MIN(max_sample_by_pct, max_sample_absolute); - if (max_sample < min_sample) // XXXX prop271 spec deviation + if (max_sample < min_sample) return min_sample; else return max_sample; @@ -1212,18 +1168,7 @@ remove_guard_from_confirmed_and_primary_lists(guard_selection_t *gs, } if (guard->confirmed_idx >= 0) { - entry_guard_t *found_guard = NULL; - if (guard->confirmed_idx < smartlist_len(gs->confirmed_entry_guards)) - found_guard = smartlist_get(gs->confirmed_entry_guards, - guard->confirmed_idx); - if (BUG(guard != found_guard)) { - // LCOV_EXCL_START - smartlist_remove_keeporder(gs->confirmed_entry_guards, guard); - // LCOV_EXCL_STOP - } else { - smartlist_del_keeporder(gs->confirmed_entry_guards, - guard->confirmed_idx); - } + smartlist_remove_keeporder(gs->confirmed_entry_guards, guard); guard->confirmed_idx = -1; guard->confirmed_on_date = 0; } else { @@ -1257,7 +1202,6 @@ entry_guard_is_listed,(guard_selection_t *gs, const entry_guard_t *guard)) STATIC void sampled_guards_update_from_consensus(guard_selection_t *gs) { - /*XXXX prop271 consider splitting this function up. */ tor_assert(gs); const int REMOVE_UNLISTED_GUARDS_AFTER = (get_remove_unlisted_guards_after_days() * 86400); @@ -1398,7 +1342,6 @@ node_passes_guard_filter(const or_options_t *options, if (routerset_contains_node(options->ExcludeNodes, node)) return 0; - /* XXXX -- prop271 spec deviation -- add entrynodes to spec. */ if (options->EntryNodes && !routerset_contains_node(options->EntryNodes, node)) return 0; @@ -1549,6 +1492,7 @@ sample_reachable_filtered_entry_guards(guard_selection_t *gs, const unsigned exclude_primary = flags & SAMPLE_EXCLUDE_PRIMARY; const unsigned exclude_pending = flags & SAMPLE_EXCLUDE_PENDING; const unsigned no_update_primary = flags & SAMPLE_NO_UPDATE_PRIMARY; + const unsigned need_descriptor = flags & SAMPLE_EXCLUDE_NO_DESCRIPTOR; SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, guard) { entry_guard_consider_retry(guard); @@ -1582,6 +1526,8 @@ sample_reachable_filtered_entry_guards(guard_selection_t *gs, continue; if (exclude_pending && guard->is_pending) continue; + if (need_descriptor && !guard_has_descriptor(guard)) + continue; smartlist_add(reachable_filtered_sample, guard); } SMARTLIST_FOREACH_END(guard); @@ -1682,7 +1628,6 @@ make_guard_confirmed(guard_selection_t *gs, entry_guard_t *guard) STATIC void entry_guards_update_primary(guard_selection_t *gs) { - /*XXXX prop271 consider splitting this function up. */ tor_assert(gs); // prevent recursion. Recursion is potentially very bad here. @@ -1880,7 +1825,7 @@ select_entry_guard_for_circuit(guard_selection_t *gs, const entry_guard_restriction_t *rst, unsigned *state_out) { - /*XXXX prop271 consider splitting this function up. */ + const int need_descriptor = (usage == GUARD_USAGE_TRAFFIC); tor_assert(gs); tor_assert(state_out); @@ -1897,6 +1842,9 @@ select_entry_guard_for_circuit(guard_selection_t *gs, if (! entry_guard_obeys_restriction(guard, rst)) continue; if (guard->is_reachable != GUARD_REACHABLE_NO) { + if (need_descriptor && BUG(!guard_has_descriptor(guard))) { + continue; + } *state_out = GUARD_CIRC_STATE_USABLE_ON_COMPLETION; guard->last_tried_to_connect = approx_time(); smartlist_add(usable_primary_guards, guard); @@ -1925,6 +1873,8 @@ select_entry_guard_for_circuit(guard_selection_t *gs, continue; entry_guard_consider_retry(guard); if (guard->is_usable_filtered_guard && ! guard->is_pending) { + if (need_descriptor && !guard_has_descriptor(guard)) + continue; /* not a bug */ guard->is_pending = 1; guard->last_tried_to_connect = approx_time(); *state_out = GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD; @@ -1940,11 +1890,15 @@ select_entry_guard_for_circuit(guard_selection_t *gs, random from {USABLE_FILTERED_GUARDS}." */ { entry_guard_t *guard; + unsigned flags = 0; + if (need_descriptor) + flags |= SAMPLE_EXCLUDE_NO_DESCRIPTOR; guard = sample_reachable_filtered_entry_guards(gs, rst, SAMPLE_EXCLUDE_CONFIRMED | SAMPLE_EXCLUDE_PRIMARY | - SAMPLE_EXCLUDE_PENDING); + SAMPLE_EXCLUDE_PENDING | + flags); if (guard == NULL) { log_info(LD_GUARD, "Absolutely no sampled guards were available. " "Marking all guards for retry and starting from top again."); @@ -2150,6 +2104,8 @@ entry_guard_pick_for_circuit(guard_selection_t *gs, // XXXX prop271 check Ed ID. if (! node) goto fail; + if (BUG(usage != GUARD_USAGE_DIRGUARD && !node_has_descriptor(node))) + goto fail; *chosen_node_out = node; *guard_state_out = tor_malloc_zero(sizeof(circuit_guard_state_t)); @@ -2176,9 +2132,6 @@ entry_guard_pick_for_circuit(guard_selection_t *gs, guard_usable_t entry_guard_succeeded(circuit_guard_state_t **guard_state_p) { - if (get_options()->UseDeprecatedGuardAlgorithm) - return GUARD_USABLE_NOW; - if (BUG(*guard_state_p == NULL)) return GUARD_USABLE_NEVER; @@ -2206,8 +2159,6 @@ entry_guard_succeeded(circuit_guard_state_t **guard_state_p) void entry_guard_cancel(circuit_guard_state_t **guard_state_p) { - if (get_options()->UseDeprecatedGuardAlgorithm) - return; if (BUG(*guard_state_p == NULL)) return; entry_guard_t *guard = entry_guard_handle_get((*guard_state_p)->guard); @@ -2229,9 +2180,6 @@ entry_guard_cancel(circuit_guard_state_t **guard_state_p) void entry_guard_failed(circuit_guard_state_t **guard_state_p) { - if (get_options()->UseDeprecatedGuardAlgorithm) - return; - if (BUG(*guard_state_p == NULL)) return; @@ -2254,8 +2202,6 @@ entry_guard_chan_failed(channel_t *chan) { if (!chan) return; - if (get_options()->UseDeprecatedGuardAlgorithm) - return; smartlist_t *pending = smartlist_new(); circuit_get_all_pending_on_channel(pending, chan); @@ -2264,7 +2210,11 @@ entry_guard_chan_failed(channel_t *chan) continue; origin_circuit_t *origin_circ = TO_ORIGIN_CIRCUIT(circ); - entry_guard_failed(&origin_circ->guard_state); + if (origin_circ->guard_state) { + /* We might have no guard state if we didn't use a guard on this + * circuit (eg it's for a fallback directory). */ + entry_guard_failed(&origin_circ->guard_state); + } } SMARTLIST_FOREACH_END(circ); smartlist_free(pending); } @@ -2394,6 +2344,13 @@ entry_guards_upgrade_waiting_circuits(guard_selection_t *gs, /* First look at the complete circuits: Do any block this circuit? */ SMARTLIST_FOREACH_BEGIN(all_circuits, origin_circuit_t *, circ) { + /* "C2 "blocks" C1 if: + * C2 obeys all the restrictions that C1 had to obey, AND + * C2 has higher priority than C1, AND + * Either C2 is <complete>, or C2 is <waiting_for_better_guard>, + or C2 has been <usable_if_no_better_guard> for no more than + {NONPRIMARY_GUARD_CONNECT_TIMEOUT} seconds." + */ circuit_guard_state_t *state = origin_circuit_get_guard_state(circ); if BUG((state == NULL)) continue; @@ -2406,9 +2363,6 @@ entry_guards_upgrade_waiting_circuits(guard_selection_t *gs, } SMARTLIST_FOREACH_END(circ); if (n_complete_blocking) { - /* "If any circuit is <complete>, then do not use any - <waiting_for_better_guard> or <usable_if_no_better_guard> circuits - circuits whose guards have lower priority." */ log_debug(LD_GUARD, "Considered upgrading guard-stalled circuits: found " "%d complete and %d guard-stalled. At least one complete " "circuit had higher priority, so not upgrading.", @@ -2416,14 +2370,10 @@ entry_guards_upgrade_waiting_circuits(guard_selection_t *gs, goto no_change; } - /* "If any circuit is <waiting_for_better_guard>, and every currently - {is_pending} circuit whose guard has higher priority has been in - state <usable_if_no_better_guard> for at least - {NONPRIMARY_GUARD_CONNECT_TIMEOUT} seconds, and all primary guards - have reachable status of <no>, then call that circuit <complete>." - - XXXX --- prop271 deviation. there's no such thing in the spec as - an {is_pending circuit}; fix the spec. + /* " * If any circuit C1 is <waiting_for_better_guard>, AND: + * All primary guards have reachable status of <no>. + * There is no circuit C2 that "blocks" C1. + Then, upgrade C1 to <complete>."" */ int n_blockers_found = 0; const time_t state_set_at_cutoff = @@ -2771,7 +2721,6 @@ entry_guard_parse_from_state(const char *s) /* Take sampled_by_version verbatim. */ guard->sampled_by_version = sampled_by; sampled_by = NULL; /* prevent free */ - // XXXX -- prop271 spec deviation -- we do not require sampled_by_version /* Listed is a boolean */ if (listed && strcmp(listed, "0")) @@ -2861,8 +2810,8 @@ entry_guard_parse_from_state(const char *s) } /** - * Replace the Guards entries in <b>state</b> with a list of all our - * non-legacy sampled guards. + * Replace the Guards entries in <b>state</b> with a list of all our sampled + * guards. */ static void entry_guards_update_guards_in_state(or_state_t *state) @@ -2873,8 +2822,6 @@ entry_guards_update_guards_in_state(or_state_t *state) config_line_t **nextline = &lines; SMARTLIST_FOREACH_BEGIN(guard_contexts, guard_selection_t *, gs) { - if (!strcmp(gs->name, "legacy")) - continue; /* This is encoded differently. */ SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, guard) { if (guard->is_persistent == 0) continue; @@ -2890,9 +2837,9 @@ entry_guards_update_guards_in_state(or_state_t *state) } /** - * Replace our non-legacy sampled guards from the Guards entries in - * <b>state</b>. Return 0 on success, -1 on failure. (If <b>set</b> is - * true, replace nothing -- only check whether replacing would work.) + * Replace our sampled guards from the Guards entries in <b>state</b>. Return 0 + * on success, -1 on failure. (If <b>set</b> is true, replace nothing -- only + * check whether replacing would work.) */ static int entry_guards_load_guards_from_state(or_state_t *state, int set) @@ -2907,8 +2854,6 @@ entry_guards_load_guards_from_state(or_state_t *state, int set) * let's be safe.) */ if (set) { SMARTLIST_FOREACH_BEGIN(guard_contexts, guard_selection_t *, gs) { - if (!strcmp(gs->name, "legacy")) - continue; guard_selection_free(gs); if (curr_guard_context == gs) curr_guard_context = NULL; @@ -2943,299 +2888,12 @@ entry_guards_load_guards_from_state(or_state_t *state, int set) if (set) { SMARTLIST_FOREACH_BEGIN(guard_contexts, guard_selection_t *, gs) { - if (!strcmp(gs->name, "legacy")) - continue; entry_guards_update_all(gs); } SMARTLIST_FOREACH_END(gs); } return n_errors ? -1 : 0; } -/* XXXXX ----------------------------------------------- */ -/* XXXXX prop271 ----- end of new-for-prop271 code ----- */ -/* XXXXX ----------------------------------------------- */ - -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM -/** - * @name Constants for old (pre-prop271) guard selection algorithm. - */ - -/**@{*/ - -/* Default number of entry guards in the case where the NumEntryGuards - * consensus parameter is not set */ -#define DEFAULT_N_GUARDS 1 -/* Minimum and maximum number of entry guards (in case the NumEntryGuards - * consensus parameter is set). */ -#define MIN_N_GUARDS 1 -#define MAX_N_GUARDS 10 -/** Largest amount that we'll backdate chosen_on_date */ -#define CHOSEN_ON_DATE_SLOP (30*86400) -/** How long (in seconds) do we allow an entry guard to be nonfunctional, - * unlisted, excluded, or otherwise nonusable before we give up on it? */ -#define ENTRY_GUARD_REMOVE_AFTER (30*24*60*60) -/**}@*/ - -/** - * @name Networkstatus parameters for old (pre-prop271) guard selection - */ -/**@}*/ -/** Choose how many entry guards or directory guards we'll use. If - * <b>for_directory</b> is true, we return how many directory guards to - * use; else we return how many entry guards to use. */ -STATIC int -decide_num_guards(const or_options_t *options, int for_directory) -{ - if (for_directory) { - int answer; - if (options->NumDirectoryGuards != 0) - return options->NumDirectoryGuards; - answer = networkstatus_get_param(NULL, "NumDirectoryGuards", 0, 0, 10); - if (answer) /* non-zero means use the consensus value */ - return answer; - } - - if (options->NumEntryGuards) - return options->NumEntryGuards; - - /* Use the value from the consensus, or 3 if no guidance. */ - return networkstatus_get_param(NULL, "NumEntryGuards", DEFAULT_N_GUARDS, - MIN_N_GUARDS, MAX_N_GUARDS); -} - -/** Check whether the entry guard <b>e</b> is usable, given the directory - * authorities' opinion about the router (stored in <b>ri</b>) and the user's - * configuration (in <b>options</b>). Set <b>e</b>->bad_since - * accordingly. Return true iff the entry guard's status changes. - * - * If it's not usable, set *<b>reason</b> to a static string explaining why. - */ -static int -entry_guard_set_status(entry_guard_t *e, const node_t *node, - time_t now, const or_options_t *options, - const char **reason) -{ - char buf[HEX_DIGEST_LEN+1]; - int changed = 0; - - *reason = NULL; - - /* Do we want to mark this guard as bad? */ - if (!node) - *reason = "unlisted"; - else if (!node->is_running) - *reason = "down"; - else if (options->UseBridges && (!node->ri || - node->ri->purpose != ROUTER_PURPOSE_BRIDGE)) - *reason = "not a bridge"; - else if (options->UseBridges && !node_is_a_configured_bridge(node)) - *reason = "not a configured bridge"; - else if (!options->UseBridges && !node->is_possible_guard && - !routerset_contains_node(options->EntryNodes,node)) - *reason = "not recommended as a guard"; - else if (routerset_contains_node(options->ExcludeNodes, node)) - *reason = "excluded"; - /* We only care about OR connection connectivity for entry guards. */ - else if (!fascist_firewall_allows_node(node, FIREWALL_OR_CONNECTION, 0)) - *reason = "unreachable by config"; - else if (e->pb.path_bias_disabled) - *reason = "path-biased"; - - if (*reason && ! e->bad_since) { - /* Router is newly bad. */ - base16_encode(buf, sizeof(buf), e->identity, DIGEST_LEN); - log_info(LD_CIRC, "Entry guard %s (%s) is %s: marking as unusable.", - e->nickname, buf, *reason); - - e->bad_since = now; - control_event_guard(e->nickname, e->identity, "BAD"); - changed = 1; - } else if (!*reason && e->bad_since) { - /* There's nothing wrong with the router any more. */ - base16_encode(buf, sizeof(buf), e->identity, DIGEST_LEN); - log_info(LD_CIRC, "Entry guard %s (%s) is no longer unusable: " - "marking as ok.", e->nickname, buf); - - e->bad_since = 0; - control_event_guard(e->nickname, e->identity, "GOOD"); - changed = 1; - } - - if (node) { - int is_dir = node_is_dir(node); - if (options->UseBridges && node_is_a_configured_bridge(node)) - is_dir = 1; - if (e->is_dir_cache != is_dir) { - e->is_dir_cache = is_dir; - changed = 1; - } - } - - return changed; -} - -/** Return true iff enough time has passed since we last tried to connect - * to the unreachable guard <b>e</b> that we're willing to try again. */ -STATIC int -entry_is_time_to_retry(const entry_guard_t *e, time_t now) -{ - struct guard_retry_period_s { - time_t period_duration; - time_t interval_during_period; - }; - - struct guard_retry_period_s periods[] = { - { 6*60*60, 60*60 }, /* For first 6 hrs., retry hourly; */ - { 3*24*60*60, 4*60*60 }, /* Then retry every 4 hrs. until the - 3-day mark; */ - { 7*24*60*60, 18*60*60 }, /* After 3 days, retry every 18 hours until - 1 week mark. */ - { TIME_MAX, 36*60*60 } /* After 1 week, retry every 36 hours. */ - }; - - time_t ith_deadline_for_retry; - time_t unreachable_for; - unsigned i; - - if (e->last_attempted < e->unreachable_since) - return 1; - - unreachable_for = now - e->unreachable_since; - - for (i = 0; i < ARRAY_LENGTH(periods); i++) { - if (unreachable_for <= periods[i].period_duration) { - ith_deadline_for_retry = e->last_attempted + - periods[i].interval_during_period; - - return (now > ith_deadline_for_retry); - } - } - return 0; -} - -/** Return the node corresponding to <b>e</b>, if <b>e</b> is - * working well enough that we are willing to use it as an entry - * right now. (Else return NULL.) In particular, it must be - * - Listed as either up or never yet contacted; - * - Present in the routerlist; - * - Listed as 'stable' or 'fast' by the current dirserver consensus, - * if demanded by <b>need_uptime</b> or <b>need_capacity</b> - * (unless it's a configured EntryNode); - * - Allowed by our current ReachableORAddresses config option; and - * - Currently thought to be reachable by us (unless <b>assume_reachable</b> - * is true). - * - * If the answer is no, set *<b>msg</b> to an explanation of why. - * - * If need_descriptor is true, only return the node if we currently have - * a descriptor (routerinfo or microdesc) for it. - */ -STATIC const node_t * -entry_is_live(const entry_guard_t *e, entry_is_live_flags_t flags, - const char **msg) -{ - const node_t *node; - const or_options_t *options = get_options(); - int need_uptime = (flags & ENTRY_NEED_UPTIME) != 0; - int need_capacity = (flags & ENTRY_NEED_CAPACITY) != 0; - const int assume_reachable = (flags & ENTRY_ASSUME_REACHABLE) != 0; - const int need_descriptor = (flags & ENTRY_NEED_DESCRIPTOR) != 0; - - tor_assert(msg); - - if (e->pb.path_bias_disabled) { - *msg = "path-biased"; - return NULL; - } - if (e->bad_since) { - *msg = "bad"; - return NULL; - } - /* no good if it's unreachable, unless assume_unreachable or can_retry. */ - if (!assume_reachable && !e->can_retry && - e->unreachable_since && !entry_is_time_to_retry(e, time(NULL))) { - *msg = "unreachable"; - return NULL; - } - node = node_get_by_id(e->identity); - if (!node) { - *msg = "no node info"; - return NULL; - } - if (need_descriptor && !node_has_descriptor(node)) { - *msg = "no descriptor"; - return NULL; - } - if (get_options()->UseBridges) { - if (node_get_purpose(node) != ROUTER_PURPOSE_BRIDGE) { - *msg = "not a bridge"; - return NULL; - } - if (!node_is_a_configured_bridge(node)) { - *msg = "not a configured bridge"; - return NULL; - } - } else { /* !get_options()->UseBridges */ - if (node_get_purpose(node) != ROUTER_PURPOSE_GENERAL) { - *msg = "not general-purpose"; - return NULL; - } - } - if (routerset_contains_node(options->EntryNodes, node)) { - /* they asked for it, they get it */ - need_uptime = need_capacity = 0; - } - if (node_is_unreliable(node, need_uptime, need_capacity, 0)) { - *msg = "not fast/stable"; - return NULL; - } - if (!fascist_firewall_allows_node(node, FIREWALL_OR_CONNECTION, 0)) { - *msg = "unreachable by config"; - return NULL; - } - return node; -} - -/** Return the number of entry guards that we think are usable, in the - * context of the given guard_selection_t */ -int -num_live_entry_guards_for_guard_selection(guard_selection_t *gs, - int for_directory) -{ - int n = 0; - const char *msg; - - tor_assert(gs != NULL); - - /* Set the entry node attributes we are interested in. */ - entry_is_live_flags_t entry_flags = ENTRY_NEED_CAPACITY; - if (!for_directory) { - entry_flags |= ENTRY_NEED_DESCRIPTOR; - } - - if (!(gs->chosen_entry_guards)) { - return 0; - } - - SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, entry) { - if (for_directory && !entry->is_dir_cache) - continue; - if (entry_is_live(entry, entry_flags, &msg)) - ++n; - } SMARTLIST_FOREACH_END(entry); - return n; -} - -/** Return the number of entry guards that we think are usable, for the - * default guard selection */ -int -num_live_entry_guards(int for_directory) -{ - return num_live_entry_guards_for_guard_selection( - get_guard_selection_info(), for_directory); -} -#endif - /** If <b>digest</b> matches the identity of any node in the * entry_guards list for the provided guard selection state, return that node. Else return NULL. */ @@ -3249,12 +2907,6 @@ entry_guard_get_by_id_digest_for_guard_selection(guard_selection_t *gs, if (tor_memeq(digest, entry->identity, DIGEST_LEN)) return entry; ); -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - SMARTLIST_FOREACH(gs->chosen_entry_guards, entry_guard_t *, entry, - if (tor_memeq(digest, entry->identity, DIGEST_LEN)) - return entry; - ); -#endif return NULL; } @@ -3277,234 +2929,6 @@ entry_guard_get_by_id_digest(const char *digest) get_guard_selection_info(), digest); } -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM -/** Dump a description of our list of entry guards in the given guard - * selection context to the log at level <b>severity</b>. */ -static void -log_entry_guards_for_guard_selection(guard_selection_t *gs, int severity) -{ - smartlist_t *elements = smartlist_new(); - char *s; - - /* - * TODO this should probably log more info about prop-271 state too - * when it's implemented. - */ - - tor_assert(gs != NULL); - - SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e) - { - const char *msg = NULL; - if (entry_is_live(e, ENTRY_NEED_CAPACITY, &msg)) - smartlist_add_asprintf(elements, "%s [%s] (up %s)", - e->nickname, - hex_str(e->identity, DIGEST_LEN), - e->made_contact ? "made-contact" : "never-contacted"); - else - smartlist_add_asprintf(elements, "%s [%s] (%s, %s)", - e->nickname, - hex_str(e->identity, DIGEST_LEN), - msg, - e->made_contact ? "made-contact" : "never-contacted"); - } - SMARTLIST_FOREACH_END(e); - - s = smartlist_join_strings(elements, ",", 0, NULL); - SMARTLIST_FOREACH(elements, char*, cp, tor_free(cp)); - smartlist_free(elements); - log_fn(severity,LD_CIRC,"%s",s); - tor_free(s); -} - -/** Called when one or more guards that we would previously have used for some - * purpose are no longer in use because a higher-priority guard has become - * usable again. */ -static void -control_event_guard_deferred(void) -{ - /* XXXX We don't actually have a good way to figure out _how many_ entries - * are live for some purpose. We need an entry_is_even_slightly_live() - * function for this to work right. NumEntryGuards isn't reliable: if we - * need guards with weird properties, we can have more than that number - * live. - **/ -#if 0 - int n = 0; - const char *msg; - const or_options_t *options = get_options(); - if (!entry_guards) - return; - SMARTLIST_FOREACH(entry_guards, entry_guard_t *, entry, - { - if (entry_is_live(entry, 0, 1, 0, &msg)) { - if (n++ == options->NumEntryGuards) { - control_event_guard(entry->nickname, entry->identity, "DEFERRED"); - return; - } - } - }); -#endif -} - -/** Add a new (preferably stable and fast) router to our chosen_entry_guards - * list for the supplied guard selection. Return a pointer to the router if - * we succeed, or NULL if we can't find any more suitable entries. - * - * If <b>chosen</b> is defined, use that one, and if it's not - * already in our entry_guards list, put it at the *beginning*. - * Else, put the one we pick at the end of the list. */ -STATIC const node_t * -add_an_entry_guard(guard_selection_t *gs, - const node_t *chosen, int reset_status, int prepend, - int for_discovery, int for_directory) -{ - const node_t *node; - entry_guard_t *entry; - - tor_assert(gs != NULL); - tor_assert(gs->chosen_entry_guards != NULL); - - if (chosen) { - node = chosen; - entry = entry_guard_get_by_id_digest_for_guard_selection(gs, - node->identity); - if (entry) { - if (reset_status) { - entry->bad_since = 0; - entry->can_retry = 1; - } - entry->is_dir_cache = node_is_dir(node); - if (get_options()->UseBridges && node_is_a_configured_bridge(node)) - entry->is_dir_cache = 1; - - return NULL; - } - } else if (!for_directory) { - node = choose_good_entry_server(CIRCUIT_PURPOSE_C_GENERAL, NULL, NULL); - if (!node) - return NULL; - } else { - const routerstatus_t *rs; - rs = router_pick_directory_server(MICRODESC_DIRINFO|V3_DIRINFO, - PDS_FOR_GUARD); - if (!rs) - return NULL; - node = node_get_by_id(rs->identity_digest); - if (!node) - return NULL; - } - if (entry_guard_get_by_id_digest_for_guard_selection(gs, node->identity) - != NULL) { - log_info(LD_CIRC, "I was about to add a duplicate entry guard."); - /* This can happen if we choose a guard, then the node goes away, then - * comes back. */ - return NULL; - } - entry = tor_malloc_zero(sizeof(entry_guard_t)); - entry->is_persistent = 1; - log_info(LD_CIRC, "Chose %s as new entry guard.", - node_describe(node)); - strlcpy(entry->nickname, node_get_nickname(node), sizeof(entry->nickname)); - memcpy(entry->identity, node->identity, DIGEST_LEN); - entry->is_dir_cache = node_is_dir(node); - if (get_options()->UseBridges && node_is_a_configured_bridge(node)) - entry->is_dir_cache = 1; - - /* Choose expiry time smudged over the past month. The goal here - * is to a) spread out when Tor clients rotate their guards, so they - * don't all select them on the same day, and b) avoid leaving a - * precise timestamp in the state file about when we first picked - * this guard. For details, see the Jan 2010 or-dev thread. */ - time_t now = time(NULL); - entry->chosen_on_date = crypto_rand_time_range(now - 3600*24*30, now); - entry->chosen_by_version = tor_strdup(VERSION); - - /* Are we picking this guard because all of our current guards are - * down so we need another one (for_discovery is 1), or because we - * decided we need more variety in our guard list (for_discovery is 0)? - * - * Currently we hack this behavior into place by setting "made_contact" - * for guards of the latter variety, so we'll be willing to use any of - * them right off the bat. - */ - if (!for_discovery) - entry->made_contact = 1; - - if (prepend) - smartlist_insert(gs->chosen_entry_guards, 0, entry); - else - smartlist_add(gs->chosen_entry_guards, entry); - entry->in_selection = gs; - - control_event_guard(entry->nickname, entry->identity, "NEW"); - control_event_guard_deferred(); - log_entry_guards_for_guard_selection(gs, LOG_INFO); - - return node; -} - -/** Entry point for bridges.c to add a bridge as guard. - * - * XXXX prop271 refactor, bridge.*/ -void -add_bridge_as_entry_guard(guard_selection_t *gs, - const node_t *chosen) -{ - add_an_entry_guard(gs, chosen, 1, 1, 0, 0); -} - -/** - * Return the minimum lifetime of working entry guard, in seconds, - * as given in the consensus networkstatus. (Plus CHOSEN_ON_DATE_SLOP, - * so that we can do the chosen_on_date randomization while achieving the - * desired minimum lifetime.) - */ -static int32_t -guards_get_lifetime(void) -{ - const or_options_t *options = get_options(); -#define DFLT_GUARD_LIFETIME (86400 * 60) /* Two months. */ -#define MIN_GUARD_LIFETIME (86400 * 30) /* One months. */ -#define MAX_GUARD_LIFETIME (86400 * 1826) /* Five years. */ - - if (options->GuardLifetime >= 1) { - return CLAMP(MIN_GUARD_LIFETIME, - options->GuardLifetime, - MAX_GUARD_LIFETIME) + CHOSEN_ON_DATE_SLOP; - } - - return networkstatus_get_param(NULL, "GuardLifetime", - DFLT_GUARD_LIFETIME, - MIN_GUARD_LIFETIME, - MAX_GUARD_LIFETIME) + CHOSEN_ON_DATE_SLOP; -} - -/** If the use of entry guards is configured, choose more entry guards - * until we have enough in the list. */ -static void -pick_entry_guards(guard_selection_t *gs, - const or_options_t *options, - int for_directory) -{ - int changed = 0; - const int num_needed = decide_num_guards(options, for_directory); - - tor_assert(gs != NULL); - tor_assert(gs->chosen_entry_guards != NULL); - - while (num_live_entry_guards_for_guard_selection(gs, for_directory) - < num_needed) { - if (!add_an_entry_guard(gs, NULL, 0, 0, 0, for_directory)) - break; - changed = 1; - } - - if (changed) - entry_guards_changed_for_guard_selection(gs); -} -#endif - /** Release all storage held by <b>e</b>. */ STATIC void entry_guard_free(entry_guard_t *e) @@ -3512,9 +2936,6 @@ entry_guard_free(entry_guard_t *e) if (!e) return; entry_guard_handles_clear(e); -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - tor_free(e->chosen_by_version); -#endif tor_free(e->sampled_by_version); tor_free(e->extra_state_fields); tor_free(e->selection_name); @@ -3522,487 +2943,6 @@ entry_guard_free(entry_guard_t *e) tor_free(e); } -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM -/** Remove from a guard selection context any entry guard which was selected - * by an unknown version of Tor, or which was selected by a version of Tor - * that's known to select entry guards badly, or which was selected more 2 - * months ago. */ -/* XXXX The "obsolete guards" and "chosen long ago guards" things should - * probably be different functions. */ -static int -remove_obsolete_entry_guards(guard_selection_t *gs, time_t now) -{ - int changed = 0, i; - int32_t guard_lifetime = guards_get_lifetime(); - - tor_assert(gs != NULL); - if (!(gs->chosen_entry_guards)) goto done; - - for (i = 0; i < smartlist_len(gs->chosen_entry_guards); ++i) { - entry_guard_t *entry = smartlist_get(gs->chosen_entry_guards, i); - const char *ver = entry->chosen_by_version; - const char *msg = NULL; - tor_version_t v; - int version_is_bad = 0, date_is_bad = 0; - if (!ver) { - msg = "does not say what version of Tor it was selected by"; - version_is_bad = 1; - } else if (tor_version_parse(ver, &v)) { - msg = "does not seem to be from any recognized version of Tor"; - version_is_bad = 1; - } - if (!version_is_bad && entry->chosen_on_date + guard_lifetime < now) { - /* It's been too long since the date listed in our state file. */ - msg = "was selected several months ago"; - date_is_bad = 1; - } - - if (version_is_bad || date_is_bad) { /* we need to drop it */ - char dbuf[HEX_DIGEST_LEN+1]; - tor_assert(msg); - base16_encode(dbuf, sizeof(dbuf), entry->identity, DIGEST_LEN); - log_fn(version_is_bad ? LOG_NOTICE : LOG_INFO, LD_CIRC, - "Entry guard '%s' (%s) %s. (Version=%s.) Replacing it.", - entry->nickname, dbuf, msg, ver?escaped(ver):"none"); - control_event_guard(entry->nickname, entry->identity, "DROPPED"); - entry_guard_free(entry); - smartlist_del_keeporder(gs->chosen_entry_guards, i--); - log_entry_guards_for_guard_selection(gs, LOG_INFO); - changed = 1; - } - } - - done: - return changed ? 1 : 0; -} - -/** Remove all entry guards from this guard selection context that have - * been down or unlisted for so long that we don't think they'll come up - * again. Return 1 if we removed any, or 0 if we did nothing. */ -static int -remove_dead_entry_guards(guard_selection_t *gs, time_t now) -{ - char dbuf[HEX_DIGEST_LEN+1]; - char tbuf[ISO_TIME_LEN+1]; - int i; - int changed = 0; - - tor_assert(gs != NULL); - if (!(gs->chosen_entry_guards)) goto done; - - for (i = 0; i < smartlist_len(gs->chosen_entry_guards); ) { - entry_guard_t *entry = smartlist_get(gs->chosen_entry_guards, i); - if (entry->bad_since && - ! entry->pb.path_bias_disabled && - entry->bad_since + ENTRY_GUARD_REMOVE_AFTER < now) { - - base16_encode(dbuf, sizeof(dbuf), entry->identity, DIGEST_LEN); - format_local_iso_time(tbuf, entry->bad_since); - log_info(LD_CIRC, "Entry guard '%s' (%s) has been down or unlisted " - "since %s local time; removing.", - entry->nickname, dbuf, tbuf); - control_event_guard(entry->nickname, entry->identity, "DROPPED"); - entry_guard_free(entry); - smartlist_del_keeporder(gs->chosen_entry_guards, i); - log_entry_guards_for_guard_selection(gs, LOG_INFO); - changed = 1; - } else - ++i; - } - - done: - return changed ? 1 : 0; -} - -/** Remove all currently listed entry guards for a given guard selection - * context */ -void -remove_all_entry_guards_for_guard_selection(guard_selection_t *gs) -{ - char dbuf[HEX_DIGEST_LEN+1]; - - tor_assert(gs != NULL); - - if (gs->chosen_entry_guards) { - while (smartlist_len(gs->chosen_entry_guards)) { - entry_guard_t *entry = smartlist_get(gs->chosen_entry_guards, 0); - base16_encode(dbuf, sizeof(dbuf), entry->identity, DIGEST_LEN); - log_info(LD_CIRC, "Entry guard '%s' (%s) has been dropped.", - entry->nickname, dbuf); - control_event_guard(entry->nickname, entry->identity, "DROPPED"); - entry_guard_free(entry); - smartlist_del(gs->chosen_entry_guards, 0); - } - } - - log_entry_guards_for_guard_selection(gs, LOG_INFO); - entry_guards_changed_for_guard_selection(gs); -} - -/** Remove all currently listed entry guards. So new ones will be chosen. */ -void -remove_all_entry_guards(void) -{ - // XXXX prop271 this function shouldn't exist, in the new order. - remove_all_entry_guards_for_guard_selection(get_guard_selection_info()); -} - -/** A new directory or router-status has arrived; update the down/listed - * status of the entry guards. - * - * An entry is 'down' if the directory lists it as nonrunning. - * An entry is 'unlisted' if the directory doesn't include it. - * - * Don't call this on startup; only on a fresh download. Otherwise we'll - * think that things are unlisted. - */ -void -entry_guards_compute_status_for_guard_selection(guard_selection_t *gs, - const or_options_t *options, - time_t now) -{ - int changed = 0; - digestmap_t *reasons; - - if ((!gs) || !(gs->chosen_entry_guards)) - return; - - if (!get_options()->UseDeprecatedGuardAlgorithm) - return; - - if (options->EntryNodes) /* reshuffle the entry guard list if needed */ - entry_nodes_should_be_added(); - - reasons = digestmap_new(); - SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, entry) - { - const node_t *r = node_get_by_id(entry->identity); - const char *reason = NULL; - if (entry_guard_set_status(entry, r, now, options, &reason)) - changed = 1; - - if (entry->bad_since) - tor_assert(reason); - if (reason) - digestmap_set(reasons, entry->identity, (char*)reason); - } - SMARTLIST_FOREACH_END(entry); - - if (remove_dead_entry_guards(gs, now)) - changed = 1; - if (remove_obsolete_entry_guards(gs, now)) - changed = 1; - - if (changed) { - SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, - entry) { - const char *reason = digestmap_get(reasons, entry->identity); - const char *live_msg = ""; - const node_t *r = entry_is_live(entry, ENTRY_NEED_CAPACITY, &live_msg); - log_info(LD_CIRC, "Summary: Entry %s [%s] is %s, %s%s%s, and %s%s.", - entry->nickname, - hex_str(entry->identity, DIGEST_LEN), - entry->unreachable_since ? "unreachable" : "reachable", - entry->bad_since ? "unusable" : "usable", - reason ? ", ": "", - reason ? reason : "", - r ? "live" : "not live / ", - r ? "" : live_msg); - } SMARTLIST_FOREACH_END(entry); - log_info(LD_CIRC, " (%d/%d entry guards are usable/new)", - num_live_entry_guards_for_guard_selection(gs, 0), - smartlist_len(gs->chosen_entry_guards)); - log_entry_guards_for_guard_selection(gs, LOG_INFO); - entry_guards_changed_for_guard_selection(gs); - } - - digestmap_free(reasons, NULL); -} - -/** A new directory or router-status has arrived; update the down/listed - * status of the entry guards. - * - * An entry is 'down' if the directory lists it as nonrunning. - * An entry is 'unlisted' if the directory doesn't include it. - * - * Don't call this on startup; only on a fresh download. Otherwise we'll - * think that things are unlisted. - */ -void -entry_guards_compute_status(const or_options_t *options, time_t now) -{ - entry_guards_compute_status_for_guard_selection(get_guard_selection_info(), - options, now); -} - -/** Called when a connection to an OR with the identity digest <b>digest</b> - * is established (<b>succeeded</b>==1) or has failed (<b>succeeded</b>==0). - * If the OR is an entry, change that entry's up/down status. - * Return 0 normally, or -1 if we want to tear down the new connection. - * - * If <b>mark_relay_status</b>, also call router_set_status() on this - * relay. - */ -/* XXX We could change succeeded and mark_relay_status into 'int flags'. - * Too many boolean arguments is a recipe for confusion. - */ -int -entry_guard_register_connect_status_for_guard_selection( - guard_selection_t *gs, const char *digest, int succeeded, - int mark_relay_status, time_t now) -{ - int changed = 0; - int refuse_conn = 0; - int first_contact = 0; - entry_guard_t *entry = NULL; - int idx = -1; - char buf[HEX_DIGEST_LEN+1]; - - if (!(gs) || !(gs->chosen_entry_guards)) { - return 0; - } - - if (! get_options()->UseDeprecatedGuardAlgorithm) { - return 0; - } - - SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e) { - tor_assert(e); - if (tor_memeq(e->identity, digest, DIGEST_LEN)) { - entry = e; - idx = e_sl_idx; - break; - } - } SMARTLIST_FOREACH_END(e); - - if (!entry) - return 0; - - base16_encode(buf, sizeof(buf), entry->identity, DIGEST_LEN); - - if (succeeded) { - if (entry->unreachable_since) { - log_info(LD_CIRC, "Entry guard '%s' (%s) is now reachable again. Good.", - entry->nickname, buf); - entry->can_retry = 0; - entry->unreachable_since = 0; - entry->last_attempted = now; - control_event_guard(entry->nickname, entry->identity, "UP"); - changed = 1; - } - if (!entry->made_contact) { - entry->made_contact = 1; - first_contact = changed = 1; - } - } else { /* ! succeeded */ - if (!entry->made_contact) { - /* We've never connected to this one. */ - log_info(LD_CIRC, - "Connection to never-contacted entry guard '%s' (%s) failed. " - "Removing from the list. %d/%d entry guards usable/new.", - entry->nickname, buf, - num_live_entry_guards_for_guard_selection(gs, 0) - 1, - smartlist_len(gs->chosen_entry_guards)-1); - control_event_guard(entry->nickname, entry->identity, "DROPPED"); - entry_guard_free(entry); - smartlist_del_keeporder(gs->chosen_entry_guards, idx); - log_entry_guards_for_guard_selection(gs, LOG_INFO); - changed = 1; - } else if (!entry->unreachable_since) { - log_info(LD_CIRC, "Unable to connect to entry guard '%s' (%s). " - "Marking as unreachable.", entry->nickname, buf); - entry->unreachable_since = entry->last_attempted = now; - control_event_guard(entry->nickname, entry->identity, "DOWN"); - changed = 1; - entry->can_retry = 0; /* We gave it an early chance; no good. */ - } else { - char tbuf[ISO_TIME_LEN+1]; - format_iso_time(tbuf, entry->unreachable_since); - log_debug(LD_CIRC, "Failed to connect to unreachable entry guard " - "'%s' (%s). It has been unreachable since %s.", - entry->nickname, buf, tbuf); - entry->last_attempted = now; - entry->can_retry = 0; /* We gave it an early chance; no good. */ - } - } - - /* if the caller asked us to, also update the is_running flags for this - * relay */ - if (mark_relay_status) - router_set_status(digest, succeeded); - - if (first_contact) { - /* We've just added a new long-term entry guard. Perhaps the network just - * came back? We should give our earlier entries another try too, - * and close this connection so we don't use it before we've given - * the others a shot. */ - SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e) { - if (e == entry) - break; - if (e->made_contact) { - const char *msg; - const node_t *r = entry_is_live(e, - ENTRY_NEED_CAPACITY | ENTRY_ASSUME_REACHABLE, - &msg); - if (r && e->unreachable_since) { - refuse_conn = 1; - e->can_retry = 1; - } - } - } SMARTLIST_FOREACH_END(e); - if (refuse_conn) { - log_info(LD_CIRC, - "Connected to new entry guard '%s' (%s). Marking earlier " - "entry guards up. %d/%d entry guards usable/new.", - entry->nickname, buf, - num_live_entry_guards_for_guard_selection(gs, 0), - smartlist_len(gs->chosen_entry_guards)); - log_entry_guards_for_guard_selection(gs, LOG_INFO); - changed = 1; - } - } - - if (changed) - entry_guards_changed_for_guard_selection(gs); - return refuse_conn ? -1 : 0; -} - -/** Called when a connection to an OR with the identity digest <b>digest</b> - * is established (<b>succeeded</b>==1) or has failed (<b>succeeded</b>==0). - * If the OR is an entry, change that entry's up/down status in the default - * guard selection context. - * Return 0 normally, or -1 if we want to tear down the new connection. - * - * If <b>mark_relay_status</b>, also call router_set_status() on this - * relay. - */ -int -entry_guard_register_connect_status(const char *digest, int succeeded, - int mark_relay_status, time_t now) -{ - return entry_guard_register_connect_status_for_guard_selection( - get_guard_selection_info(), digest, succeeded, mark_relay_status, now); -} - -/** Called when the value of EntryNodes changes in our configuration. */ -void -entry_nodes_should_be_added_for_guard_selection(guard_selection_t *gs) -{ - tor_assert(gs != NULL); - - log_info(LD_CIRC, "EntryNodes config option set. Putting configured " - "relays at the front of the entry guard list."); - gs->should_add_entry_nodes = 1; -} - -/** Called when the value of EntryNodes changes in our configuration. */ -void -entry_nodes_should_be_added(void) -{ - entry_nodes_should_be_added_for_guard_selection( - get_guard_selection_info()); -} - -/** Adjust the entry guards list so that it only contains entries from - * EntryNodes, adding new entries from EntryNodes to the list as needed. */ -STATIC void -entry_guards_set_from_config(guard_selection_t *gs, - const or_options_t *options) -{ - smartlist_t *entry_nodes, *worse_entry_nodes, *entry_fps; - smartlist_t *old_entry_guards_on_list, *old_entry_guards_not_on_list; - const int numentryguards = decide_num_guards(options, 0); - - tor_assert(gs != NULL); - tor_assert(gs->chosen_entry_guards != NULL); - - gs->should_add_entry_nodes = 0; - - if (!options->EntryNodes) { - /* It's possible that a controller set EntryNodes, thus making - * should_add_entry_nodes set, then cleared it again, all before the - * call to choose_random_entry() that triggered us. If so, just return. - */ - return; - } - - { - char *string = routerset_to_string(options->EntryNodes); - log_info(LD_CIRC,"Adding configured EntryNodes '%s'.", string); - tor_free(string); - } - - entry_nodes = smartlist_new(); - worse_entry_nodes = smartlist_new(); - entry_fps = smartlist_new(); - old_entry_guards_on_list = smartlist_new(); - old_entry_guards_not_on_list = smartlist_new(); - - /* Split entry guards into those on the list and those not. */ - - routerset_get_all_nodes(entry_nodes, options->EntryNodes, - options->ExcludeNodes, 0); - SMARTLIST_FOREACH(entry_nodes, const node_t *,node, - smartlist_add(entry_fps, (void*)node->identity)); - - SMARTLIST_FOREACH(gs->chosen_entry_guards, entry_guard_t *, e, { - if (smartlist_contains_digest(entry_fps, e->identity)) - smartlist_add(old_entry_guards_on_list, e); - else - smartlist_add(old_entry_guards_not_on_list, e); - }); - - /* Remove all currently configured guard nodes, excluded nodes, unreachable - * nodes, or non-Guard nodes from entry_nodes. */ - SMARTLIST_FOREACH_BEGIN(entry_nodes, const node_t *, node) { - if (entry_guard_get_by_id_digest_for_guard_selection(gs, - node->identity)) { - SMARTLIST_DEL_CURRENT(entry_nodes, node); - continue; - } else if (routerset_contains_node(options->ExcludeNodes, node)) { - SMARTLIST_DEL_CURRENT(entry_nodes, node); - continue; - } else if (!fascist_firewall_allows_node(node, FIREWALL_OR_CONNECTION, - 0)) { - SMARTLIST_DEL_CURRENT(entry_nodes, node); - continue; - } else if (! node->is_possible_guard) { - smartlist_add(worse_entry_nodes, (node_t*)node); - SMARTLIST_DEL_CURRENT(entry_nodes, node); - } - } SMARTLIST_FOREACH_END(node); - - /* Now build the new entry_guards list. */ - smartlist_clear(gs->chosen_entry_guards); - /* First, the previously configured guards that are in EntryNodes. */ - smartlist_add_all(gs->chosen_entry_guards, old_entry_guards_on_list); - /* Next, scramble the rest of EntryNodes, putting the guards first. */ - smartlist_shuffle(entry_nodes); - smartlist_shuffle(worse_entry_nodes); - smartlist_add_all(entry_nodes, worse_entry_nodes); - - /* Next, the rest of EntryNodes */ - SMARTLIST_FOREACH_BEGIN(entry_nodes, const node_t *, node) { - add_an_entry_guard(gs, node, 0, 0, 1, 0); - if (smartlist_len(gs->chosen_entry_guards) > numentryguards * 10) - break; - } SMARTLIST_FOREACH_END(node); - log_notice(LD_GENERAL, "%d entries in guards", - smartlist_len(gs->chosen_entry_guards)); - /* Finally, free the remaining previously configured guards that are not in - * EntryNodes. */ - SMARTLIST_FOREACH(old_entry_guards_not_on_list, entry_guard_t *, e, - entry_guard_free(e)); - - smartlist_free(entry_nodes); - smartlist_free(worse_entry_nodes); - smartlist_free(entry_fps); - smartlist_free(old_entry_guards_on_list); - smartlist_free(old_entry_guards_not_on_list); - entry_guards_changed_for_guard_selection(gs); -} -#endif - /** Return 0 if we're fine adding arbitrary routers out of the * directory to our entry guard list, or return 1 if we have a * list already and we must stick to it. @@ -4018,35 +2958,6 @@ entry_list_is_constrained(const or_options_t *options) return 0; } -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM -/** Pick a live (up and listed) entry guard from entry_guards. If - * <b>state</b> is non-NULL, this is for a specific circuit -- - * make sure not to pick this circuit's exit or any node in the - * exit's family. If <b>state</b> is NULL, we're looking for a random - * guard (likely a bridge). If <b>dirinfo</b> is not NO_DIRINFO (zero), - * then only select from nodes that know how to answer directory questions - * of that type. */ -const node_t * -choose_random_entry(cpath_build_state_t *state) -{ - tor_assert(get_options()->UseDeprecatedGuardAlgorithm); - - return choose_random_entry_impl(get_guard_selection_info(), - state, 0, NO_DIRINFO, NULL); -} - -/** Pick a live (up and listed) directory guard from entry_guards for - * downloading information of type <b>type</b>. */ -const node_t * -choose_random_dirguard(dirinfo_type_t type) -{ - tor_assert(get_options()->UseDeprecatedGuardAlgorithm); - - return choose_random_entry_impl(get_guard_selection_info(), - NULL, 1, type, NULL); -} -#endif - /** Return the number of bridges that have descriptors that are marked with * purpose 'bridge' and are running. */ @@ -4055,249 +2966,24 @@ num_bridges_usable(void) { int n_options = 0; - if (get_options()->UseDeprecatedGuardAlgorithm) { -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - tor_assert(get_options()->UseBridges); - (void) choose_random_entry_impl(get_guard_selection_info(), - NULL, 0, 0, &n_options); -#else - tor_assert_nonfatal_unreached(); -#endif - } else { - /* XXXX prop271 Is this quite right? */ - tor_assert(get_options()->UseBridges); - guard_selection_t *gs = get_guard_selection_info(); - tor_assert(gs->type == GS_TYPE_BRIDGE); + /* XXXX prop271 Is this quite right? */ + tor_assert(get_options()->UseBridges); + guard_selection_t *gs = get_guard_selection_info(); + tor_assert(gs->type == GS_TYPE_BRIDGE); - SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, guard) { - if (guard->is_reachable == GUARD_REACHABLE_NO) - continue; - if (tor_digest_is_zero(guard->identity)) - continue; - const node_t *node = node_get_by_id(guard->identity); - if (node && node->ri) - ++n_options; - } SMARTLIST_FOREACH_END(guard); - } + SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, guard) { + if (guard->is_reachable == GUARD_REACHABLE_NO) + continue; + if (tor_digest_is_zero(guard->identity)) + continue; + const node_t *node = node_get_by_id(guard->identity); + if (node && node->ri) + ++n_options; + } SMARTLIST_FOREACH_END(guard); return n_options; } -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM -/** Filter <b>all_entry_guards</b> for usable entry guards and put them - * in <b>live_entry_guards</b>. We filter based on whether the node is - * currently alive, and on whether it satisfies the restrictions - * imposed by the other arguments of this function. - * - * We don't place more guards than NumEntryGuards in <b>live_entry_guards</b>. - * - * If <b>chosen_exit</b> is set, it contains the exit node of this - * circuit. Make sure to not use it or its family as an entry guard. - * - * If <b>need_uptime</b> is set, we are looking for a stable entry guard. - * if <b>need_capacity</b> is set, we are looking for a fast entry guard. - * - * The rest of the arguments are the same as in choose_random_entry_impl(). - * - * Return 1 if we should choose a guard right away. Return 0 if we - * should try to add more nodes to our list before deciding on a - * guard. - */ -STATIC int -populate_live_entry_guards(smartlist_t *live_entry_guards, - const smartlist_t *all_entry_guards, - const node_t *chosen_exit, - dirinfo_type_t dirinfo_type, - int for_directory, - int need_uptime, int need_capacity) -{ - const or_options_t *options = get_options(); - const node_t *node = NULL; - const int num_needed = decide_num_guards(options, for_directory); - smartlist_t *exit_family = smartlist_new(); - int retval = 0; - entry_is_live_flags_t entry_flags = 0; - - (void) dirinfo_type; - - { /* Set the flags we want our entry node to have */ - if (need_uptime) { - entry_flags |= ENTRY_NEED_UPTIME; - } - if (need_capacity) { - entry_flags |= ENTRY_NEED_CAPACITY; - } - if (!for_directory) { - entry_flags |= ENTRY_NEED_DESCRIPTOR; - } - } - - tor_assert(all_entry_guards); - - if (chosen_exit) { - nodelist_add_node_and_family(exit_family, chosen_exit); - } - - SMARTLIST_FOREACH_BEGIN(all_entry_guards, const entry_guard_t *, entry) { - const char *msg; - node = entry_is_live(entry, entry_flags, &msg); - if (!node) - continue; /* down, no point */ - if (for_directory) { - if (!entry->is_dir_cache) - continue; /* We need a directory and didn't get one. */ - } - if (node == chosen_exit) - continue; /* don't pick the same node for entry and exit */ - if (smartlist_contains(exit_family, node)) - continue; /* avoid relays that are family members of our exit */ - smartlist_add(live_entry_guards, (void*)node); - if (!entry->made_contact) { - /* Always start with the first not-yet-contacted entry - * guard. Otherwise we might add several new ones, pick - * the second new one, and now we've expanded our entry - * guard list without needing to. */ - retval = 1; - goto done; - } - if (smartlist_len(live_entry_guards) >= num_needed) { - retval = 1; - goto done; /* We picked enough entry guards. Done! */ - } - } SMARTLIST_FOREACH_END(entry); - - done: - smartlist_free(exit_family); - - return retval; -} - -/** Pick a node to be used as the entry guard of a circuit, relative to - * a supplied guard selection context. - * - * If <b>state</b> is set, it contains the information we know about - * the upcoming circuit. - * - * If <b>for_directory</b> is set, we are looking for a directory guard. - * - * <b>dirinfo_type</b> contains the kind of directory information we - * are looking for in our node, or NO_DIRINFO (zero) if we are not - * looking for any particular directory information (when set to - * NO_DIRINFO, the <b>dirinfo_type</b> filter is ignored). - * - * If <b>n_options_out</b> is set, we set it to the number of - * candidate guard nodes we had before picking a specific guard node. - * - * On success, return the node that should be used as the entry guard - * of the circuit. Return NULL if no such node could be found. - * - * Helper for choose_random{entry,dirguard}. -*/ -static const node_t * -choose_random_entry_impl(guard_selection_t *gs, - cpath_build_state_t *state, int for_directory, - dirinfo_type_t dirinfo_type, int *n_options_out) -{ - const or_options_t *options = get_options(); - smartlist_t *live_entry_guards = smartlist_new(); - const node_t *chosen_exit = - state?build_state_get_exit_node(state) : NULL; - const node_t *node = NULL; - int need_uptime = state ? state->need_uptime : 0; - int need_capacity = state ? state->need_capacity : 0; - int preferred_min = 0; - const int num_needed = decide_num_guards(options, for_directory); - int retval = 0; - - tor_assert(gs != NULL); - tor_assert(gs->chosen_entry_guards != NULL); - - if (n_options_out) - *n_options_out = 0; - - if (gs->should_add_entry_nodes) - entry_guards_set_from_config(gs, options); - - if (!entry_list_is_constrained(options) && - smartlist_len(gs->chosen_entry_guards) < num_needed) - pick_entry_guards(gs, options, for_directory); - - retry: - smartlist_clear(live_entry_guards); - - /* Populate the list of live entry guards so that we pick one of - them. */ - retval = populate_live_entry_guards(live_entry_guards, - gs->chosen_entry_guards, - chosen_exit, - dirinfo_type, - for_directory, - need_uptime, need_capacity); - - if (retval == 1) { /* We should choose a guard right now. */ - goto choose_and_finish; - } - - if (entry_list_is_constrained(options)) { - /* If we prefer the entry nodes we've got, and we have at least - * one choice, that's great. Use it. */ - preferred_min = 1; - } else { - /* Try to have at least 2 choices available. This way we don't - * get stuck with a single live-but-crummy entry and just keep - * using it. - * (We might get 2 live-but-crummy entry guards, but so be it.) */ - preferred_min = 2; - } - - if (smartlist_len(live_entry_guards) < preferred_min) { - if (!entry_list_is_constrained(options)) { - /* still no? try adding a new entry then */ - /* XXX if guard doesn't imply fast and stable, then we need - * to tell add_an_entry_guard below what we want, or it might - * be a long time til we get it. -RD */ - node = add_an_entry_guard(gs, NULL, 0, 0, 1, for_directory); - if (node) { - entry_guards_changed_for_guard_selection(gs); - /* XXX we start over here in case the new node we added shares - * a family with our exit node. There's a chance that we'll just - * load up on entry guards here, if the network we're using is - * one big family. Perhaps we should teach add_an_entry_guard() - * to understand nodes-to-avoid-if-possible? -RD */ - goto retry; - } - } - if (!node && need_uptime) { - need_uptime = 0; /* try without that requirement */ - goto retry; - } - if (!node && need_capacity) { - /* still no? last attempt, try without requiring capacity */ - need_capacity = 0; - goto retry; - } - - /* live_entry_guards may be empty below. Oh well, we tried. */ - } - - choose_and_finish: - if (entry_list_is_constrained(options)) { - /* We need to weight by bandwidth, because our bridges or entryguards - * were not already selected proportional to their bandwidth. */ - node = node_sl_choose_by_bandwidth(live_entry_guards, WEIGHT_FOR_GUARD); - } else { - /* We choose uniformly at random here, because choose_good_entry_server() - * already weights its choices by bandwidth, so we don't want to - * *double*-weight our guard selection. */ - node = smartlist_choose(live_entry_guards); - } - if (n_options_out) - *n_options_out = smartlist_len(live_entry_guards); - smartlist_free(live_entry_guards); - return node; -} -#endif - /** Check the pathbias use success count of <b>node</b> and disable it if it * goes over our thresholds. */ static void @@ -4344,262 +3030,6 @@ pathbias_check_close_success_count(entry_guard_t *node) } } -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM -/** Parse <b>state</b> and learn about the entry guards it describes. - * If <b>set</b> is true, and there are no errors, replace the guard - * list in the provided guard selection context with what we find. - * On success, return 0. On failure, alloc into *<b>msg</b> a string - * describing the error, and return -1. - */ -int -entry_guards_parse_state_for_guard_selection( - guard_selection_t *gs, - or_state_t *state, int set, char **msg) -{ - entry_guard_t *node = NULL; - smartlist_t *new_entry_guards = smartlist_new(); - config_line_t *line; - time_t now = time(NULL); - const char *state_version = state->TorVersion; - digestmap_t *added_by = digestmap_new(); - - tor_assert(gs != NULL); - - *msg = NULL; - for (line = state->EntryGuards; line; line = line->next) { - if (!strcasecmp(line->key, "EntryGuard")) { - smartlist_t *args = smartlist_new(); - node = tor_malloc_zero(sizeof(entry_guard_t)); - /* all entry guards on disk have been contacted */ - node->made_contact = 1; - node->is_persistent = 1; - smartlist_add(new_entry_guards, node); - smartlist_split_string(args, line->value, " ", - SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0); - if (smartlist_len(args)<2) { - *msg = tor_strdup("Unable to parse entry nodes: " - "Too few arguments to EntryGuard"); - } else if (!is_legal_nickname(smartlist_get(args,0))) { - *msg = tor_strdup("Unable to parse entry nodes: " - "Bad nickname for EntryGuard"); - } else { - strlcpy(node->nickname, smartlist_get(args,0), MAX_NICKNAME_LEN+1); - if (base16_decode(node->identity, DIGEST_LEN, smartlist_get(args,1), - strlen(smartlist_get(args,1))) != DIGEST_LEN) { - *msg = tor_strdup("Unable to parse entry nodes: " - "Bad hex digest for EntryGuard"); - } - } - if (smartlist_len(args) >= 3) { - const char *is_cache = smartlist_get(args, 2); - if (!strcasecmp(is_cache, "DirCache")) { - node->is_dir_cache = 1; - } else if (!strcasecmp(is_cache, "NoDirCache")) { - node->is_dir_cache = 0; - } else { - log_warn(LD_CONFIG, "Bogus third argument to EntryGuard line: %s", - escaped(is_cache)); - } - } - SMARTLIST_FOREACH(args, char*, cp, tor_free(cp)); - smartlist_free(args); - if (*msg) - break; - } else if (!strcasecmp(line->key, "EntryGuardDownSince") || - !strcasecmp(line->key, "EntryGuardUnlistedSince")) { - time_t when; - time_t last_try = 0; - if (!node) { - *msg = tor_strdup("Unable to parse entry nodes: " - "EntryGuardDownSince/UnlistedSince without EntryGuard"); - break; - } - if (parse_iso_time_(line->value, &when, 0, 0)<0) { - *msg = tor_strdup("Unable to parse entry nodes: " - "Bad time in EntryGuardDownSince/UnlistedSince"); - break; - } - if (when > now) { - /* It's a bad idea to believe info in the future: you can wind - * up with timeouts that aren't allowed to happen for years. */ - continue; - } - if (strlen(line->value) >= ISO_TIME_LEN+ISO_TIME_LEN+1) { - /* ignore failure */ - (void) parse_iso_time(line->value+ISO_TIME_LEN+1, &last_try); - } - if (!strcasecmp(line->key, "EntryGuardDownSince")) { - node->unreachable_since = when; - node->last_attempted = last_try; - } else { - node->bad_since = when; - } - } else if (!strcasecmp(line->key, "EntryGuardAddedBy")) { - char d[DIGEST_LEN]; - /* format is digest version date */ - if (strlen(line->value) < HEX_DIGEST_LEN+1+1+1+ISO_TIME_LEN) { - log_warn(LD_BUG, "EntryGuardAddedBy line is not long enough."); - continue; - } - if (base16_decode(d, sizeof(d), - line->value, HEX_DIGEST_LEN) != sizeof(d) || - line->value[HEX_DIGEST_LEN] != ' ') { - log_warn(LD_BUG, "EntryGuardAddedBy line %s does not begin with " - "hex digest", escaped(line->value)); - continue; - } - digestmap_set(added_by, d, tor_strdup(line->value+HEX_DIGEST_LEN+1)); - } else if (!strcasecmp(line->key, "EntryGuardPathUseBias")) { - double use_cnt, success_cnt; - - if (!node) { - *msg = tor_strdup("Unable to parse entry nodes: " - "EntryGuardPathUseBias without EntryGuard"); - break; - } - - if (tor_sscanf(line->value, "%lf %lf", - &use_cnt, &success_cnt) != 2) { - log_info(LD_GENERAL, "Malformed path use bias line for node %s", - node->nickname); - continue; - } - - if (use_cnt < success_cnt) { - int severity = LOG_INFO; - /* If this state file was written by a Tor that would have - * already fixed it, then the overcounting bug is still there.. */ - if (tor_version_as_new_as(state_version, "0.2.4.13-alpha")) { - severity = LOG_NOTICE; - } - log_fn(severity, LD_BUG, - "State file contains unexpectedly high usage success " - "counts %lf/%lf for Guard %s ($%s)", - success_cnt, use_cnt, - node->nickname, hex_str(node->identity, DIGEST_LEN)); - success_cnt = use_cnt; - } - - node->pb.use_attempts = use_cnt; - node->pb.use_successes = success_cnt; - - log_info(LD_GENERAL, "Read %f/%f path use bias for node %s", - node->pb.use_successes, node->pb.use_attempts, node->nickname); - - pathbias_check_use_success_count(node); - - } else if (!strcasecmp(line->key, "EntryGuardPathBias")) { - double hop_cnt, success_cnt, timeouts, collapsed, successful_closed, - unusable; - - if (!node) { - *msg = tor_strdup("Unable to parse entry nodes: " - "EntryGuardPathBias without EntryGuard"); - break; - } - - /* First try 3 params, then 2. */ - /* In the long run: circuit_success ~= successful_circuit_close + - * collapsed_circuits + - * unusable_circuits */ - if (tor_sscanf(line->value, "%lf %lf %lf %lf %lf %lf", - &hop_cnt, &success_cnt, &successful_closed, - &collapsed, &unusable, &timeouts) != 6) { - int old_success, old_hops; - if (tor_sscanf(line->value, "%u %u", &old_success, &old_hops) != 2) { - continue; - } - log_info(LD_GENERAL, "Reading old-style EntryGuardPathBias %s", - escaped(line->value)); - - success_cnt = old_success; - successful_closed = old_success; - hop_cnt = old_hops; - timeouts = 0; - collapsed = 0; - unusable = 0; - } - - if (hop_cnt < success_cnt) { - int severity = LOG_INFO; - /* If this state file was written by a Tor that would have - * already fixed it, then the overcounting bug is still there.. */ - if (tor_version_as_new_as(state_version, "0.2.4.13-alpha")) { - severity = LOG_NOTICE; - } - log_fn(severity, LD_BUG, - "State file contains unexpectedly high success counts " - "%lf/%lf for Guard %s ($%s)", - success_cnt, hop_cnt, - node->nickname, hex_str(node->identity, DIGEST_LEN)); - success_cnt = hop_cnt; - } - - node->pb.circ_attempts = hop_cnt; - node->pb.circ_successes = success_cnt; - - node->pb.successful_circuits_closed = successful_closed; - node->pb.timeouts = timeouts; - node->pb.collapsed_circuits = collapsed; - node->pb.unusable_circuits = unusable; - - log_info(LD_GENERAL, "Read %f/%f path bias for node %s", - node->pb.circ_successes, node->pb.circ_attempts, - node->nickname); - - pathbias_check_close_success_count(node); - } else { - log_warn(LD_BUG, "Unexpected key %s", line->key); - } - } - - SMARTLIST_FOREACH_BEGIN(new_entry_guards, entry_guard_t *, e) { - char *sp; - char *val = digestmap_get(added_by, e->identity); - if (val && (sp = strchr(val, ' '))) { - time_t when; - *sp++ = '\0'; - if (parse_iso_time(sp, &when)<0) { - log_warn(LD_BUG, "Can't read time %s in EntryGuardAddedBy", sp); - } else { - e->chosen_by_version = tor_strdup(val); - e->chosen_on_date = when; - } - } else { - if (state_version) { - e->chosen_on_date = crypto_rand_time_range(now - 3600*24*30, now); - e->chosen_by_version = tor_strdup(state_version); - } - } - if (e->pb.path_bias_disabled && !e->bad_since) - e->bad_since = time(NULL); - } - SMARTLIST_FOREACH_END(e); - - if (*msg || !set) { - SMARTLIST_FOREACH(new_entry_guards, entry_guard_t *, e, - entry_guard_free(e)); - smartlist_free(new_entry_guards); - } else { /* !err && set */ - if (gs->chosen_entry_guards) { - SMARTLIST_FOREACH(gs->chosen_entry_guards, entry_guard_t *, e, - entry_guard_free(e)); - smartlist_free(gs->chosen_entry_guards); - } - gs->chosen_entry_guards = new_entry_guards; - SMARTLIST_FOREACH(new_entry_guards, entry_guard_t *, e, - e->in_selection = gs); - - /* XXX hand new_entry_guards to this func, and move it up a - * few lines, so we don't have to re-dirty it */ - if (remove_obsolete_entry_guards(gs, now)) - entry_guards_dirty = 1; - } - digestmap_free(added_by, tor_free_); - return *msg ? -1 : 0; -} -#endif - /** Parse <b>state</b> and learn about the entry guards it describes. * If <b>set</b> is true, and there are no errors, replace the guard * list in the default guard selection context with what we find. @@ -4610,20 +3040,10 @@ int entry_guards_parse_state(or_state_t *state, int set, char **msg) { entry_guards_dirty = 0; - int r1 = entry_guards_load_guards_from_state(state, set); - -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - int r2 = entry_guards_parse_state_for_guard_selection( - get_guard_selection_by_name("legacy", GS_TYPE_LEGACY, 1), - state, set, msg); -#else - int r2 = 0; -#endif - entry_guards_dirty = 0; - if (r1 < 0 || r2 < 0) { + if (r1 < 0) { if (msg && *msg == NULL) { *msg = tor_strdup("parsing error"); //xxxx prop271 should we try harder? } @@ -4683,88 +3103,11 @@ entry_guards_update_state(or_state_t *state) { entry_guards_dirty = 0; - // Handles all non-legacy guard info. + // Handles all guard info. entry_guards_update_guards_in_state(state); entry_guards_dirty = 0; -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - config_line_t **next, *line; - - guard_selection_t *gs; - gs = get_guard_selection_by_name("legacy", GS_TYPE_LEGACY, 0); - if (!gs) - return; // nothign to save. - tor_assert(gs->chosen_entry_guards != NULL); - - config_free_lines(state->EntryGuards); - next = &state->EntryGuards; - *next = NULL; - SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e) { - char dbuf[HEX_DIGEST_LEN+1]; - if (!e->made_contact) - continue; /* don't write this one to disk */ - *next = line = tor_malloc_zero(sizeof(config_line_t)); - line->key = tor_strdup("EntryGuard"); - base16_encode(dbuf, sizeof(dbuf), e->identity, DIGEST_LEN); - tor_asprintf(&line->value, "%s %s %sDirCache", e->nickname, dbuf, - e->is_dir_cache ? "" : "No"); - next = &(line->next); - if (e->unreachable_since) { - *next = line = tor_malloc_zero(sizeof(config_line_t)); - line->key = tor_strdup("EntryGuardDownSince"); - line->value = tor_malloc(ISO_TIME_LEN+1+ISO_TIME_LEN+1); - format_iso_time(line->value, e->unreachable_since); - if (e->last_attempted) { - line->value[ISO_TIME_LEN] = ' '; - format_iso_time(line->value+ISO_TIME_LEN+1, e->last_attempted); - } - next = &(line->next); - } - if (e->bad_since) { - *next = line = tor_malloc_zero(sizeof(config_line_t)); - line->key = tor_strdup("EntryGuardUnlistedSince"); - line->value = tor_malloc(ISO_TIME_LEN+1); - format_iso_time(line->value, e->bad_since); - next = &(line->next); - } - if (e->chosen_on_date && e->chosen_by_version && - !strchr(e->chosen_by_version, ' ')) { - char d[HEX_DIGEST_LEN+1]; - char t[ISO_TIME_LEN+1]; - *next = line = tor_malloc_zero(sizeof(config_line_t)); - line->key = tor_strdup("EntryGuardAddedBy"); - base16_encode(d, sizeof(d), e->identity, DIGEST_LEN); - format_iso_time(t, e->chosen_on_date); - tor_asprintf(&line->value, "%s %s %s", - d, e->chosen_by_version, t); - next = &(line->next); - } - if (e->pb.circ_attempts > 0) { - *next = line = tor_malloc_zero(sizeof(config_line_t)); - line->key = tor_strdup("EntryGuardPathBias"); - /* In the long run: circuit_success ~= successful_circuit_close + - * collapsed_circuits + - * unusable_circuits */ - tor_asprintf(&line->value, "%f %f %f %f %f %f", - e->pb.circ_attempts, e->pb.circ_successes, - pathbias_get_close_success_count(e), - e->pb.collapsed_circuits, - e->pb.unusable_circuits, e->pb.timeouts); - next = &(line->next); - } - if (e->pb.use_attempts > 0) { - *next = line = tor_malloc_zero(sizeof(config_line_t)); - line->key = tor_strdup("EntryGuardPathUseBias"); - - tor_asprintf(&line->value, "%f %f", - e->pb.use_attempts, - pathbias_get_use_success_count(e)); - next = &(line->next); - } - - } SMARTLIST_FOREACH_END(e); -#endif if (!get_options()->AvoidDiskWrites) or_state_mark_dirty(get_or_state(), 0); entry_guards_dirty = 0; @@ -4775,8 +3118,7 @@ entry_guards_update_state(or_state_t *state) * Return a newly allocated string. */ STATIC char * -getinfo_helper_format_single_entry_guard(const entry_guard_t *e, - int legacy_guard) +getinfo_helper_format_single_entry_guard(const entry_guard_t *e) { const char *status = NULL; time_t when = 0; @@ -4784,42 +3126,23 @@ getinfo_helper_format_single_entry_guard(const entry_guard_t *e, char tbuf[ISO_TIME_LEN+1]; char nbuf[MAX_VERBOSE_NICKNAME_LEN+1]; - if (legacy_guard) { -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - if (!e->made_contact) { - status = "never-connected"; - } else if (e->bad_since) { - when = e->bad_since; - status = "unusable"; - } else if (e->unreachable_since) { - when = e->unreachable_since; - status = "down"; - } else { - status = "up"; - } -#else - tor_assert_nonfatal_unreached(); - status = "BUG"; -#endif + /* This is going to be a bit tricky, since the status + * codes weren't really intended for prop271 guards. + * + * XXXX use a more appropriate format for exporting this information + */ + if (e->confirmed_idx < 0) { + status = "never-connected"; + } else if (! e->currently_listed) { + when = e->unlisted_since_date; + status = "unusable"; + } else if (! e->is_filtered_guard) { + status = "unusable"; + } else if (e->is_reachable == GUARD_REACHABLE_NO) { + when = e->failing_since; + status = "down"; } else { - /* modern case. This is going to be a bit tricky, since the status - * codes above weren't really intended for prop271 guards. - * - * XXXX use a more appropriate format for exporting this information - */ - if (e->confirmed_idx < 0) { - status = "never-connected"; - } else if (! e->currently_listed) { - when = e->unlisted_since_date; - status = "unusable"; - } else if (! e->is_filtered_guard) { - status = "unusable"; - } else if (e->is_reachable == GUARD_REACHABLE_NO) { - when = e->failing_since; - status = "down"; - } else { - status = "up"; - } + status = "up"; } node = entry_guard_find_node(e); @@ -4859,9 +3182,6 @@ getinfo_helper_entry_guards(control_connection_t *conn, guard_selection_t *gs = get_guard_selection_info(); tor_assert(gs != NULL); -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - tor_assert(gs->chosen_entry_guards != NULL); -#endif (void) conn; (void) errmsg; @@ -4869,24 +3189,12 @@ getinfo_helper_entry_guards(control_connection_t *conn, if (!strcmp(question,"entry-guards") || !strcmp(question,"helper-nodes")) { const smartlist_t *guards; - int legacy_mode; - if (gs->type == GS_TYPE_LEGACY) { -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - guards = gs->chosen_entry_guards; - legacy_mode = 1; -#else - tor_assert_nonfatal_unreached(); - return 0; -#endif - } else { - guards = gs->sampled_entry_guards; - legacy_mode = 0; - } + guards = gs->sampled_entry_guards; smartlist_t *sl = smartlist_new(); SMARTLIST_FOREACH_BEGIN(guards, const entry_guard_t *, e) { - char *cp = getinfo_helper_format_single_entry_guard(e, legacy_mode); + char *cp = getinfo_helper_format_single_entry_guard(e); smartlist_add(sl, cp); } SMARTLIST_FOREACH_END(e); *answer = smartlist_join_strings(sl, "", 0, NULL); @@ -4931,107 +3239,6 @@ guard_get_guardfraction_bandwidth(guardfraction_bandwidth_t *guardfraction_bw, guardfraction_bw->non_guard_bw = orig_bandwidth - (int) guard_bw; } -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM -/** Returns true iff the node is used as a guard in the specified guard - * context */ -int -is_node_used_as_guard_for_guard_selection(guard_selection_t *gs, - const node_t *node) -{ - int res = 0; - - /* - * We used to have a using_as_guard flag in node_t, but it had to go away - * to allow for multiple guard selection contexts. Instead, search the - * guard list for a matching digest. - */ - - tor_assert(gs != NULL); - tor_assert(node != NULL); - - SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e) { - if (tor_memeq(e->identity, node->identity, DIGEST_LEN)) { - res = 1; - break; - } - } SMARTLIST_FOREACH_END(e); - - return res; -} - -/** Returns true iff the node is used as a guard in the default guard - * context */ -MOCK_IMPL(int, -is_node_used_as_guard, (const node_t *node)) -{ - return is_node_used_as_guard_for_guard_selection( - get_guard_selection_info(), node); -} - -/** Return 1 if we have at least one descriptor for an entry guard - * (bridge or member of EntryNodes) and all descriptors we know are - * down. Else return 0. If <b>act</b> is 1, then mark the down guards - * up; else just observe and report. */ -static int -entries_retry_helper(const or_options_t *options, int act) -{ - const node_t *node; - int any_known = 0; - int any_running = 0; - int need_bridges = options->UseBridges != 0; - guard_selection_t *gs = get_guard_selection_info(); - - tor_assert(gs != NULL); - tor_assert(gs->chosen_entry_guards != NULL); - - SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e) { - node = node_get_by_id(e->identity); - if (node && node_has_descriptor(node) && - node_is_bridge(node) == need_bridges && - (!need_bridges || (!e->bad_since && - node_is_a_configured_bridge(node)))) { - any_known = 1; - if (node->is_running) - any_running = 1; /* some entry is both known and running */ - else if (act) { - /* Mark all current connections to this OR as unhealthy, since - * otherwise there could be one that started 30 seconds - * ago, and in 30 seconds it will time out, causing us to mark - * the node down and undermine the retry attempt. We mark even - * the established conns, since if the network just came back - * we'll want to attach circuits to fresh conns. */ - channel_update_bad_for_new_circs(node->identity, 1); - - /* mark this entry node for retry */ - router_set_status(node->identity, 1); - e->can_retry = 1; - e->bad_since = 0; - } - } - } SMARTLIST_FOREACH_END(e); - log_debug(LD_DIR, "%d: any_known %d, any_running %d", - act, any_known, any_running); - return any_known && !any_running; -} - -/** Do we know any descriptors for our bridges / entrynodes, and are - * all the ones we have descriptors for down? */ -int -entries_known_but_down(const or_options_t *options) -{ - tor_assert(entry_list_is_constrained(options)); - return entries_retry_helper(options, 0); -} - -/** Mark all down known bridges / entrynodes up. */ -void -entries_retry_all(const or_options_t *options) -{ - tor_assert(entry_list_is_constrained(options)); - entries_retry_helper(options, 1); -} -#endif - /** Helper: Update the status of all entry guards, in whatever algorithm * is used. Return true if we should stop using all previously generated * circuits, by calling circuit_mark_all_unused_circs() and @@ -5046,16 +3253,8 @@ guards_update_all(void) tor_assert(curr_guard_context); - if (curr_guard_context->type == GS_TYPE_LEGACY) { -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - entry_guards_compute_status(get_options(), approx_time()); -#else - tor_assert_nonfatal_unreached(); -#endif - } else { - if (entry_guards_update_all(curr_guard_context)) - mark_circuits = 1; - } + if (entry_guards_update_all(curr_guard_context)) + mark_circuits = 1; return mark_circuits; } @@ -5066,66 +3265,75 @@ const node_t * guards_choose_guard(cpath_build_state_t *state, circuit_guard_state_t **guard_state_out) { - if (get_options()->UseDeprecatedGuardAlgorithm) { -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - return choose_random_entry(state); -#else - tor_assert_nonfatal_unreached(); - return NULL; -#endif - } else { - const node_t *r = NULL; - const uint8_t *exit_id = NULL; - entry_guard_restriction_t *rst = NULL; - // XXXX prop271 spec deviation -- use of restriction here. - if (state && (exit_id = build_state_get_exit_rsa_id(state))) { - /* We're building to a targeted exit node, so that node can't be - * chosen as our guard for this circuit. */ - rst = tor_malloc_zero(sizeof(entry_guard_restriction_t)); - memcpy(rst->exclude_id, exit_id, DIGEST_LEN); - } - if (entry_guard_pick_for_circuit(get_guard_selection_info(), - GUARD_USAGE_TRAFFIC, - rst, - &r, - guard_state_out) < 0) { - tor_assert(r == NULL); - } - return r; + const node_t *r = NULL; + const uint8_t *exit_id = NULL; + entry_guard_restriction_t *rst = NULL; + if (state && (exit_id = build_state_get_exit_rsa_id(state))) { + /* We're building to a targeted exit node, so that node can't be + * chosen as our guard for this circuit. Remember that fact in a + * restriction. */ + rst = tor_malloc_zero(sizeof(entry_guard_restriction_t)); + memcpy(rst->exclude_id, exit_id, DIGEST_LEN); + } + if (entry_guard_pick_for_circuit(get_guard_selection_info(), + GUARD_USAGE_TRAFFIC, + rst, + &r, + guard_state_out) < 0) { + tor_assert(r == NULL); + } + return r; +} + +/** Remove all currently listed entry guards for a given guard selection + * context. This frees and replaces <b>gs</b>, so don't use <b>gs</b> + * after calling this function. */ +void +remove_all_entry_guards_for_guard_selection(guard_selection_t *gs) +{ + // This function shouldn't exist. XXXX + tor_assert(gs != NULL); + char *old_name = tor_strdup(gs->name); + guard_selection_type_t old_type = gs->type; + + SMARTLIST_FOREACH(gs->sampled_entry_guards, entry_guard_t *, entry, { + control_event_guard(entry->nickname, entry->identity, "DROPPED"); + }); + + if (gs == curr_guard_context) { + curr_guard_context = NULL; } + + smartlist_remove(guard_contexts, gs); + guard_selection_free(gs); + + gs = get_guard_selection_by_name(old_name, old_type, 1); + entry_guards_changed_for_guard_selection(gs); + tor_free(old_name); +} + +/** Remove all currently listed entry guards. So new ones will be chosen. */ +void +remove_all_entry_guards(void) +{ + // XXXX prop271 this function shouldn't exist, in the new order. + // This function shouldn't exist. + remove_all_entry_guards_for_guard_selection(get_guard_selection_info()); } /** Helper: pick a directory guard, with whatever algorithm is used. */ const node_t * -guards_choose_dirguard(dirinfo_type_t info, - circuit_guard_state_t **guard_state_out) +guards_choose_dirguard(circuit_guard_state_t **guard_state_out) { - if (get_options()->UseDeprecatedGuardAlgorithm) { -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - return choose_random_dirguard(info); -#else - (void)info; - tor_assert_nonfatal_unreached(); - return NULL; -#endif - } else { - /* XXXX prop271 We don't need to look at the dirinfo_type_t here, - * apparently. If you look at the old implementation, and you follow info - * downwards through choose_random_dirguard(), into - * choose_random_entry_impl(), into populate_live_entry_guards()... you - * find out that it isn't even used, and hasn't been since 0.2.7.1-alpha, - * when we realized that every Tor on the network would support - * microdescriptors. -NM */ - const node_t *r = NULL; - if (entry_guard_pick_for_circuit(get_guard_selection_info(), - GUARD_USAGE_DIRGUARD, - NULL, - &r, - guard_state_out) < 0) { - tor_assert(r == NULL); - } - return r; + const node_t *r = NULL; + if (entry_guard_pick_for_circuit(get_guard_selection_info(), + GUARD_USAGE_DIRGUARD, + NULL, + &r, + guard_state_out) < 0) { + tor_assert(r == NULL); } + return r; } /** @@ -5138,21 +3346,49 @@ guards_retry_optimistic(const or_options_t *options) if (! entry_list_is_constrained(options)) return 0; -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - if (options->UseDeprecatedGuardAlgorithm) { - if (entries_known_but_down(options)) { - entries_retry_all(options); - return 1; - } - } -#endif - // XXXX prop271 -- is this correct? mark_primary_guards_maybe_reachable(get_guard_selection_info()); return 1; } +/** + * Return true iff we know enough directory information to construct + * circuits through all of the primary guards we'd currently use. + */ +int +guard_selection_have_enough_dir_info_to_build_circuits(guard_selection_t *gs) +{ + if (!gs->primary_guards_up_to_date) + entry_guards_update_primary(gs); + + const int num_primary = get_n_primary_guards_to_use(GUARD_USAGE_TRAFFIC); + int n_missing_descriptors = 0; + int n_considered = 0; + + SMARTLIST_FOREACH_BEGIN(gs->primary_entry_guards, entry_guard_t *, guard) { + entry_guard_consider_retry(guard); + if (guard->is_reachable == GUARD_REACHABLE_NO) + continue; + n_considered++; + if (!guard_has_descriptor(guard)) + n_missing_descriptors++; + if (n_considered >= num_primary) + break; + } SMARTLIST_FOREACH_END(guard); + + return n_missing_descriptors == 0; +} + +/** As guard_selection_have_enough_dir_info_to_build_circuits, but uses + * the default guard selection. */ +int +entry_guards_have_enough_dir_info_to_build_circuits(void) +{ + return guard_selection_have_enough_dir_info_to_build_circuits( + get_guard_selection_info()); +} + /** Free one guard selection context */ STATIC void guard_selection_free(guard_selection_t *gs) @@ -5161,15 +3397,6 @@ guard_selection_free(guard_selection_t *gs) tor_free(gs->name); -#ifdef ENABLE_LEGACY_GUARD_ALGORITHM - if (gs->chosen_entry_guards) { - SMARTLIST_FOREACH(gs->chosen_entry_guards, entry_guard_t *, e, - entry_guard_free(e)); - smartlist_free(gs->chosen_entry_guards); - gs->chosen_entry_guards = NULL; - } -#endif - if (gs->sampled_entry_guards) { SMARTLIST_FOREACH(gs->sampled_entry_guards, entry_guard_t *, e, entry_guard_free(e)); |