mirror of
https://gitlab.torproject.org/tpo/core/tor.git
synced 2024-11-14 07:03:44 +01:00
Remove the (no longer compiled) code for legacy guard selection.
Part of 20830.
This commit is contained in:
Nick Mathewson
parent
e167a0e17d
commit
472b277207
@ -762,11 +762,7 @@ learned_bridge_descriptor(routerinfo_t *ri, int from_cache)
|
|||||||
(int) bridge->port);
|
(int) bridge->port);
|
||||||
}
|
}
|
||||||
if (get_options()->UseDeprecatedGuardAlgorithm) {
|
if (get_options()->UseDeprecatedGuardAlgorithm) {
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
add_bridge_as_entry_guard(get_guard_selection_info(), node);
|
|
||||||
#else
|
|
||||||
tor_assert_nonfatal_unreached();
|
tor_assert_nonfatal_unreached();
|
||||||
#endif
|
|
||||||
} else {
|
} else {
|
||||||
entry_guard_learned_bridge_identity(&bridge->addrport_configured,
|
entry_guard_learned_bridge_identity(&bridge->addrport_configured,
|
||||||
(const uint8_t*)ri->cache_info.identity_digest);
|
(const uint8_t*)ri->cache_info.identity_digest);
|
||||||
@ -777,12 +773,7 @@ learned_bridge_descriptor(routerinfo_t *ri, int from_cache)
|
|||||||
/* set entry->made_contact so if it goes down we don't drop it from
|
/* set entry->made_contact so if it goes down we don't drop it from
|
||||||
* our entry node list */
|
* our entry node list */
|
||||||
if (get_options()->UseDeprecatedGuardAlgorithm) {
|
if (get_options()->UseDeprecatedGuardAlgorithm) {
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
entry_guard_register_connect_status(ri->cache_info.identity_digest,
|
|
||||||
1, 0, now);
|
|
||||||
#else
|
|
||||||
tor_assert_nonfatal_unreached();
|
tor_assert_nonfatal_unreached();
|
||||||
#endif
|
|
||||||
}
|
}
|
||||||
if (first) {
|
if (first) {
|
||||||
routerlist_retry_directory_downloads(now);
|
routerlist_retry_directory_downloads(now);
|
||||||
|
|||||||
@ -2577,19 +2577,6 @@ channel_do_open_actions(channel_t *chan)
|
|||||||
if (started_here) {
|
if (started_here) {
|
||||||
circuit_build_times_network_is_live(get_circuit_build_times_mutable());
|
circuit_build_times_network_is_live(get_circuit_build_times_mutable());
|
||||||
rep_hist_note_connect_succeeded(chan->identity_digest, now);
|
rep_hist_note_connect_succeeded(chan->identity_digest, now);
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
// XXXX prop271 this call is no longer useful with the new algorithm.
|
|
||||||
if (entry_guard_register_connect_status(
|
|
||||||
chan->identity_digest, 1, 0, now) < 0) {
|
|
||||||
/* Close any circuits pending on this channel. We leave it in state
|
|
||||||
* 'open' though, because it didn't actually *fail* -- we just
|
|
||||||
* chose not to use it. */
|
|
||||||
log_debug(LD_OR,
|
|
||||||
"New entry guard was reachable, but closing this "
|
|
||||||
"connection so we can retry the earlier entry guards.");
|
|
||||||
close_origin_circuits = 1;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
router_set_status(chan->identity_digest, 1);
|
router_set_status(chan->identity_digest, 1);
|
||||||
} else {
|
} else {
|
||||||
/* only report it to the geoip module if it's not a known router */
|
/* only report it to the geoip module if it's not a known router */
|
||||||
|
|||||||
@ -1279,10 +1279,6 @@ pathbias_measure_use_rate(entry_guard_t *guard)
|
|||||||
tor_lround(pb->timeouts),
|
tor_lround(pb->timeouts),
|
||||||
tor_lround(get_circuit_build_close_time_ms()/1000));
|
tor_lround(get_circuit_build_close_time_ms()/1000));
|
||||||
pb->path_bias_disabled = 1;
|
pb->path_bias_disabled = 1;
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
// XXXX
|
|
||||||
entry_guard_mark_bad(guard);
|
|
||||||
#endif
|
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
} else if (!pb->path_bias_use_extreme) {
|
} else if (!pb->path_bias_use_extreme) {
|
||||||
@ -1388,10 +1384,6 @@ pathbias_measure_close_rate(entry_guard_t *guard)
|
|||||||
tor_lround(pb->timeouts),
|
tor_lround(pb->timeouts),
|
||||||
tor_lround(get_circuit_build_close_time_ms()/1000));
|
tor_lround(get_circuit_build_close_time_ms()/1000));
|
||||||
pb->path_bias_disabled = 1;
|
pb->path_bias_disabled = 1;
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
// XXXX
|
|
||||||
entry_guard_mark_bad(guard);
|
|
||||||
#endif
|
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
} else if (!pb->path_bias_extreme) {
|
} else if (!pb->path_bias_extreme) {
|
||||||
|
|||||||
@ -2308,26 +2308,6 @@ choose_good_entry_server(uint8_t purpose, cpath_build_state_t *state,
|
|||||||
* family. */
|
* family. */
|
||||||
nodelist_add_node_and_family(excluded, node);
|
nodelist_add_node_and_family(excluded, node);
|
||||||
}
|
}
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
/* and exclude current entry guards and their families,
|
|
||||||
* unless we're in a test network, and excluding guards
|
|
||||||
* would exclude all nodes (i.e. we're in an incredibly small tor network,
|
|
||||||
* or we're using TestingAuthVoteGuard *).
|
|
||||||
* This is an incomplete fix, but is no worse than the previous behaviour,
|
|
||||||
* and only applies to minimal, testing tor networks
|
|
||||||
* (so it's no less secure) */
|
|
||||||
if (options->UseEntryGuards
|
|
||||||
&& (!options->TestingTorNetwork ||
|
|
||||||
smartlist_len(nodelist_get_list()) > smartlist_len(get_entry_guards())
|
|
||||||
)) {
|
|
||||||
SMARTLIST_FOREACH(get_entry_guards(), const entry_guard_t *, entry,
|
|
||||||
{
|
|
||||||
if ((node = entry_guard_find_node(entry))) {
|
|
||||||
nodelist_add_node_and_family(excluded, node);
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
if (state) {
|
if (state) {
|
||||||
if (state->need_uptime)
|
if (state->need_uptime)
|
||||||
|
|||||||
@ -1732,10 +1732,6 @@ circuit_build_failed(origin_circuit_t *circ)
|
|||||||
/* New guard API: we failed. */
|
/* New guard API: we failed. */
|
||||||
if (circ->guard_state)
|
if (circ->guard_state)
|
||||||
entry_guard_failed(&circ->guard_state);
|
entry_guard_failed(&circ->guard_state);
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
/* Old guard API: we failed. */
|
|
||||||
entry_guard_register_connect_status(n_chan_id, 0, 1, time(NULL));
|
|
||||||
#endif
|
|
||||||
/* if there are any one-hop streams waiting on this circuit, fail
|
/* if there are any one-hop streams waiting on this circuit, fail
|
||||||
* them now so they can retry elsewhere. */
|
* them now so they can retry elsewhere. */
|
||||||
connection_ap_fail_onehop(n_chan_id, circ->build_state);
|
connection_ap_fail_onehop(n_chan_id, circ->build_state);
|
||||||
|
|||||||
@ -2097,15 +2097,6 @@ options_act(const or_options_t *old_options)
|
|||||||
!options->BridgeAuthoritativeDir)
|
!options->BridgeAuthoritativeDir)
|
||||||
rep_hist_desc_stats_term();
|
rep_hist_desc_stats_term();
|
||||||
|
|
||||||
/* Check if we need to parse and add the EntryNodes config option. */
|
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
if (options->EntryNodes &&
|
|
||||||
(!old_options ||
|
|
||||||
!routerset_equal(old_options->EntryNodes,options->EntryNodes) ||
|
|
||||||
!routerset_equal(old_options->ExcludeNodes,options->ExcludeNodes)))
|
|
||||||
entry_nodes_should_be_added();
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Since our options changed, we might need to regenerate and upload our
|
/* Since our options changed, we might need to regenerate and upload our
|
||||||
* server descriptor.
|
* server descriptor.
|
||||||
*/
|
*/
|
||||||
@ -3009,13 +3000,6 @@ options_validate(or_options_t *old_options, or_options_t *options,
|
|||||||
|
|
||||||
warn_about_relative_paths(options);
|
warn_about_relative_paths(options);
|
||||||
|
|
||||||
#ifndef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
if (options->UseDeprecatedGuardAlgorithm) {
|
|
||||||
log_warn(LD_CONFIG, "DeprecatedGuardAlgorithm not supported.");
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
if (server_mode(options) &&
|
if (server_mode(options) &&
|
||||||
(!strcmpstart(uname, "Windows 95") ||
|
(!strcmpstart(uname, "Windows 95") ||
|
||||||
!strcmpstart(uname, "Windows 98") ||
|
!strcmpstart(uname, "Windows 98") ||
|
||||||
|
|||||||
@ -718,11 +718,6 @@ connection_or_about_to_close(or_connection_t *or_conn)
|
|||||||
rep_hist_note_connect_failed(or_conn->identity_digest, now);
|
rep_hist_note_connect_failed(or_conn->identity_digest, now);
|
||||||
/* Tell the new guard API about the channel failure */
|
/* Tell the new guard API about the channel failure */
|
||||||
entry_guard_chan_failed(TLS_CHAN_TO_BASE(or_conn->chan));
|
entry_guard_chan_failed(TLS_CHAN_TO_BASE(or_conn->chan));
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
/* Tell the old guard API about the channel failure */
|
|
||||||
entry_guard_register_connect_status(or_conn->identity_digest,0,
|
|
||||||
!options->HTTPSProxy, now);
|
|
||||||
#endif
|
|
||||||
if (conn->state >= OR_CONN_STATE_TLS_HANDSHAKING) {
|
if (conn->state >= OR_CONN_STATE_TLS_HANDSHAKING) {
|
||||||
int reason = tls_error_to_orconn_end_reason(or_conn->tls_error);
|
int reason = tls_error_to_orconn_end_reason(or_conn->tls_error);
|
||||||
control_event_or_conn_status(or_conn, OR_CONN_EVENT_FAILED,
|
control_event_or_conn_status(or_conn, OR_CONN_EVENT_FAILED,
|
||||||
@ -1728,11 +1723,6 @@ connection_or_client_learned_peer_id(or_connection_t *conn,
|
|||||||
|
|
||||||
/* Tell the new guard API about the channel failure */
|
/* Tell the new guard API about the channel failure */
|
||||||
entry_guard_chan_failed(TLS_CHAN_TO_BASE(conn->chan));
|
entry_guard_chan_failed(TLS_CHAN_TO_BASE(conn->chan));
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
/* Tell the old guard API about the channel failure */
|
|
||||||
entry_guard_register_connect_status(conn->identity_digest, 0, 1,
|
|
||||||
time(NULL));
|
|
||||||
#endif
|
|
||||||
control_event_or_conn_status(conn, OR_CONN_EVENT_FAILED,
|
control_event_or_conn_status(conn, OR_CONN_EVENT_FAILED,
|
||||||
END_OR_CONN_REASON_OR_IDENTITY);
|
END_OR_CONN_REASON_OR_IDENTITY);
|
||||||
if (!authdir_mode_tests_reachability(options))
|
if (!authdir_mode_tests_reachability(options))
|
||||||
|
|||||||
1794
src/or/entrynodes.c
1794
src/or/entrynodes.c
File diff suppressed because it is too large
Load Diff
@ -28,11 +28,6 @@ typedef struct circuit_guard_state_t circuit_guard_state_t;
|
|||||||
private. */
|
private. */
|
||||||
typedef struct entry_guard_restriction_t entry_guard_restriction_t;
|
typedef struct entry_guard_restriction_t entry_guard_restriction_t;
|
||||||
|
|
||||||
/*
|
|
||||||
XXXX Prop271 undefine this in order to disable all legacy guard functions.
|
|
||||||
*/
|
|
||||||
// #define ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
|
|
||||||
/* Information about a guard's pathbias status.
|
/* Information about a guard's pathbias status.
|
||||||
* These fields are used in circpathbias.c to try to detect entry
|
* These fields are used in circpathbias.c to try to detect entry
|
||||||
* nodes that are failing circuits at a suspicious frequency.
|
* nodes that are failing circuits at a suspicious frequency.
|
||||||
@ -179,37 +174,6 @@ struct entry_guard_t {
|
|||||||
guard_selection_t *in_selection;
|
guard_selection_t *in_selection;
|
||||||
/**@}*/
|
/**@}*/
|
||||||
|
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
/**
|
|
||||||
* @name legacy guard selection algorithm fields
|
|
||||||
*
|
|
||||||
* These are used and maintained by the legacy (pre-prop271) entry guard
|
|
||||||
* algorithm. Most of them we will remove as prop271 gets implemented.
|
|
||||||
* The rest we'll migrate over, if they are 100% semantically identical to
|
|
||||||
* their prop271 equivalents. XXXXprop271
|
|
||||||
*/
|
|
||||||
/**@{*/
|
|
||||||
time_t chosen_on_date; /**< Approximately when was this guard added?
|
|
||||||
* "0" if we don't know. */
|
|
||||||
char *chosen_by_version; /**< What tor version added this guard? NULL
|
|
||||||
* if we don't know. */
|
|
||||||
unsigned int made_contact : 1; /**< 0 if we have never connected to this
|
|
||||||
* router, 1 if we have. */
|
|
||||||
unsigned int can_retry : 1; /**< Should we retry connecting to this entry,
|
|
||||||
* in spite of having it marked as unreachable?*/
|
|
||||||
unsigned int is_dir_cache : 1; /**< Is this node a directory cache? */
|
|
||||||
time_t bad_since; /**< 0 if this guard is currently usable, or the time at
|
|
||||||
* which it was observed to become (according to the
|
|
||||||
* directory or the user configuration) unusable. */
|
|
||||||
time_t unreachable_since; /**< 0 if we can connect to this guard, or the
|
|
||||||
* time at which we first noticed we couldn't
|
|
||||||
* connect to it. */
|
|
||||||
time_t last_attempted; /**< 0 if we can connect to this guard, or the time
|
|
||||||
* at which we last failed to connect to it. */
|
|
||||||
|
|
||||||
/**}@*/
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/** Path bias information for this guard. */
|
/** Path bias information for this guard. */
|
||||||
guard_pathbias_t pb;
|
guard_pathbias_t pb;
|
||||||
};
|
};
|
||||||
@ -305,20 +269,6 @@ struct guard_selection_s {
|
|||||||
* confirmed_entry_guards receive? */
|
* confirmed_entry_guards receive? */
|
||||||
int next_confirmed_idx;
|
int next_confirmed_idx;
|
||||||
|
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
/**
|
|
||||||
* A list of our chosen entry guards, as entry_guard_t structures; this
|
|
||||||
* preserves the pre-Prop271 behavior.
|
|
||||||
*/
|
|
||||||
smartlist_t *chosen_entry_guards;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* When we try to choose an entry guard, should we parse and add
|
|
||||||
* config's EntryNodes first? This was formerly a global. This
|
|
||||||
* preserves the pre-Prop271 behavior.
|
|
||||||
*/
|
|
||||||
int should_add_entry_nodes;
|
|
||||||
#endif
|
|
||||||
};
|
};
|
||||||
|
|
||||||
struct entry_guard_handle_t;
|
struct entry_guard_handle_t;
|
||||||
@ -378,11 +328,6 @@ entry_guard_t *entry_guard_get_by_id_digest(const char *digest);
|
|||||||
void entry_guards_changed_for_guard_selection(guard_selection_t *gs);
|
void entry_guards_changed_for_guard_selection(guard_selection_t *gs);
|
||||||
void entry_guards_changed(void);
|
void entry_guards_changed(void);
|
||||||
guard_selection_t * get_guard_selection_info(void);
|
guard_selection_t * get_guard_selection_info(void);
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
const smartlist_t *get_entry_guards_for_guard_selection(
|
|
||||||
guard_selection_t *gs);
|
|
||||||
const smartlist_t *get_entry_guards(void);
|
|
||||||
#endif
|
|
||||||
int num_live_entry_guards_for_guard_selection(
|
int num_live_entry_guards_for_guard_selection(
|
||||||
guard_selection_t *gs,
|
guard_selection_t *gs,
|
||||||
int for_directory);
|
int for_directory);
|
||||||
@ -390,9 +335,6 @@ int num_live_entry_guards(int for_directory);
|
|||||||
#endif
|
#endif
|
||||||
|
|
||||||
const node_t *entry_guard_find_node(const entry_guard_t *guard);
|
const node_t *entry_guard_find_node(const entry_guard_t *guard);
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
void entry_guard_mark_bad(entry_guard_t *guard);
|
|
||||||
#endif
|
|
||||||
const char *entry_guard_get_rsa_id_digest(const entry_guard_t *guard);
|
const char *entry_guard_get_rsa_id_digest(const entry_guard_t *guard);
|
||||||
const char *entry_guard_describe(const entry_guard_t *guard);
|
const char *entry_guard_describe(const entry_guard_t *guard);
|
||||||
guard_pathbias_t *entry_guard_get_pathbias_state(entry_guard_t *guard);
|
guard_pathbias_t *entry_guard_get_pathbias_state(entry_guard_t *guard);
|
||||||
@ -432,10 +374,6 @@ void entry_guards_note_internet_connectivity(guard_selection_t *gs);
|
|||||||
int update_guard_selection_choice(const or_options_t *options);
|
int update_guard_selection_choice(const or_options_t *options);
|
||||||
|
|
||||||
/* Used by bridges.c only. */
|
/* Used by bridges.c only. */
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
void add_bridge_as_entry_guard(guard_selection_t *gs,
|
|
||||||
const node_t *chosen);
|
|
||||||
#endif
|
|
||||||
int num_bridges_usable(void);
|
int num_bridges_usable(void);
|
||||||
|
|
||||||
#ifdef ENTRYNODES_PRIVATE
|
#ifdef ENTRYNODES_PRIVATE
|
||||||
@ -612,68 +550,13 @@ STATIC unsigned entry_guards_note_guard_success(guard_selection_t *gs,
|
|||||||
STATIC int entry_guard_has_higher_priority(entry_guard_t *a, entry_guard_t *b);
|
STATIC int entry_guard_has_higher_priority(entry_guard_t *a, entry_guard_t *b);
|
||||||
STATIC char *getinfo_helper_format_single_entry_guard(const entry_guard_t *e,
|
STATIC char *getinfo_helper_format_single_entry_guard(const entry_guard_t *e,
|
||||||
int is_legacy);
|
int is_legacy);
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
// ---------- XXXX this stuff is pre-prop271.
|
|
||||||
|
|
||||||
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);
|
|
||||||
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);
|
|
||||||
STATIC int decide_num_guards(const or_options_t *options, int for_directory);
|
|
||||||
|
|
||||||
STATIC void entry_guards_set_from_config(guard_selection_t *gs,
|
|
||||||
const or_options_t *options);
|
|
||||||
|
|
||||||
/** Flags to be passed to entry_is_live() to indicate what kind of
|
|
||||||
* entry nodes we are looking for. */
|
|
||||||
typedef enum {
|
|
||||||
ENTRY_NEED_UPTIME = 1<<0,
|
|
||||||
ENTRY_NEED_CAPACITY = 1<<1,
|
|
||||||
ENTRY_ASSUME_REACHABLE = 1<<2,
|
|
||||||
ENTRY_NEED_DESCRIPTOR = 1<<3,
|
|
||||||
} entry_is_live_flags_t;
|
|
||||||
|
|
||||||
STATIC const node_t *entry_is_live(const entry_guard_t *e,
|
|
||||||
entry_is_live_flags_t flags,
|
|
||||||
const char **msg);
|
|
||||||
|
|
||||||
STATIC int entry_is_time_to_retry(const entry_guard_t *e, time_t now);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
void remove_all_entry_guards_for_guard_selection(guard_selection_t *gs);
|
|
||||||
void remove_all_entry_guards(void);
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
struct bridge_info_t;
|
struct bridge_info_t;
|
||||||
void entry_guard_learned_bridge_identity(const tor_addr_port_t *addrport,
|
void entry_guard_learned_bridge_identity(const tor_addr_port_t *addrport,
|
||||||
const uint8_t *rsa_id_digest);
|
const uint8_t *rsa_id_digest);
|
||||||
|
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
void entry_guards_compute_status_for_guard_selection(
|
|
||||||
guard_selection_t *gs, const or_options_t *options, time_t now);
|
|
||||||
void entry_guards_compute_status(const or_options_t *options, time_t now);
|
|
||||||
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 entry_guard_register_connect_status(const char *digest, int succeeded,
|
|
||||||
int mark_relay_status, time_t now);
|
|
||||||
void entry_nodes_should_be_added_for_guard_selection(guard_selection_t *gs);
|
|
||||||
void entry_nodes_should_be_added(void);
|
|
||||||
#endif
|
|
||||||
int entry_list_is_constrained(const or_options_t *options);
|
int entry_list_is_constrained(const or_options_t *options);
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
const node_t *choose_random_entry(cpath_build_state_t *state);
|
|
||||||
const node_t *choose_random_dirguard(dirinfo_type_t t);
|
|
||||||
#endif
|
|
||||||
int guards_retry_optimistic(const or_options_t *options);
|
int guards_retry_optimistic(const or_options_t *options);
|
||||||
int entry_guards_parse_state_for_guard_selection(
|
int entry_guards_parse_state_for_guard_selection(
|
||||||
guard_selection_t *gs, or_state_t *state, int set, char **msg);
|
guard_selection_t *gs, or_state_t *state, int set, char **msg);
|
||||||
@ -682,11 +565,6 @@ void entry_guards_update_state(or_state_t *state);
|
|||||||
int getinfo_helper_entry_guards(control_connection_t *conn,
|
int getinfo_helper_entry_guards(control_connection_t *conn,
|
||||||
const char *question, char **answer,
|
const char *question, char **answer,
|
||||||
const char **errmsg);
|
const char **errmsg);
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
int is_node_used_as_guard_for_guard_selection(guard_selection_t *gs,
|
|
||||||
const node_t *node);
|
|
||||||
MOCK_DECL(int, is_node_used_as_guard, (const node_t *node));
|
|
||||||
#endif
|
|
||||||
|
|
||||||
int entries_known_but_down(const or_options_t *options);
|
int entries_known_but_down(const or_options_t *options);
|
||||||
void entries_retry_all(const or_options_t *options);
|
void entries_retry_all(const or_options_t *options);
|
||||||
|
|||||||
@ -1999,10 +1999,7 @@ router_pick_directory_server_impl(dirinfo_type_t type, int flags,
|
|||||||
const int for_guard = (flags & PDS_FOR_GUARD);
|
const int for_guard = (flags & PDS_FOR_GUARD);
|
||||||
int try_excluding = 1, n_excluded = 0, n_busy = 0;
|
int try_excluding = 1, n_excluded = 0, n_busy = 0;
|
||||||
int try_ip_pref = 1;
|
int try_ip_pref = 1;
|
||||||
|
tor_assert_nonfatal(! for_guard); // XXXX prop271
|
||||||
#ifndef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
tor_assert_nonfatal(! for_guard);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
if (!consensus)
|
if (!consensus)
|
||||||
return NULL;
|
return NULL;
|
||||||
@ -2036,12 +2033,6 @@ router_pick_directory_server_impl(dirinfo_type_t type, int flags,
|
|||||||
|
|
||||||
SKIP_MISSING_TRUSTED_EXTRAINFO(type, node->identity);
|
SKIP_MISSING_TRUSTED_EXTRAINFO(type, node->identity);
|
||||||
|
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
/* Don't make the same node a guard twice */
|
|
||||||
if (for_guard && is_node_used_as_guard(node)) {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
/* Ensure that a directory guard is actually a guard node. */
|
/* Ensure that a directory guard is actually a guard node. */
|
||||||
if (for_guard && !node->is_possible_guard) {
|
if (for_guard && !node->is_possible_guard) {
|
||||||
continue;
|
continue;
|
||||||
|
|||||||
@ -45,41 +45,6 @@ get_or_state_replacement(void)
|
|||||||
return dummy_state;
|
return dummy_state;
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
/* Unittest cleanup function: Cleanup the fake network. */
|
|
||||||
static int
|
|
||||||
fake_network_cleanup(const struct testcase_t *testcase, void *ptr)
|
|
||||||
{
|
|
||||||
(void) testcase;
|
|
||||||
(void) ptr;
|
|
||||||
|
|
||||||
routerlist_free_all();
|
|
||||||
nodelist_free_all();
|
|
||||||
entry_guards_free_all();
|
|
||||||
or_state_free(dummy_state);
|
|
||||||
|
|
||||||
return 1; /* NOP */
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Unittest setup function: Setup a fake network. */
|
|
||||||
static void *
|
|
||||||
fake_network_setup(const struct testcase_t *testcase)
|
|
||||||
{
|
|
||||||
(void) testcase;
|
|
||||||
|
|
||||||
/* Setup fake state */
|
|
||||||
dummy_state = tor_malloc_zero(sizeof(or_state_t));
|
|
||||||
MOCK(get_or_state,
|
|
||||||
get_or_state_replacement);
|
|
||||||
|
|
||||||
/* Setup fake routerlist. */
|
|
||||||
helper_setup_fake_routerlist();
|
|
||||||
|
|
||||||
/* Return anything but NULL (it's interpreted as test fail) */
|
|
||||||
return dummy_state;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
static networkstatus_t *dummy_consensus = NULL;
|
static networkstatus_t *dummy_consensus = NULL;
|
||||||
|
|
||||||
static smartlist_t *big_fake_net_nodes = NULL;
|
static smartlist_t *big_fake_net_nodes = NULL;
|
||||||
@ -202,697 +167,6 @@ mock_get_options(void)
|
|||||||
return &mocked_options;
|
return &mocked_options;
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
/** Test choose_random_entry() with none of our routers being guard nodes. */
|
|
||||||
static void
|
|
||||||
test_choose_random_entry_no_guards(void *arg)
|
|
||||||
{
|
|
||||||
const node_t *chosen_entry = NULL;
|
|
||||||
|
|
||||||
(void) arg;
|
|
||||||
|
|
||||||
MOCK(get_options, mock_get_options);
|
|
||||||
|
|
||||||
/* Check that we get a guard if it passes preferred
|
|
||||||
* address settings */
|
|
||||||
memset(&mocked_options, 0, sizeof(mocked_options));
|
|
||||||
mocked_options.ClientUseIPv4 = 1;
|
|
||||||
mocked_options.ClientPreferIPv6ORPort = 0;
|
|
||||||
mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
||||||
|
|
||||||
/* Try to pick an entry even though none of our routers are guards. */
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
|
|
||||||
/* Unintuitively, we actually pick a random node as our entry,
|
|
||||||
because router_choose_random_node() relaxes its constraints if it
|
|
||||||
can't find a proper entry guard. */
|
|
||||||
tt_assert(chosen_entry);
|
|
||||||
|
|
||||||
/* And with the other IP version active */
|
|
||||||
mocked_options.ClientUseIPv6 = 1;
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
tt_assert(chosen_entry);
|
|
||||||
|
|
||||||
/* And with the preference on auto */
|
|
||||||
mocked_options.ClientPreferIPv6ORPort = -1;
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
tt_assert(chosen_entry);
|
|
||||||
|
|
||||||
/* Check that we don't get a guard if it doesn't pass mandatory address
|
|
||||||
* settings */
|
|
||||||
memset(&mocked_options, 0, sizeof(mocked_options));
|
|
||||||
mocked_options.ClientUseIPv4 = 0;
|
|
||||||
mocked_options.ClientPreferIPv6ORPort = 0;
|
|
||||||
mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
||||||
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
|
|
||||||
/* If we don't allow IPv4 at all, we don't get a guard*/
|
|
||||||
tt_assert(!chosen_entry);
|
|
||||||
|
|
||||||
/* Check that we get a guard if it passes allowed but not preferred address
|
|
||||||
* settings */
|
|
||||||
memset(&mocked_options, 0, sizeof(mocked_options));
|
|
||||||
mocked_options.ClientUseIPv4 = 1;
|
|
||||||
mocked_options.ClientUseIPv6 = 1;
|
|
||||||
mocked_options.ClientPreferIPv6ORPort = 1;
|
|
||||||
mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
||||||
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
tt_assert(chosen_entry);
|
|
||||||
|
|
||||||
/* Check that we get a guard if it passes preferred address settings when
|
|
||||||
* they're auto */
|
|
||||||
memset(&mocked_options, 0, sizeof(mocked_options));
|
|
||||||
mocked_options.ClientUseIPv4 = 1;
|
|
||||||
mocked_options.ClientPreferIPv6ORPort = -1;
|
|
||||||
mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
||||||
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
tt_assert(chosen_entry);
|
|
||||||
|
|
||||||
/* And with IPv6 active */
|
|
||||||
mocked_options.ClientUseIPv6 = 1;
|
|
||||||
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
tt_assert(chosen_entry);
|
|
||||||
|
|
||||||
done:
|
|
||||||
memset(&mocked_options, 0, sizeof(mocked_options));
|
|
||||||
UNMOCK(get_options);
|
|
||||||
}
|
|
||||||
|
|
||||||
/** Test choose_random_entry() with only one of our routers being a
|
|
||||||
guard node. */
|
|
||||||
static void
|
|
||||||
test_choose_random_entry_one_possible_guard(void *arg)
|
|
||||||
{
|
|
||||||
const node_t *chosen_entry = NULL;
|
|
||||||
node_t *the_guard = NULL;
|
|
||||||
smartlist_t *our_nodelist = NULL;
|
|
||||||
|
|
||||||
(void) arg;
|
|
||||||
|
|
||||||
MOCK(get_options, mock_get_options);
|
|
||||||
|
|
||||||
/* Set one of the nodes to be a guard. */
|
|
||||||
our_nodelist = nodelist_get_list();
|
|
||||||
the_guard = smartlist_get(our_nodelist, 4); /* chosen by fair dice roll */
|
|
||||||
the_guard->is_possible_guard = 1;
|
|
||||||
|
|
||||||
/* Check that we get the guard if it passes preferred
|
|
||||||
* address settings */
|
|
||||||
memset(&mocked_options, 0, sizeof(mocked_options));
|
|
||||||
mocked_options.ClientUseIPv4 = 1;
|
|
||||||
mocked_options.ClientPreferIPv6ORPort = 0;
|
|
||||||
mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
||||||
|
|
||||||
/* Pick an entry. Make sure we pick the node we marked as guard. */
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
tt_ptr_op(chosen_entry, OP_EQ, the_guard);
|
|
||||||
|
|
||||||
/* And with the other IP version active */
|
|
||||||
mocked_options.ClientUseIPv6 = 1;
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
tt_ptr_op(chosen_entry, OP_EQ, the_guard);
|
|
||||||
|
|
||||||
/* And with the preference on auto */
|
|
||||||
mocked_options.ClientPreferIPv6ORPort = -1;
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
tt_ptr_op(chosen_entry, OP_EQ, the_guard);
|
|
||||||
|
|
||||||
/* Check that we don't get a guard if it doesn't pass mandatory address
|
|
||||||
* settings */
|
|
||||||
memset(&mocked_options, 0, sizeof(mocked_options));
|
|
||||||
mocked_options.ClientUseIPv4 = 0;
|
|
||||||
mocked_options.ClientPreferIPv6ORPort = 0;
|
|
||||||
mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
||||||
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
|
|
||||||
/* If we don't allow IPv4 at all, we don't get a guard*/
|
|
||||||
tt_assert(!chosen_entry);
|
|
||||||
|
|
||||||
/* Check that we get a node if it passes allowed but not preferred
|
|
||||||
* address settings */
|
|
||||||
memset(&mocked_options, 0, sizeof(mocked_options));
|
|
||||||
mocked_options.ClientUseIPv4 = 1;
|
|
||||||
mocked_options.ClientUseIPv6 = 1;
|
|
||||||
mocked_options.ClientPreferIPv6ORPort = 1;
|
|
||||||
mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
||||||
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
|
|
||||||
/* We disable the guard check and the preferred address check at the same
|
|
||||||
* time, so we can't be sure we get the guard */
|
|
||||||
tt_assert(chosen_entry);
|
|
||||||
|
|
||||||
/* Check that we get a node if it is allowed but not preferred when settings
|
|
||||||
* are auto */
|
|
||||||
memset(&mocked_options, 0, sizeof(mocked_options));
|
|
||||||
mocked_options.ClientUseIPv4 = 1;
|
|
||||||
mocked_options.ClientPreferIPv6ORPort = -1;
|
|
||||||
mocked_options.UseDeprecatedGuardAlgorithm = 1;
|
|
||||||
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
|
|
||||||
/* We disable the guard check and the preferred address check at the same
|
|
||||||
* time, so we can't be sure we get the guard */
|
|
||||||
tt_assert(chosen_entry);
|
|
||||||
|
|
||||||
/* and with IPv6 active */
|
|
||||||
mocked_options.ClientUseIPv6 = 1;
|
|
||||||
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
tt_assert(chosen_entry);
|
|
||||||
|
|
||||||
done:
|
|
||||||
memset(&mocked_options, 0, sizeof(mocked_options));
|
|
||||||
UNMOCK(get_options);
|
|
||||||
}
|
|
||||||
|
|
||||||
/** Helper to conduct tests for populate_live_entry_guards().
|
|
||||||
|
|
||||||
This test adds some entry guards to our list, and then tests
|
|
||||||
populate_live_entry_guards() to mke sure it filters them correctly.
|
|
||||||
|
|
||||||
<b>num_needed</b> is the number of guard nodes we support. It's
|
|
||||||
configurable to make sure we function properly with 1 or 3 guard
|
|
||||||
nodes configured.
|
|
||||||
*/
|
|
||||||
static void
|
|
||||||
populate_live_entry_guards_test_helper(int num_needed)
|
|
||||||
{
|
|
||||||
smartlist_t *our_nodelist = NULL;
|
|
||||||
smartlist_t *live_entry_guards = smartlist_new();
|
|
||||||
guard_selection_t *gs = get_guard_selection_info();
|
|
||||||
const smartlist_t *all_entry_guards =
|
|
||||||
get_entry_guards_for_guard_selection(gs);
|
|
||||||
or_options_t *options = get_options_mutable();
|
|
||||||
int retval;
|
|
||||||
|
|
||||||
/* Set NumEntryGuards to the provided number. */
|
|
||||||
options->NumEntryGuards = num_needed;
|
|
||||||
tt_int_op(num_needed, OP_EQ, decide_num_guards(options, 0));
|
|
||||||
|
|
||||||
/* The global entry guards smartlist should be empty now. */
|
|
||||||
tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);
|
|
||||||
|
|
||||||
/* Walk the nodelist and add all nodes as entry guards. */
|
|
||||||
our_nodelist = nodelist_get_list();
|
|
||||||
tt_int_op(smartlist_len(our_nodelist), OP_EQ, HELPER_NUMBER_OF_DESCRIPTORS);
|
|
||||||
|
|
||||||
SMARTLIST_FOREACH_BEGIN(our_nodelist, const node_t *, node) {
|
|
||||||
const node_t *node_tmp;
|
|
||||||
node_tmp = add_an_entry_guard(gs, node, 0, 1, 0, 0);
|
|
||||||
tt_assert(node_tmp);
|
|
||||||
} SMARTLIST_FOREACH_END(node);
|
|
||||||
|
|
||||||
/* Make sure the nodes were added as entry guards. */
|
|
||||||
tt_int_op(smartlist_len(all_entry_guards), OP_EQ,
|
|
||||||
HELPER_NUMBER_OF_DESCRIPTORS);
|
|
||||||
|
|
||||||
/* Ensure that all the possible entry guards are enough to satisfy us. */
|
|
||||||
tt_int_op(smartlist_len(all_entry_guards), OP_GE, num_needed);
|
|
||||||
|
|
||||||
/* Walk the entry guard list for some sanity checking */
|
|
||||||
SMARTLIST_FOREACH_BEGIN(all_entry_guards, const entry_guard_t *, entry) {
|
|
||||||
/* Since we called add_an_entry_guard() with 'for_discovery' being
|
|
||||||
False, all guards should have made_contact enabled. */
|
|
||||||
tt_int_op(entry->made_contact, OP_EQ, 1);
|
|
||||||
|
|
||||||
} SMARTLIST_FOREACH_END(entry);
|
|
||||||
|
|
||||||
/* First, try to get some fast guards. This should fail. */
|
|
||||||
retval = populate_live_entry_guards(live_entry_guards,
|
|
||||||
all_entry_guards,
|
|
||||||
NULL,
|
|
||||||
NO_DIRINFO, /* Don't care about DIRINFO*/
|
|
||||||
0, 0,
|
|
||||||
1); /* We want fast guard! */
|
|
||||||
tt_int_op(retval, OP_EQ, 0);
|
|
||||||
tt_int_op(smartlist_len(live_entry_guards), OP_EQ, 0);
|
|
||||||
|
|
||||||
/* Now try to get some stable guards. This should fail too. */
|
|
||||||
retval = populate_live_entry_guards(live_entry_guards,
|
|
||||||
all_entry_guards,
|
|
||||||
NULL,
|
|
||||||
NO_DIRINFO,
|
|
||||||
0,
|
|
||||||
1, /* We want stable guard! */
|
|
||||||
0);
|
|
||||||
tt_int_op(retval, OP_EQ, 0);
|
|
||||||
tt_int_op(smartlist_len(live_entry_guards), OP_EQ, 0);
|
|
||||||
|
|
||||||
/* Now try to get any guard we can find. This should succeed. */
|
|
||||||
retval = populate_live_entry_guards(live_entry_guards,
|
|
||||||
all_entry_guards,
|
|
||||||
NULL,
|
|
||||||
NO_DIRINFO,
|
|
||||||
0, 0, 0); /* No restrictions! */
|
|
||||||
|
|
||||||
/* Since we had more than enough guards in 'all_entry_guards', we
|
|
||||||
should have added 'num_needed' of them to live_entry_guards.
|
|
||||||
'retval' should be 1 since we now have enough live entry guards
|
|
||||||
to pick one. */
|
|
||||||
tt_int_op(retval, OP_EQ, 1);
|
|
||||||
tt_int_op(smartlist_len(live_entry_guards), OP_EQ, num_needed);
|
|
||||||
|
|
||||||
done:
|
|
||||||
smartlist_free(live_entry_guards);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Test populate_live_entry_guards() for 1 guard node. */
|
|
||||||
static void
|
|
||||||
test_populate_live_entry_guards_1guard(void *arg)
|
|
||||||
{
|
|
||||||
(void) arg;
|
|
||||||
|
|
||||||
populate_live_entry_guards_test_helper(1);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Test populate_live_entry_guards() for 3 guard nodes. */
|
|
||||||
static void
|
|
||||||
test_populate_live_entry_guards_3guards(void *arg)
|
|
||||||
{
|
|
||||||
(void) arg;
|
|
||||||
|
|
||||||
populate_live_entry_guards_test_helper(3);
|
|
||||||
}
|
|
||||||
|
|
||||||
/** Append some EntryGuard lines to the Tor state at <b>state</b>.
|
|
||||||
|
|
||||||
<b>entry_guard_lines</b> is a smartlist containing 2-tuple
|
|
||||||
smartlists that carry the key and values of the statefile.
|
|
||||||
As an example:
|
|
||||||
entry_guard_lines =
|
|
||||||
(("EntryGuard", "name 67E72FF33D7D41BF11C569646A0A7B4B188340DF DirCache"),
|
|
||||||
("EntryGuardDownSince", "2014-06-07 16:02:46 2014-06-07 16:02:46"))
|
|
||||||
*/
|
|
||||||
static void
|
|
||||||
state_insert_entry_guard_helper(or_state_t *state,
|
|
||||||
smartlist_t *entry_guard_lines)
|
|
||||||
{
|
|
||||||
config_line_t **next, *line;
|
|
||||||
|
|
||||||
next = &state->EntryGuards;
|
|
||||||
*next = NULL;
|
|
||||||
|
|
||||||
/* Loop over all the state lines in the smartlist */
|
|
||||||
SMARTLIST_FOREACH_BEGIN(entry_guard_lines, const smartlist_t *,state_lines) {
|
|
||||||
/* Get key and value for each line */
|
|
||||||
const char *state_key = smartlist_get(state_lines, 0);
|
|
||||||
const char *state_value = smartlist_get(state_lines, 1);
|
|
||||||
|
|
||||||
*next = line = tor_malloc_zero(sizeof(config_line_t));
|
|
||||||
line->key = tor_strdup(state_key);
|
|
||||||
tor_asprintf(&line->value, "%s", state_value);
|
|
||||||
next = &(line->next);
|
|
||||||
} SMARTLIST_FOREACH_END(state_lines);
|
|
||||||
}
|
|
||||||
|
|
||||||
/** Free memory occupied by <b>entry_guard_lines</b>. */
|
|
||||||
static void
|
|
||||||
state_lines_free(smartlist_t *entry_guard_lines)
|
|
||||||
{
|
|
||||||
SMARTLIST_FOREACH_BEGIN(entry_guard_lines, smartlist_t *, state_lines) {
|
|
||||||
char *state_key = smartlist_get(state_lines, 0);
|
|
||||||
char *state_value = smartlist_get(state_lines, 1);
|
|
||||||
|
|
||||||
tor_free(state_key);
|
|
||||||
tor_free(state_value);
|
|
||||||
smartlist_free(state_lines);
|
|
||||||
} SMARTLIST_FOREACH_END(state_lines);
|
|
||||||
|
|
||||||
smartlist_free(entry_guard_lines);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Tests entry_guards_parse_state(). It creates a fake Tor state with
|
|
||||||
a saved entry guard and makes sure that Tor can parse it and
|
|
||||||
creates the right entry node out of it.
|
|
||||||
*/
|
|
||||||
static void
|
|
||||||
test_entry_guards_parse_state_simple(void *arg)
|
|
||||||
{
|
|
||||||
or_options_t *options = get_options_mutable();
|
|
||||||
options->UseDeprecatedGuardAlgorithm = 1;
|
|
||||||
or_state_t *state = or_state_new();
|
|
||||||
const smartlist_t *all_entry_guards = get_entry_guards();
|
|
||||||
smartlist_t *entry_state_lines = smartlist_new();
|
|
||||||
char *msg = NULL;
|
|
||||||
int retval;
|
|
||||||
|
|
||||||
/* Details of our fake guard node */
|
|
||||||
const char *nickname = "hagbard";
|
|
||||||
const char *fpr = "B29D536DD1752D542E1FBB3C9CE4449D51298212";
|
|
||||||
const char *tor_version = "0.2.5.3-alpha-dev";
|
|
||||||
const char *added_at = get_yesterday_date_str();
|
|
||||||
const char *unlisted_since = "2014-06-08 16:16:50";
|
|
||||||
|
|
||||||
(void) arg;
|
|
||||||
|
|
||||||
/* The global entry guards smartlist should be empty now. */
|
|
||||||
tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);
|
|
||||||
|
|
||||||
{ /* Prepare the state entry */
|
|
||||||
|
|
||||||
/* Prepare the smartlist to hold the key/value of each line */
|
|
||||||
smartlist_t *state_line = smartlist_new();
|
|
||||||
smartlist_add_asprintf(state_line, "EntryGuard");
|
|
||||||
smartlist_add_asprintf(state_line, "%s %s %s", nickname, fpr, "DirCache");
|
|
||||||
smartlist_add(entry_state_lines, state_line);
|
|
||||||
|
|
||||||
state_line = smartlist_new();
|
|
||||||
smartlist_add_asprintf(state_line, "EntryGuardAddedBy");
|
|
||||||
smartlist_add_asprintf(state_line, "%s %s %s", fpr, tor_version, added_at);
|
|
||||||
smartlist_add(entry_state_lines, state_line);
|
|
||||||
|
|
||||||
state_line = smartlist_new();
|
|
||||||
smartlist_add_asprintf(state_line, "EntryGuardUnlistedSince");
|
|
||||||
smartlist_add_asprintf(state_line, "%s", unlisted_since);
|
|
||||||
smartlist_add(entry_state_lines, state_line);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Inject our lines in the state */
|
|
||||||
state_insert_entry_guard_helper(state, entry_state_lines);
|
|
||||||
|
|
||||||
/* Parse state */
|
|
||||||
retval = entry_guards_parse_state(state, 1, &msg);
|
|
||||||
tt_int_op(retval, OP_GE, 0);
|
|
||||||
|
|
||||||
/* Test that the guard was registered.
|
|
||||||
We need to re-get the entry guard list since its pointer was
|
|
||||||
overwritten in entry_guards_parse_state(). */
|
|
||||||
all_entry_guards = get_entry_guards();
|
|
||||||
tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 1);
|
|
||||||
|
|
||||||
{ /* Test the entry guard structure */
|
|
||||||
char hex_digest[1024];
|
|
||||||
char str_time[1024];
|
|
||||||
|
|
||||||
const entry_guard_t *e = smartlist_get(all_entry_guards, 0);
|
|
||||||
tt_str_op(e->nickname, OP_EQ, nickname); /* Verify nickname */
|
|
||||||
|
|
||||||
base16_encode(hex_digest, sizeof(hex_digest),
|
|
||||||
e->identity, DIGEST_LEN);
|
|
||||||
tt_str_op(hex_digest, OP_EQ, fpr); /* Verify fingerprint */
|
|
||||||
|
|
||||||
tt_assert(e->is_dir_cache); /* Verify dirness */
|
|
||||||
|
|
||||||
tt_str_op(e->chosen_by_version, OP_EQ, tor_version); /* Verify version */
|
|
||||||
|
|
||||||
tt_assert(e->made_contact); /* All saved guards have been contacted */
|
|
||||||
|
|
||||||
tt_assert(e->bad_since); /* Verify bad_since timestamp */
|
|
||||||
format_iso_time(str_time, e->bad_since);
|
|
||||||
tt_str_op(str_time, OP_EQ, unlisted_since);
|
|
||||||
|
|
||||||
/* The rest should be unset */
|
|
||||||
tt_assert(!e->unreachable_since);
|
|
||||||
tt_assert(!e->can_retry);
|
|
||||||
tt_assert(!e->pb.path_bias_noticed);
|
|
||||||
tt_assert(!e->pb.path_bias_warned);
|
|
||||||
tt_assert(!e->pb.path_bias_extreme);
|
|
||||||
tt_assert(!e->pb.path_bias_disabled);
|
|
||||||
tt_assert(!e->pb.path_bias_use_noticed);
|
|
||||||
tt_assert(!e->pb.path_bias_use_extreme);
|
|
||||||
tt_assert(!e->last_attempted);
|
|
||||||
}
|
|
||||||
|
|
||||||
done:
|
|
||||||
state_lines_free(entry_state_lines);
|
|
||||||
or_state_free(state);
|
|
||||||
tor_free(msg);
|
|
||||||
}
|
|
||||||
|
|
||||||
/** Similar to test_entry_guards_parse_state_simple() but aims to test
|
|
||||||
the PathBias-related details of the entry guard. */
|
|
||||||
static void
|
|
||||||
test_entry_guards_parse_state_pathbias(void *arg)
|
|
||||||
{
|
|
||||||
or_options_t *options = get_options_mutable();
|
|
||||||
options->UseDeprecatedGuardAlgorithm = 1;
|
|
||||||
or_state_t *state = or_state_new();
|
|
||||||
const smartlist_t *all_entry_guards = get_entry_guards();
|
|
||||||
char *msg = NULL;
|
|
||||||
int retval;
|
|
||||||
smartlist_t *entry_state_lines = smartlist_new();
|
|
||||||
|
|
||||||
/* Path bias details of the fake guard */
|
|
||||||
const double circ_attempts = 9;
|
|
||||||
const double circ_successes = 8;
|
|
||||||
const double successful_closed = 4;
|
|
||||||
const double collapsed = 2;
|
|
||||||
const double unusable = 0;
|
|
||||||
const double timeouts = 1;
|
|
||||||
|
|
||||||
(void) arg;
|
|
||||||
|
|
||||||
/* The global entry guards smartlist should be empty now. */
|
|
||||||
tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);
|
|
||||||
|
|
||||||
{ /* Prepare the state entry */
|
|
||||||
|
|
||||||
/* Prepare the smartlist to hold the key/value of each line */
|
|
||||||
smartlist_t *state_line = smartlist_new();
|
|
||||||
smartlist_add_asprintf(state_line, "EntryGuard");
|
|
||||||
smartlist_add_asprintf(state_line,
|
|
||||||
"givethanks B29D536DD1752D542E1FBB3C9CE4449D51298212 NoDirCache");
|
|
||||||
smartlist_add(entry_state_lines, state_line);
|
|
||||||
|
|
||||||
state_line = smartlist_new();
|
|
||||||
smartlist_add_asprintf(state_line, "EntryGuardAddedBy");
|
|
||||||
smartlist_add_asprintf(state_line,
|
|
||||||
"B29D536DD1752D542E1FBB3C9CE4449D51298212 0.2.5.3-alpha-dev "
|
|
||||||
"%s", get_yesterday_date_str());
|
|
||||||
smartlist_add(entry_state_lines, state_line);
|
|
||||||
|
|
||||||
state_line = smartlist_new();
|
|
||||||
smartlist_add_asprintf(state_line, "EntryGuardUnlistedSince");
|
|
||||||
smartlist_add_asprintf(state_line, "2014-06-08 16:16:50");
|
|
||||||
smartlist_add(entry_state_lines, state_line);
|
|
||||||
|
|
||||||
state_line = smartlist_new();
|
|
||||||
smartlist_add_asprintf(state_line, "EntryGuardPathBias");
|
|
||||||
smartlist_add_asprintf(state_line, "%f %f %f %f %f %f",
|
|
||||||
circ_attempts, circ_successes, successful_closed,
|
|
||||||
collapsed, unusable, timeouts);
|
|
||||||
smartlist_add(entry_state_lines, state_line);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Inject our lines in the state */
|
|
||||||
state_insert_entry_guard_helper(state, entry_state_lines);
|
|
||||||
|
|
||||||
/* Parse state */
|
|
||||||
retval = entry_guards_parse_state(state, 1, &msg);
|
|
||||||
tt_int_op(retval, OP_GE, 0);
|
|
||||||
|
|
||||||
/* Test that the guard was registered */
|
|
||||||
all_entry_guards = get_entry_guards();
|
|
||||||
tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 1);
|
|
||||||
|
|
||||||
{ /* Test the path bias of this guard */
|
|
||||||
const entry_guard_t *e = smartlist_get(all_entry_guards, 0);
|
|
||||||
|
|
||||||
tt_assert(!e->is_dir_cache);
|
|
||||||
tt_assert(!e->can_retry);
|
|
||||||
|
|
||||||
/* XXX tt_double_op doesn't support equality. Cast to int for now. */
|
|
||||||
tt_int_op((int)e->pb.circ_attempts, OP_EQ, (int)circ_attempts);
|
|
||||||
tt_int_op((int)e->pb.circ_successes, OP_EQ, (int)circ_successes);
|
|
||||||
tt_int_op((int)e->pb.successful_circuits_closed, OP_EQ,
|
|
||||||
(int)successful_closed);
|
|
||||||
tt_int_op((int)e->pb.timeouts, OP_EQ, (int)timeouts);
|
|
||||||
tt_int_op((int)e->pb.collapsed_circuits, OP_EQ, (int)collapsed);
|
|
||||||
tt_int_op((int)e->pb.unusable_circuits, OP_EQ, (int)unusable);
|
|
||||||
}
|
|
||||||
|
|
||||||
done:
|
|
||||||
or_state_free(state);
|
|
||||||
state_lines_free(entry_state_lines);
|
|
||||||
tor_free(msg);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Simple test of entry_guards_set_from_config() by specifying a
|
|
||||||
particular EntryNode and making sure it gets picked. */
|
|
||||||
static void
|
|
||||||
test_entry_guards_set_from_config(void *arg)
|
|
||||||
{
|
|
||||||
or_options_t *options = get_options_mutable();
|
|
||||||
options->UseDeprecatedGuardAlgorithm = 1;
|
|
||||||
guard_selection_t *gs = get_guard_selection_info();
|
|
||||||
const smartlist_t *all_entry_guards =
|
|
||||||
get_entry_guards_for_guard_selection(gs);
|
|
||||||
const char *entrynodes_str = "test003r";
|
|
||||||
const node_t *chosen_entry = NULL;
|
|
||||||
int retval;
|
|
||||||
|
|
||||||
(void) arg;
|
|
||||||
|
|
||||||
/* Prase EntryNodes as a routerset. */
|
|
||||||
options->EntryNodes = routerset_new();
|
|
||||||
retval = routerset_parse(options->EntryNodes,
|
|
||||||
entrynodes_str,
|
|
||||||
"test_entrynodes");
|
|
||||||
tt_int_op(retval, OP_GE, 0);
|
|
||||||
|
|
||||||
/* Read nodes from EntryNodes */
|
|
||||||
entry_guards_set_from_config(gs, options);
|
|
||||||
|
|
||||||
/* Test that only one guard was added. */
|
|
||||||
tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 1);
|
|
||||||
|
|
||||||
/* Make sure it was the guard we specified. */
|
|
||||||
chosen_entry = choose_random_entry(NULL);
|
|
||||||
tt_str_op(chosen_entry->ri->nickname, OP_EQ, entrynodes_str);
|
|
||||||
|
|
||||||
done:
|
|
||||||
routerset_free(options->EntryNodes);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
|
||||||
test_entry_is_time_to_retry(void *arg)
|
|
||||||
{
|
|
||||||
entry_guard_t *test_guard;
|
|
||||||
time_t now;
|
|
||||||
int retval;
|
|
||||||
(void)arg;
|
|
||||||
|
|
||||||
now = time(NULL);
|
|
||||||
|
|
||||||
test_guard = tor_malloc_zero(sizeof(entry_guard_t));
|
|
||||||
|
|
||||||
test_guard->last_attempted = now - 10;
|
|
||||||
test_guard->unreachable_since = now - 1;
|
|
||||||
|
|
||||||
retval = entry_is_time_to_retry(test_guard,now);
|
|
||||||
tt_int_op(retval,OP_EQ,1);
|
|
||||||
|
|
||||||
test_guard->unreachable_since = now - (6*60*60 - 1);
|
|
||||||
test_guard->last_attempted = now - (60*60 + 1);
|
|
||||||
|
|
||||||
retval = entry_is_time_to_retry(test_guard,now);
|
|
||||||
tt_int_op(retval,OP_EQ,1);
|
|
||||||
|
|
||||||
test_guard->last_attempted = now - (60*60 - 1);
|
|
||||||
|
|
||||||
retval = entry_is_time_to_retry(test_guard,now);
|
|
||||||
tt_int_op(retval,OP_EQ,0);
|
|
||||||
|
|
||||||
test_guard->unreachable_since = now - (6*60*60 + 1);
|
|
||||||
test_guard->last_attempted = now - (4*60*60 + 1);
|
|
||||||
|
|
||||||
retval = entry_is_time_to_retry(test_guard,now);
|
|
||||||
tt_int_op(retval,OP_EQ,1);
|
|
||||||
|
|
||||||
test_guard->unreachable_since = now - (3*24*60*60 - 1);
|
|
||||||
test_guard->last_attempted = now - (4*60*60 + 1);
|
|
||||||
|
|
||||||
retval = entry_is_time_to_retry(test_guard,now);
|
|
||||||
tt_int_op(retval,OP_EQ,1);
|
|
||||||
|
|
||||||
test_guard->unreachable_since = now - (3*24*60*60 + 1);
|
|
||||||
test_guard->last_attempted = now - (18*60*60 + 1);
|
|
||||||
|
|
||||||
retval = entry_is_time_to_retry(test_guard,now);
|
|
||||||
tt_int_op(retval,OP_EQ,1);
|
|
||||||
|
|
||||||
test_guard->unreachable_since = now - (7*24*60*60 - 1);
|
|
||||||
test_guard->last_attempted = now - (18*60*60 + 1);
|
|
||||||
|
|
||||||
retval = entry_is_time_to_retry(test_guard,now);
|
|
||||||
tt_int_op(retval,OP_EQ,1);
|
|
||||||
|
|
||||||
test_guard->last_attempted = now - (18*60*60 - 1);
|
|
||||||
|
|
||||||
retval = entry_is_time_to_retry(test_guard,now);
|
|
||||||
tt_int_op(retval,OP_EQ,0);
|
|
||||||
|
|
||||||
test_guard->unreachable_since = now - (7*24*60*60 + 1);
|
|
||||||
test_guard->last_attempted = now - (36*60*60 + 1);
|
|
||||||
|
|
||||||
retval = entry_is_time_to_retry(test_guard,now);
|
|
||||||
tt_int_op(retval,OP_EQ,1);
|
|
||||||
|
|
||||||
test_guard->unreachable_since = now - (7*24*60*60 + 1);
|
|
||||||
test_guard->last_attempted = now - (36*60*60 + 1);
|
|
||||||
|
|
||||||
retval = entry_is_time_to_retry(test_guard,now);
|
|
||||||
tt_int_op(retval,OP_EQ,1);
|
|
||||||
|
|
||||||
done:
|
|
||||||
tor_free(test_guard);
|
|
||||||
}
|
|
||||||
|
|
||||||
/** XXX Do some tests that entry_is_live() */
|
|
||||||
static void
|
|
||||||
test_entry_is_live(void *arg)
|
|
||||||
{
|
|
||||||
smartlist_t *our_nodelist = NULL;
|
|
||||||
guard_selection_t *gs = get_guard_selection_info();
|
|
||||||
const smartlist_t *all_entry_guards =
|
|
||||||
get_entry_guards_for_guard_selection(gs);
|
|
||||||
const node_t *test_node = NULL;
|
|
||||||
const entry_guard_t *test_entry = NULL;
|
|
||||||
const char *msg;
|
|
||||||
int which_node;
|
|
||||||
|
|
||||||
(void) arg;
|
|
||||||
|
|
||||||
/* The global entry guards smartlist should be empty now. */
|
|
||||||
tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);
|
|
||||||
|
|
||||||
/* Walk the nodelist and add all nodes as entry guards. */
|
|
||||||
our_nodelist = nodelist_get_list();
|
|
||||||
tt_int_op(smartlist_len(our_nodelist), OP_EQ, HELPER_NUMBER_OF_DESCRIPTORS);
|
|
||||||
|
|
||||||
SMARTLIST_FOREACH_BEGIN(our_nodelist, const node_t *, node) {
|
|
||||||
const node_t *node_tmp;
|
|
||||||
node_tmp = add_an_entry_guard(gs, node, 0, 1, 0, 0);
|
|
||||||
tt_assert(node_tmp);
|
|
||||||
|
|
||||||
tt_int_op(node->is_stable, OP_EQ, 0);
|
|
||||||
tt_int_op(node->is_fast, OP_EQ, 0);
|
|
||||||
} SMARTLIST_FOREACH_END(node);
|
|
||||||
|
|
||||||
/* Make sure the nodes were added as entry guards. */
|
|
||||||
tt_int_op(smartlist_len(all_entry_guards), OP_EQ,
|
|
||||||
HELPER_NUMBER_OF_DESCRIPTORS);
|
|
||||||
|
|
||||||
/* Now get a random test entry that we will use for this unit test. */
|
|
||||||
which_node = 3; /* (chosen by fair dice roll) */
|
|
||||||
test_entry = smartlist_get(all_entry_guards, which_node);
|
|
||||||
|
|
||||||
/* Let's do some entry_is_live() tests! */
|
|
||||||
|
|
||||||
/* Require the node to be stable, but it's not. Should fail.
|
|
||||||
Also enable 'assume_reachable' because why not. */
|
|
||||||
test_node = entry_is_live(test_entry,
|
|
||||||
ENTRY_NEED_UPTIME | ENTRY_ASSUME_REACHABLE,
|
|
||||||
&msg);
|
|
||||||
tt_assert(!test_node);
|
|
||||||
|
|
||||||
/* Require the node to be fast, but it's not. Should fail. */
|
|
||||||
test_node = entry_is_live(test_entry,
|
|
||||||
ENTRY_NEED_CAPACITY | ENTRY_ASSUME_REACHABLE,
|
|
||||||
&msg);
|
|
||||||
tt_assert(!test_node);
|
|
||||||
|
|
||||||
/* Don't impose any restrictions on the node. Should succeed. */
|
|
||||||
test_node = entry_is_live(test_entry, 0, &msg);
|
|
||||||
tt_assert(test_node);
|
|
||||||
tt_ptr_op(test_node, OP_EQ, node_get_by_id(test_entry->identity));
|
|
||||||
|
|
||||||
/* Require descriptor for this node. It has one so it should succeed. */
|
|
||||||
test_node = entry_is_live(test_entry, ENTRY_NEED_DESCRIPTOR, &msg);
|
|
||||||
tt_assert(test_node);
|
|
||||||
tt_ptr_op(test_node, OP_EQ, node_get_by_id(test_entry->identity));
|
|
||||||
|
|
||||||
done:
|
|
||||||
; /* XXX */
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define TEST_IPV4_ADDR "123.45.67.89"
|
#define TEST_IPV4_ADDR "123.45.67.89"
|
||||||
#define TEST_IPV6_ADDR "[1234:5678:90ab:cdef::]"
|
#define TEST_IPV6_ADDR "[1234:5678:90ab:cdef::]"
|
||||||
|
|
||||||
@ -1475,12 +749,7 @@ test_entry_guard_parse_from_state_broken(void *arg)
|
|||||||
tt_int_op(smartlist_len(gs_df->sampled_entry_guards), OP_EQ, 1);
|
tt_int_op(smartlist_len(gs_df->sampled_entry_guards), OP_EQ, 1);
|
||||||
guard_selection_t *gs_legacy =
|
guard_selection_t *gs_legacy =
|
||||||
get_guard_selection_by_name("legacy", GS_TYPE_LEGACY, 0);
|
get_guard_selection_by_name("legacy", GS_TYPE_LEGACY, 0);
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
tt_assert(gs_legacy != NULL);
|
|
||||||
tt_int_op(smartlist_len(gs_legacy->chosen_entry_guards), OP_EQ, 0);
|
|
||||||
#else
|
|
||||||
tt_assert(gs_legacy == NULL);
|
tt_assert(gs_legacy == NULL);
|
||||||
#endif
|
|
||||||
|
|
||||||
done:
|
done:
|
||||||
config_free_lines(lines);
|
config_free_lines(lines);
|
||||||
@ -3361,12 +2630,6 @@ test_enty_guard_should_expire_waiting(void *arg)
|
|||||||
tor_free(fake_state);
|
tor_free(fake_state);
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
static const struct testcase_setup_t fake_network = {
|
|
||||||
fake_network_setup, fake_network_cleanup
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
|
|
||||||
static const struct testcase_setup_t big_fake_network = {
|
static const struct testcase_setup_t big_fake_network = {
|
||||||
big_fake_network_setup, big_fake_network_cleanup
|
big_fake_network_setup, big_fake_network_cleanup
|
||||||
};
|
};
|
||||||
@ -3383,33 +2646,6 @@ static const struct testcase_setup_t upgrade_circuits = {
|
|||||||
(void*)(arg) }
|
(void*)(arg) }
|
||||||
|
|
||||||
struct testcase_t entrynodes_tests[] = {
|
struct testcase_t entrynodes_tests[] = {
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
{ "entry_is_time_to_retry", test_entry_is_time_to_retry,
|
|
||||||
TT_FORK, NULL, NULL },
|
|
||||||
{ "choose_random_entry_no_guards", test_choose_random_entry_no_guards,
|
|
||||||
TT_FORK, &fake_network, NULL },
|
|
||||||
{ "choose_random_entry_one_possible_guard",
|
|
||||||
test_choose_random_entry_one_possible_guard,
|
|
||||||
TT_FORK, &fake_network, NULL },
|
|
||||||
{ "populate_live_entry_guards_1guard",
|
|
||||||
test_populate_live_entry_guards_1guard,
|
|
||||||
TT_FORK, &fake_network, NULL },
|
|
||||||
{ "populate_live_entry_guards_3guards",
|
|
||||||
test_populate_live_entry_guards_3guards,
|
|
||||||
TT_FORK, &fake_network, NULL },
|
|
||||||
{ "entry_guards_parse_state_simple",
|
|
||||||
test_entry_guards_parse_state_simple,
|
|
||||||
TT_FORK, &fake_network, NULL },
|
|
||||||
{ "entry_guards_parse_state_pathbias",
|
|
||||||
test_entry_guards_parse_state_pathbias,
|
|
||||||
TT_FORK, &fake_network, NULL },
|
|
||||||
{ "entry_guards_set_from_config",
|
|
||||||
test_entry_guards_set_from_config,
|
|
||||||
TT_FORK, &fake_network, NULL },
|
|
||||||
{ "entry_is_live",
|
|
||||||
test_entry_is_live,
|
|
||||||
TT_FORK, &fake_network, NULL },
|
|
||||||
#endif
|
|
||||||
{ "node_preferred_orport",
|
{ "node_preferred_orport",
|
||||||
test_node_preferred_orport,
|
test_node_preferred_orport,
|
||||||
0, NULL, NULL },
|
0, NULL, NULL },
|
||||||
|
|||||||
@ -204,55 +204,6 @@ mock_usable_consensus_flavor(void)
|
|||||||
return mock_usable_consensus_flavor_value;
|
return mock_usable_consensus_flavor_value;
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
static smartlist_t *mock_is_guard_list = NULL;
|
|
||||||
|
|
||||||
static int
|
|
||||||
mock_is_node_used_as_guard(const node_t *n)
|
|
||||||
{
|
|
||||||
if (mock_is_guard_list) {
|
|
||||||
SMARTLIST_FOREACH_BEGIN(mock_is_guard_list, node_t *, e) {
|
|
||||||
if (e == n) return 1;
|
|
||||||
} SMARTLIST_FOREACH_END(e);
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
|
||||||
mark_node_used_as_guard(node_t *n)
|
|
||||||
{
|
|
||||||
if (!n) return;
|
|
||||||
|
|
||||||
if (!mock_is_guard_list) {
|
|
||||||
mock_is_guard_list = smartlist_new();
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!mock_is_node_used_as_guard(n)) {
|
|
||||||
smartlist_add(mock_is_guard_list, n);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
|
||||||
mark_node_unused_as_guard(node_t *n)
|
|
||||||
{
|
|
||||||
if (!n) return;
|
|
||||||
|
|
||||||
if (!mock_is_guard_list) return;
|
|
||||||
|
|
||||||
smartlist_remove(mock_is_guard_list, n);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
|
||||||
clear_mock_guard_list(void)
|
|
||||||
{
|
|
||||||
if (mock_is_guard_list) {
|
|
||||||
smartlist_free(mock_is_guard_list);
|
|
||||||
mock_is_guard_list = NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
static void
|
static void
|
||||||
test_router_pick_directory_server_impl(void *arg)
|
test_router_pick_directory_server_impl(void *arg)
|
||||||
{
|
{
|
||||||
@ -273,9 +224,6 @@ test_router_pick_directory_server_impl(void *arg)
|
|||||||
(void)arg;
|
(void)arg;
|
||||||
|
|
||||||
MOCK(usable_consensus_flavor, mock_usable_consensus_flavor);
|
MOCK(usable_consensus_flavor, mock_usable_consensus_flavor);
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
MOCK(is_node_used_as_guard, mock_is_node_used_as_guard);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* With no consensus, we must be bootstrapping, regardless of time or flavor
|
/* With no consensus, we must be bootstrapping, regardless of time or flavor
|
||||||
*/
|
*/
|
||||||
@ -388,34 +336,6 @@ test_router_pick_directory_server_impl(void *arg)
|
|||||||
node_router1->is_valid = 1;
|
node_router1->is_valid = 1;
|
||||||
node_router3->is_valid = 1;
|
node_router3->is_valid = 1;
|
||||||
|
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
flags |= PDS_FOR_GUARD;
|
|
||||||
mark_node_used_as_guard(node_router1);
|
|
||||||
mark_node_used_as_guard(node_router2);
|
|
||||||
mark_node_used_as_guard(node_router3);
|
|
||||||
rs = router_pick_directory_server_impl(V3_DIRINFO, flags, NULL);
|
|
||||||
tt_assert(rs == NULL);
|
|
||||||
mark_node_unused_as_guard(node_router1);
|
|
||||||
rs = router_pick_directory_server_impl(V3_DIRINFO, flags, NULL);
|
|
||||||
tt_assert(rs != NULL);
|
|
||||||
tt_assert(tor_memeq(rs->identity_digest, router1_id, DIGEST_LEN));
|
|
||||||
rs = NULL;
|
|
||||||
mark_node_unused_as_guard(node_router2);
|
|
||||||
mark_node_unused_as_guard(node_router3);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* One not valid, one guard. This should leave one remaining */
|
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
node_router1->is_valid = 0;
|
|
||||||
mark_node_used_as_guard(node_router2);
|
|
||||||
rs = router_pick_directory_server_impl(V3_DIRINFO, flags, NULL);
|
|
||||||
tt_assert(rs != NULL);
|
|
||||||
tt_assert(tor_memeq(rs->identity_digest, router3_id, DIGEST_LEN));
|
|
||||||
rs = NULL;
|
|
||||||
node_router1->is_valid = 1;
|
|
||||||
mark_node_unused_as_guard(node_router2);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Manipulate overloaded */
|
/* Manipulate overloaded */
|
||||||
|
|
||||||
node_router2->rs->last_dir_503_at = now;
|
node_router2->rs->last_dir_503_at = now;
|
||||||
@ -477,10 +397,6 @@ test_router_pick_directory_server_impl(void *arg)
|
|||||||
|
|
||||||
done:
|
done:
|
||||||
UNMOCK(usable_consensus_flavor);
|
UNMOCK(usable_consensus_flavor);
|
||||||
#ifdef ENABLE_LEGACY_GUARD_ALGORITHM
|
|
||||||
UNMOCK(is_node_used_as_guard);
|
|
||||||
clear_mock_guard_list();
|
|
||||||
#endif
|
|
||||||
|
|
||||||
if (router1_id)
|
if (router1_id)
|
||||||
tor_free(router1_id);
|
tor_free(router1_id);
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user