torproject/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-12-06 19:41:15 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove functions that checked for pre-ipv6 consensus.

Browse Source 
We no longer need or need to test:
  * node_awaiting_ipv6()
  * networkstatus_consensus_has_ipv6().
This commit is contained in:
Nick Mathewson
2020-01-15 11:26:14 -05:00
parent 8d94bcbf8c
commit ceacda44f1
4 changed files with 1 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/or/policies.c
+1 -55
View File
@@ -933,49 +933,6 @@ fascist_firewall_choose_address_ipv4h(uint32_t ipv4h_addr,
pref_ipv6, ap);
}
/* Some microdescriptor consensus methods have no IPv6 addresses in rs: they
* are in the microdescriptors. For these consensus methods, we can't rely on
* the node's IPv6 address until its microdescriptor is available (when using
* microdescs).
* But for bridges, rewrite_node_address_for_bridge() updates node->ri with
* the configured address, so we can trust bridge addresses.
* (Bridges could gain an IPv6 address if their microdescriptor arrives, but
* this will never be their preferred address: that is in the config.)
* Returns true if the node needs a microdescriptor for its IPv6 address, and
* false if the addresses in the node are already up-to-date.
*/
static int
node_awaiting_ipv6(const or_options_t* options, const node_t *node)
{
tor_assert(node);
/* There's no point waiting for an IPv6 address if we'd never use it */
if (!fascist_firewall_use_ipv6(options)) {
return 0;
}
/* If the node has an IPv6 address, we're not waiting */
if (node_has_ipv6_addr(node)) {
return 0;
}
/* If the current consensus method and flavour has IPv6 addresses, we're not
* waiting */
if (networkstatus_consensus_has_ipv6(options)) {
return 0;
}
/* Bridge clients never use the address from a bridge's md, so there's no
* need to wait for it. */
if (node_is_a_configured_bridge(node)) {
return 0;
}
/* We are waiting if we_use_microdescriptors_for_circuits() and we have no
* md. */
return (!node->md && we_use_microdescriptors_for_circuits(options));
}
/** Like fascist_firewall_choose_address_base(), but takes <b>rs</b>.
* Consults the corresponding node, then falls back to rs if node is NULL.
* This should only happen when there's no valid consensus, and rs doesn't
@@ -998,7 +955,7 @@ fascist_firewall_choose_address_rs(const routerstatus_t *rs,
const or_options_t *options = get_options();
const node_t *node = node_get_by_id(rs->identity_digest);
if (node && !node_awaiting_ipv6(options, node)) {
if (node) {
fascist_firewall_choose_address_node(node, fw_connection, pref_only, ap);
} else {
/* There's no node-specific IPv6 preference, so use the generic IPv6
@@ -1111,17 +1068,6 @@ fascist_firewall_choose_address_node(const node_t *node,
}
node_assert_ok(node);
/* Calling fascist_firewall_choose_address_node() when the node is missing
* IPv6 information breaks IPv6-only clients.
* If the node is a hard-coded fallback directory or authority, call
* fascist_firewall_choose_address_rs() on the fake (hard-coded) routerstatus
* for the node.
* If it is not hard-coded, check that the node has a microdescriptor, full
* descriptor (routerinfo), or is one of our configured bridges before
* calling this function. */
if (BUG(node_awaiting_ipv6(get_options(), node))) {
return;
}
const int pref_ipv6_node = (fw_connection == FIREWALL_OR_CONNECTION
? node_ipv6_or_preferred(node)
src/feature/nodelist/networkstatus.c
-22
View File
@@ -1577,28 +1577,6 @@ networkstatus_consensus_is_already_downloading(const char *resource)
return answer;
}
/* Does the current, reasonably live consensus have IPv6 addresses?
* Returns 1 if there is a reasonably live consensus and its consensus method
* includes IPv6 addresses in the consensus.
* Otherwise, if there is no consensus, or the method does not include IPv6
* addresses, returns 0. */
int
networkstatus_consensus_has_ipv6(const or_options_t* options)
{
(void) options;
const networkstatus_t *cons = networkstatus_get_reasonably_live_consensus(
approx_time(),
usable_consensus_flavor());
/* If we have no consensus, we have no IPv6 in it */
if (!cons) {
return 0;
}
/* All supported consensus methods have IPv6 addresses. */
return 1;
}
/** Given two router status entries for the same router identity, return 1 if
* if the contents have changed between them. Otherwise, return 0. */
static int
src/feature/nodelist/networkstatus.h
-1
View File
@@ -104,7 +104,6 @@ int networkstatus_consensus_can_use_multiple_directories(
MOCK_DECL(int, networkstatus_consensus_can_use_extra_fallbacks,(
const or_options_t *options));
int networkstatus_consensus_is_already_downloading(const char *resource);
int networkstatus_consensus_has_ipv6(const or_options_t* options);
#define NSSET_FROM_CACHE 1
#define NSSET_WAS_WAITING_FOR_CERTS 2
src/test/test_dir.c
-88
View File
@@ -7065,93 +7065,6 @@ test_dir_platform_str(void *arg)
;
}
static networkstatus_t *mock_networkstatus;
static networkstatus_t *
mock_networkstatus_get_latest_consensus_by_flavor(consensus_flavor_t f)
{
(void)f;
return mock_networkstatus;
}
static void
test_dir_networkstatus_consensus_has_ipv6(void *arg)
{
(void)arg;
int has_ipv6 = 0;
/* Init options and networkstatus */
or_options_t our_options;
mock_options = &our_options;
reset_options(mock_options, &mock_get_options_calls);
MOCK(get_options, mock_get_options);
networkstatus_t our_networkstatus;
mock_networkstatus = &our_networkstatus;
memset(mock_networkstatus, 0, sizeof(*mock_networkstatus));
MOCK(networkstatus_get_latest_consensus_by_flavor,
mock_networkstatus_get_latest_consensus_by_flavor);
/* A live consensus */
mock_networkstatus->valid_after = time(NULL) - 3600;
mock_networkstatus->valid_until = time(NULL) + 3600;
/* Test the bounds for A lines in the NS consensus */
mock_options->UseMicrodescriptors = 0;
mock_networkstatus->consensus_method = MIN_SUPPORTED_CONSENSUS_METHOD;
has_ipv6 = networkstatus_consensus_has_ipv6(get_options());
tt_assert(has_ipv6);
/* Test the bounds for A lines in the microdesc consensus */
mock_options->UseMicrodescriptors = 1;
mock_networkstatus->consensus_method =
MIN_SUPPORTED_CONSENSUS_METHOD;
has_ipv6 = networkstatus_consensus_has_ipv6(get_options());
tt_assert(has_ipv6);
mock_networkstatus->consensus_method = MAX_SUPPORTED_CONSENSUS_METHOD + 20;
has_ipv6 = networkstatus_consensus_has_ipv6(get_options());
tt_assert(has_ipv6);
mock_networkstatus->consensus_method =
MIN_SUPPORTED_CONSENSUS_METHOD + 1;
has_ipv6 = networkstatus_consensus_has_ipv6(get_options());
tt_assert(has_ipv6);
mock_networkstatus->consensus_method =
MIN_SUPPORTED_CONSENSUS_METHOD + 20;
has_ipv6 = networkstatus_consensus_has_ipv6(get_options());
tt_assert(has_ipv6);
/* Test the edge cases */
mock_options->UseMicrodescriptors = 1;
mock_networkstatus->consensus_method =
MIN_SUPPORTED_CONSENSUS_METHOD;
/* Reasonably live */
mock_networkstatus->valid_until = approx_time() - 60;
has_ipv6 = networkstatus_consensus_has_ipv6(get_options());
tt_assert(has_ipv6);
/* Not reasonably live */
mock_networkstatus->valid_after = approx_time() - 24*60*60 - 3600;
mock_networkstatus->valid_until = approx_time() - 24*60*60 - 60;
has_ipv6 = networkstatus_consensus_has_ipv6(get_options());
tt_assert(!has_ipv6);
/* NULL consensus */
mock_networkstatus = NULL;
has_ipv6 = networkstatus_consensus_has_ipv6(get_options());
tt_assert(!has_ipv6);
done:
UNMOCK(get_options);
UNMOCK(networkstatus_get_latest_consensus_by_flavor);
}
static void
test_dir_format_versions_list(void *arg)
{
@@ -7290,7 +7203,6 @@ struct testcase_t dir_tests[] = {
DIR(matching_flags, 0),
DIR(networkstatus_compute_bw_weights_v10, 0),
DIR(platform_str, 0),
DIR(networkstatus_consensus_has_ipv6, TT_FORK),
DIR(format_versions_list, TT_FORK),
END_OF_TESTCASES
};