nihilist/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-11-11 13:43:47 +01:00
Code Issues Packages Projects Releases Wiki Activity
047790a253
tor/src/test/test_entrynodes.c

2732 lines
92 KiB
C
Raw Normal View History

Run the copyright update script.
2017-03-15 21:13:17 +01:00
/* Copyright (c) 2014-2017, The Tor Project, Inc. */
Add the entrynodes.c unit tests.
2014-06-24 20:22:52 +02:00
/* See LICENSE for licensing information */
#include "orconfig.h"
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
#define CIRCUITLIST_PRIVATE
Add the entrynodes.c unit tests.
2014-06-24 20:22:52 +02:00
#define STATEFILE_PRIVATE
#define ENTRYNODES_PRIVATE
#define ROUTERLIST_PRIVATE
#include "or.h"
#include "test.h"
Make bridge clients prefer the configured bridge address When ClientPreferIPv6ORPort is auto, bridges prefer the configured bridge ORPort address. Otherwise, they use the value of the option. Other clients prefer IPv4 ORPorts if ClientPreferIPv6ORPort is auto. When ClientPreferIPv6DirPort is auto, all clients prefer IPv4 DirPorts.
2016-02-03 13:52:39 +01:00
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
#include "bridges.h"
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
#include "circuitlist.h"
Make bridge clients prefer the configured bridge address When ClientPreferIPv6ORPort is auto, bridges prefer the configured bridge ORPort address. Otherwise, they use the value of the option. Other clients prefer IPv4 ORPorts if ClientPreferIPv6ORPort is auto. When ClientPreferIPv6DirPort is auto, all clients prefer IPv4 DirPorts.
2016-02-03 13:52:39 +01:00
#include "config.h"
prop271: Tests for the highlevel or_state_t encode/decode functions
2016-11-30 18:35:16 +01:00
#include "confparse.h"
Add the entrynodes.c unit tests.
2014-06-24 20:22:52 +02:00
#include "entrynodes.h"
#include "nodelist.h"
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
#include "networkstatus.h"
Make bridge clients prefer the configured bridge address When ClientPreferIPv6ORPort is auto, bridges prefer the configured bridge ORPort address. Otherwise, they use the value of the option. Other clients prefer IPv4 ORPorts if ClientPreferIPv6ORPort is auto. When ClientPreferIPv6DirPort is auto, all clients prefer IPv4 DirPorts.
2016-02-03 13:52:39 +01:00
#include "policies.h"
Add the entrynodes.c unit tests.
2014-06-24 20:22:52 +02:00
#include "routerlist.h"
Make bridge clients prefer the configured bridge address When ClientPreferIPv6ORPort is auto, bridges prefer the configured bridge ORPort address. Otherwise, they use the value of the option. Other clients prefer IPv4 ORPorts if ClientPreferIPv6ORPort is auto. When ClientPreferIPv6DirPort is auto, all clients prefer IPv4 DirPorts.
2016-02-03 13:52:39 +01:00
#include "routerparse.h"
Add the entrynodes.c unit tests.
2014-06-24 20:22:52 +02:00
#include "routerset.h"
#include "statefile.h"
Make bridge clients prefer the configured bridge address When ClientPreferIPv6ORPort is auto, bridges prefer the configured bridge ORPort address. Otherwise, they use the value of the option. Other clients prefer IPv4 ORPorts if ClientPreferIPv6ORPort is auto. When ClientPreferIPv6DirPort is auto, all clients prefer IPv4 DirPorts.
2016-02-03 13:52:39 +01:00
#include "util.h"
Add the entrynodes.c unit tests.
2014-06-24 20:22:52 +02:00
Unittest prep: Move get_yesterday_date_str() to helper file. We want to use this function in our guardfraction unittests, so make a test_helpers module and move it there.
2015-01-29 16:09:53 +01:00
#include "test_helpers.h"
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
#include "log_test_helpers.h"
Move test_descriptors.txt to an include file Making the text file work out-of-tree didn't work on windows. Maybe we can get it working that way later.
2014-07-16 22:37:00 +02:00
Add the entrynodes.c unit tests.
2014-06-24 20:22:52 +02:00
/* TODO:
* choose_random_entry() test with state set.
*
* parse_state() tests with more than one guards.
*
* More tests for set_from_config(): Multiple nodes, use fingerprints,
* use country codes.
*/
/** Dummy Tor state used in unittests. */
static or_state_t *dummy_state = NULL;
static or_state_t *
get_or_state_replacement(void)
{
return dummy_state;
}
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
static networkstatus_t *dummy_consensus = NULL;
static smartlist_t *big_fake_net_nodes = NULL;
static smartlist_t *
bfn_mock_nodelist_get_list(void)
{
return big_fake_net_nodes;
}
static networkstatus_t *
bfn_mock_networkstatus_get_live_consensus(time_t now)
{
(void)now;
return dummy_consensus;
}
static const node_t *
bfn_mock_node_get_by_id(const char *id)
{
SMARTLIST_FOREACH(big_fake_net_nodes, node_t *, n,
if (fast_memeq(n->identity, id, 20))
return n);
return NULL;
}
/* Unittest cleanup function: Cleanup the fake network. */
static int
big_fake_network_cleanup(const struct testcase_t *testcase, void *ptr)
{
(void) testcase;
(void) ptr;
if (big_fake_net_nodes) {
SMARTLIST_FOREACH(big_fake_net_nodes, node_t *, n, {
tor_free(n->rs);
tor_free(n->md);
tor_free(n);
});
smartlist_free(big_fake_net_nodes);
}
UNMOCK(nodelist_get_list);
UNMOCK(node_get_by_id);
UNMOCK(get_or_state);
UNMOCK(networkstatus_get_live_consensus);
or_state_free(dummy_state);
dummy_state = NULL;
tor_free(dummy_consensus);
return 1; /* NOP */
}
/* Unittest setup function: Setup a fake network. */
static void *
big_fake_network_setup(const struct testcase_t *testcase)
{
int i;
/* These are minimal node_t objects that only contain the aspects of node_t
* that we need for entrynodes.c. */
const int N_NODES = 271;
big_fake_net_nodes = smartlist_new();
for (i = 0; i < N_NODES; ++i) {
node_t *n = tor_malloc_zero(sizeof(node_t));
n->md = tor_malloc_zero(sizeof(microdesc_t));
crypto_rand(n->identity, sizeof(n->identity));
n->rs = tor_malloc_zero(sizeof(routerstatus_t));
memcpy(n->rs->identity_digest, n->identity, DIGEST_LEN);
n->is_running = n->is_valid = n->is_fast = n->is_stable = 1;
Adjust unit tests to account for fix to bug 22753. Our mock network put all the guards on the same IPv4 address, which doesn't fly when we start applying EnforceDistinctSubnets. So in this commit, I disable EnforceDistinctSubnets when running the old guard_restriction_t test. This commit also adds a regression test for #22753.
2017-06-29 16:09:06 +02:00
/* Note: all these guards have the same address, so you'll need to
* disable EnforceDistinctSubnets when a restriction is applied. */
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
n->rs->addr = 0x04020202;
n->rs->or_port = 1234;
n->rs->is_v2_dir = 1;
n->rs->has_bandwidth = 1;
n->rs->bandwidth_kb = 30;
/* Call half of the nodes a possible guard. */
if (i % 2 == 0) {
n->is_possible_guard = 1;
n->rs->guardfraction_percentage = 100;
n->rs->has_guardfraction = 1;
}
smartlist_add(big_fake_net_nodes, n);
}
dummy_state = tor_malloc_zero(sizeof(or_state_t));
dummy_consensus = tor_malloc_zero(sizeof(networkstatus_t));
dummy_consensus->valid_after = approx_time() - 3600;
dummy_consensus->valid_until = approx_time() + 3600;
MOCK(nodelist_get_list, bfn_mock_nodelist_get_list);
MOCK(node_get_by_id, bfn_mock_node_get_by_id);
MOCK(get_or_state,
get_or_state_replacement);
MOCK(networkstatus_get_live_consensus,
bfn_mock_networkstatus_get_live_consensus);
/* Return anything but NULL (it's interpreted as test fail) */
return (void*)testcase;
}
static time_t
mock_randomize_time_no_randomization(time_t a, time_t b)
{
(void) b;
return a;
}
Choose OR Entry Guards using IPv4/IPv6 preferences Update unit tests.
2015-12-18 01:28:54 +01:00
static or_options_t mocked_options;
static const or_options_t *
mock_get_options(void)
{
return &mocked_options;
}
Add ClientUseIPv4 and ClientPreferIPv6DirPort torrc options ClientUseIPv4 0 tells tor to avoid IPv4 client connections. ClientPreferIPv6DirPort 1 tells tor to prefer IPv6 directory connections. Refactor policy for IPv4/IPv6 preferences. Fix a bug where node->ipv6_preferred could become stale if ClientPreferIPv6ORPort was changed after the consensus was loaded. Update documentation, existing code, add unit tests.
2015-12-14 07:23:10 +01:00
#define TEST_IPV4_ADDR "123.45.67.89"
#define TEST_IPV6_ADDR "[1234:5678:90ab:cdef::]"
static void
test_node_preferred_orport(void *arg)
{
(void)arg;
tor_addr_t ipv4_addr;
const uint16_t ipv4_port = 4444;
tor_addr_t ipv6_addr;
const uint16_t ipv6_port = 6666;
routerinfo_t node_ri;
node_t node;
tor_addr_port_t ap;
/* Setup options */
memset(&mocked_options, 0, sizeof(mocked_options));
Use fascist firewall and ClientUseIPv4 for bridge clients Bridge clients ignore ClientUseIPv6, acting as if it is always 1. This preserves existing behaviour. Make ClientPreferIPv6OR/DirPort auto by default: * Bridge clients prefer IPv6 by default. * Other clients prefer IPv4 by default. This preserves existing behaviour.
2016-01-03 14:35:22 +01:00
/* We don't test ClientPreferIPv6ORPort here, because it's used in
* nodelist_set_consensus to setup node.ipv6_preferred, which we set
* directly. */
Add ClientUseIPv4 and ClientPreferIPv6DirPort torrc options ClientUseIPv4 0 tells tor to avoid IPv4 client connections. ClientPreferIPv6DirPort 1 tells tor to prefer IPv6 directory connections. Refactor policy for IPv4/IPv6 preferences. Fix a bug where node->ipv6_preferred could become stale if ClientPreferIPv6ORPort was changed after the consensus was loaded. Update documentation, existing code, add unit tests.
2015-12-14 07:23:10 +01:00
MOCK(get_options, mock_get_options);
/* Setup IP addresses */
tor_addr_parse(&ipv4_addr, TEST_IPV4_ADDR);
tor_addr_parse(&ipv6_addr, TEST_IPV6_ADDR);
/* Setup node_ri */
memset(&node_ri, 0, sizeof(node_ri));
node_ri.addr = tor_addr_to_ipv4h(&ipv4_addr);
node_ri.or_port = ipv4_port;
tor_addr_copy(&node_ri.ipv6_addr, &ipv6_addr);
node_ri.ipv6_orport = ipv6_port;
/* Setup node */
memset(&node, 0, sizeof(node));
node.ri = &node_ri;
/* Check the preferred address is IPv4 if we're only using IPv4, regardless
* of whether we prefer it or not */
mocked_options.ClientUseIPv4 = 1;
mocked_options.ClientUseIPv6 = 0;
node.ipv6_preferred = 0;
node_get_pref_orport(&node, &ap);
tt_assert(tor_addr_eq(&ap.addr, &ipv4_addr));
tt_assert(ap.port == ipv4_port);
node.ipv6_preferred = 1;
node_get_pref_orport(&node, &ap);
tt_assert(tor_addr_eq(&ap.addr, &ipv4_addr));
tt_assert(ap.port == ipv4_port);
/* Check the preferred address is IPv4 if we're using IPv4 and IPv6, but
* don't prefer the IPv6 address */
mocked_options.ClientUseIPv4 = 1;
mocked_options.ClientUseIPv6 = 1;
node.ipv6_preferred = 0;
node_get_pref_orport(&node, &ap);
tt_assert(tor_addr_eq(&ap.addr, &ipv4_addr));
tt_assert(ap.port == ipv4_port);
/* Check the preferred address is IPv6 if we prefer it and
* ClientUseIPv6 is 1, regardless of ClientUseIPv4 */
mocked_options.ClientUseIPv4 = 1;
mocked_options.ClientUseIPv6 = 1;
node.ipv6_preferred = 1;
node_get_pref_orport(&node, &ap);
tt_assert(tor_addr_eq(&ap.addr, &ipv6_addr));
tt_assert(ap.port == ipv6_port);
mocked_options.ClientUseIPv4 = 0;
node_get_pref_orport(&node, &ap);
tt_assert(tor_addr_eq(&ap.addr, &ipv6_addr));
tt_assert(ap.port == ipv6_port);
/* Check the preferred address is IPv6 if we don't prefer it, but
* ClientUseIPv4 is 0 */
mocked_options.ClientUseIPv4 = 0;
mocked_options.ClientUseIPv6 = 1;
Make bridge clients prefer the configured bridge address When ClientPreferIPv6ORPort is auto, bridges prefer the configured bridge ORPort address. Otherwise, they use the value of the option. Other clients prefer IPv4 ORPorts if ClientPreferIPv6ORPort is auto. When ClientPreferIPv6DirPort is auto, all clients prefer IPv4 DirPorts.
2016-02-03 13:52:39 +01:00
node.ipv6_preferred = fascist_firewall_prefer_ipv6_orport(&mocked_options);
Add ClientUseIPv4 and ClientPreferIPv6DirPort torrc options ClientUseIPv4 0 tells tor to avoid IPv4 client connections. ClientPreferIPv6DirPort 1 tells tor to prefer IPv6 directory connections. Refactor policy for IPv4/IPv6 preferences. Fix a bug where node->ipv6_preferred could become stale if ClientPreferIPv6ORPort was changed after the consensus was loaded. Update documentation, existing code, add unit tests.
2015-12-14 07:23:10 +01:00
node_get_pref_orport(&node, &ap);
tt_assert(tor_addr_eq(&ap.addr, &ipv6_addr));
tt_assert(ap.port == ipv6_port);
done:
UNMOCK(get_options);
}
Add an entry_guard_describe() function This function helpfully removes all but one remaining use of an entry_guard_t private field in pathbias.c
2016-11-14 18:04:42 +01:00
static void
test_entry_guard_describe(void *arg)
{
(void)arg;
entry_guard_t g;
memset(&g, 0, sizeof(g));
strlcpy(g.nickname, "okefenokee", sizeof(g.nickname));
memcpy(g.identity, "theforestprimeval---", DIGEST_LEN);
tt_str_op(entry_guard_describe(&g), OP_EQ,
"okefenokee ($746865666F726573747072696D6576616C2D2D2D)");
done:
;
}
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
static void
test_entry_guard_randomize_time(void *arg)
{
const time_t now = 1479153573;
const int delay = 86400;
const int N = 1000;
(void)arg;
time_t t;
int i;
for (i = 0; i < N; ++i) {
t = randomize_time(now, delay);
tt_int_op(t, OP_LE, now);
tt_int_op(t, OP_GE, now-delay);
}
/* now try the corner cases */
for (i = 0; i < N; ++i) {
t = randomize_time(100, delay);
tt_int_op(t, OP_GE, 1);
tt_int_op(t, OP_LE, 100);
t = randomize_time(0, delay);
tt_int_op(t, OP_EQ, 1);
}
done:
;
}
static void
test_entry_guard_encode_for_state_minimal(void *arg)
{
(void) arg;
entry_guard_t *eg = tor_malloc_zero(sizeof(entry_guard_t));
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
eg->selection_name = tor_strdup("wubwub");
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
memcpy(eg->identity, "plurpyflurpyslurpydo", DIGEST_LEN);
eg->sampled_on_date = 1479081600;
eg->confirmed_idx = -1;
char *s = NULL;
s = entry_guard_encode_for_state(eg);
tt_str_op(s, OP_EQ,
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
"in=wubwub "
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
"rsa_id=706C75727079666C75727079736C75727079646F "
"sampled_on=2016-11-14T00:00:00 "
"listed=0");
done:
entry_guard_free(eg);
tor_free(s);
}
static void
test_entry_guard_encode_for_state_maximal(void *arg)
{
(void) arg;
entry_guard_t *eg = tor_malloc_zero(sizeof(entry_guard_t));
strlcpy(eg->nickname, "Fred", sizeof(eg->nickname));
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
eg->selection_name = tor_strdup("default");
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
memcpy(eg->identity, "plurpyflurpyslurpydo", DIGEST_LEN);
Lay down some infrastructure for bridges in the New Guard Order. This includes: * making bridge_info_t exposed but opaque * allowing guards where we don't know an identity * making it possible to learn the identity of a guard * creating a guard that lacks a node_t * remembering a guard's address and port. * Looking up a guard by address and port. * Only enforcing the rule that we need a live consensus to update the "listed" status for guards when we are not using bridges.
2016-11-29 14:04:41 +01:00
eg->bridge_addr = tor_malloc_zero(sizeof(tor_addr_port_t));
tor_addr_from_ipv4h(&eg->bridge_addr->addr, 0x08080404);
eg->bridge_addr->port = 9999;
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
eg->sampled_on_date = 1479081600;
eg->sampled_by_version = tor_strdup("1.2.3");
eg->unlisted_since_date = 1479081645;
eg->currently_listed = 1;
eg->confirmed_on_date = 1479081690;
eg->confirmed_idx = 333;
eg->extra_state_fields = tor_strdup("and the green grass grew all around");
char *s = NULL;
s = entry_guard_encode_for_state(eg);
tt_str_op(s, OP_EQ,
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
"in=default "
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
"rsa_id=706C75727079666C75727079736C75727079646F "
Lay down some infrastructure for bridges in the New Guard Order. This includes: * making bridge_info_t exposed but opaque * allowing guards where we don't know an identity * making it possible to learn the identity of a guard * creating a guard that lacks a node_t * remembering a guard's address and port. * Looking up a guard by address and port. * Only enforcing the rule that we need a live consensus to update the "listed" status for guards when we are not using bridges.
2016-11-29 14:04:41 +01:00
"bridge_addr=8.8.4.4:9999 "
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
"nickname=Fred "
"sampled_on=2016-11-14T00:00:00 "
"sampled_by=1.2.3 "
"unlisted_since=2016-11-14T00:00:45 "
"listed=1 "
"confirmed_on=2016-11-14T00:01:30 "
"confirmed_idx=333 "
"and the green grass grew all around");
done:
entry_guard_free(eg);
tor_free(s);
}
static void
test_entry_guard_parse_from_state_minimal(void *arg)
{
(void)arg;
char *mem_op_hex_tmp = NULL;
entry_guard_t *eg = NULL;
time_t t = approx_time();
eg = entry_guard_parse_from_state(
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
"in=default_plus "
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
"rsa_id=596f75206d6179206e656564206120686f626279");
tt_assert(eg);
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
tt_str_op(eg->selection_name, OP_EQ, "default_plus");
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
test_mem_op_hex(eg->identity, OP_EQ,
"596f75206d6179206e656564206120686f626279");
tt_str_op(eg->nickname, OP_EQ, "$596F75206D6179206E656564206120686F626279");
Lay down some infrastructure for bridges in the New Guard Order. This includes: * making bridge_info_t exposed but opaque * allowing guards where we don't know an identity * making it possible to learn the identity of a guard * creating a guard that lacks a node_t * remembering a guard's address and port. * Looking up a guard by address and port. * Only enforcing the rule that we need a live consensus to update the "listed" status for guards when we are not using bridges.
2016-11-29 14:04:41 +01:00
tt_ptr_op(eg->bridge_addr, OP_EQ, NULL);
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
tt_i64_op(eg->sampled_on_date, OP_GE, t);
tt_i64_op(eg->sampled_on_date, OP_LE, t+86400);
tt_i64_op(eg->unlisted_since_date, OP_EQ, 0);
tt_ptr_op(eg->sampled_by_version, OP_EQ, NULL);
tt_int_op(eg->currently_listed, OP_EQ, 0);
tt_i64_op(eg->confirmed_on_date, OP_EQ, 0);
tt_int_op(eg->confirmed_idx, OP_EQ, -1);
tt_int_op(eg->last_tried_to_connect, OP_EQ, 0);
tt_int_op(eg->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
done:
entry_guard_free(eg);
tor_free(mem_op_hex_tmp);
}
static void
test_entry_guard_parse_from_state_maximal(void *arg)
{
(void)arg;
char *mem_op_hex_tmp = NULL;
entry_guard_t *eg = NULL;
eg = entry_guard_parse_from_state(
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
"in=fred "
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
"rsa_id=706C75727079666C75727079736C75727079646F "
Lay down some infrastructure for bridges in the New Guard Order. This includes: * making bridge_info_t exposed but opaque * allowing guards where we don't know an identity * making it possible to learn the identity of a guard * creating a guard that lacks a node_t * remembering a guard's address and port. * Looking up a guard by address and port. * Only enforcing the rule that we need a live consensus to update the "listed" status for guards when we are not using bridges.
2016-11-29 14:04:41 +01:00
"bridge_addr=[1::3]:9999 "
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
"nickname=Fred "
"sampled_on=2016-11-14T00:00:00 "
"sampled_by=1.2.3 "
"unlisted_since=2016-11-14T00:00:45 "
"listed=1 "
"confirmed_on=2016-11-14T00:01:30 "
"confirmed_idx=333 "
"and the green grass grew all around "
"rsa_id=all,around");
tt_assert(eg);
test_mem_op_hex(eg->identity, OP_EQ,
"706C75727079666C75727079736C75727079646F");
Lay down some infrastructure for bridges in the New Guard Order. This includes: * making bridge_info_t exposed but opaque * allowing guards where we don't know an identity * making it possible to learn the identity of a guard * creating a guard that lacks a node_t * remembering a guard's address and port. * Looking up a guard by address and port. * Only enforcing the rule that we need a live consensus to update the "listed" status for guards when we are not using bridges.
2016-11-29 14:04:41 +01:00
tt_str_op(fmt_addr(&eg->bridge_addr->addr), OP_EQ, "1::3");
tt_int_op(eg->bridge_addr->port, OP_EQ, 9999);
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
tt_str_op(eg->nickname, OP_EQ, "Fred");
tt_i64_op(eg->sampled_on_date, OP_EQ, 1479081600);
tt_i64_op(eg->unlisted_since_date, OP_EQ, 1479081645);
tt_str_op(eg->sampled_by_version, OP_EQ, "1.2.3");
tt_int_op(eg->currently_listed, OP_EQ, 1);
tt_i64_op(eg->confirmed_on_date, OP_EQ, 1479081690);
tt_int_op(eg->confirmed_idx, OP_EQ, 333);
tt_str_op(eg->extra_state_fields, OP_EQ,
"and the green grass grew all around rsa_id=all,around");
tt_int_op(eg->last_tried_to_connect, OP_EQ, 0);
tt_int_op(eg->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
done:
entry_guard_free(eg);
tor_free(mem_op_hex_tmp);
}
static void
test_entry_guard_parse_from_state_failure(void *arg)
{
(void)arg;
entry_guard_t *eg = NULL;
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
/* no selection */
eg = entry_guard_parse_from_state(
"rsa_id=596f75206d6179206e656564206120686f626270");
tt_assert(! eg);
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
/* no RSA ID. */
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
eg = entry_guard_parse_from_state("in=default nickname=Fred");
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
tt_assert(! eg);
/* Bad RSA ID: bad character. */
eg = entry_guard_parse_from_state(
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
"in=default "
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
"rsa_id=596f75206d6179206e656564206120686f62627q");
tt_assert(! eg);
/* Bad RSA ID: too long.*/
eg = entry_guard_parse_from_state(
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
"in=default "
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
"rsa_id=596f75206d6179206e656564206120686f6262703");
tt_assert(! eg);
/* Bad RSA ID: too short.*/
eg = entry_guard_parse_from_state(
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
"in=default "
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
"rsa_id=596f75206d6179206e65656420612");
tt_assert(! eg);
done:
entry_guard_free(eg);
}
static void
test_entry_guard_parse_from_state_partial_failure(void *arg)
{
(void)arg;
char *mem_op_hex_tmp = NULL;
entry_guard_t *eg = NULL;
time_t t = approx_time();
eg = entry_guard_parse_from_state(
Make new prop271 entry guards persistent To do this, it makes sense to treat legacy guards as a separate guard_selection_t *, and handle them separately. This also means we add support here for having multiple guard selections. Note that we don't persist pathbias information yet; that will take some refactoring.
2016-11-22 20:22:54 +01:00
"in=default "
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
"rsa_id=706C75727079666C75727079736C75727079646F "
Lay down some infrastructure for bridges in the New Guard Order. This includes: * making bridge_info_t exposed but opaque * allowing guards where we don't know an identity * making it possible to learn the identity of a guard * creating a guard that lacks a node_t * remembering a guard's address and port. * Looking up a guard by address and port. * Only enforcing the rule that we need a live consensus to update the "listed" status for guards when we are not using bridges.
2016-11-29 14:04:41 +01:00
"bridge_addr=1.2.3.3.4:5 "
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
"nickname=FredIsANodeWithAStrangeNicknameThatIsTooLong "
"sampled_on=2016-11-14T00:00:99 "
"sampled_by=1.2.3 stuff in the middle "
"unlisted_since=2016-xx-14T00:00:45 "
"listed=0 "
"confirmed_on=2016-11-14T00:01:30zz "
"confirmed_idx=idx "
"and the green grass grew all around "
"rsa_id=all,around");
tt_assert(eg);
test_mem_op_hex(eg->identity, OP_EQ,
"706C75727079666C75727079736C75727079646F");
tt_str_op(eg->nickname, OP_EQ, "FredIsANodeWithAStrangeNicknameThatIsTooL");
Lay down some infrastructure for bridges in the New Guard Order. This includes: * making bridge_info_t exposed but opaque * allowing guards where we don't know an identity * making it possible to learn the identity of a guard * creating a guard that lacks a node_t * remembering a guard's address and port. * Looking up a guard by address and port. * Only enforcing the rule that we need a live consensus to update the "listed" status for guards when we are not using bridges.
2016-11-29 14:04:41 +01:00
tt_ptr_op(eg->bridge_addr, OP_EQ, NULL);
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
tt_i64_op(eg->sampled_on_date, OP_EQ, t);
tt_i64_op(eg->unlisted_since_date, OP_EQ, 0);
tt_str_op(eg->sampled_by_version, OP_EQ, "1.2.3");
tt_int_op(eg->currently_listed, OP_EQ, 0);
tt_i64_op(eg->confirmed_on_date, OP_EQ, 0);
tt_int_op(eg->confirmed_idx, OP_EQ, -1);
tt_str_op(eg->extra_state_fields, OP_EQ,
"stuff in the middle and the green grass grew all around "
"rsa_id=all,around");
tt_int_op(eg->last_tried_to_connect, OP_EQ, 0);
tt_int_op(eg->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
done:
entry_guard_free(eg);
tor_free(mem_op_hex_tmp);
}
prop271: Tests for the highlevel or_state_t encode/decode functions
2016-11-30 18:35:16 +01:00
static int
mock_entry_guard_is_listed(guard_selection_t *gs, const entry_guard_t *guard)
{
(void)gs;
(void)guard;
return 1;
}
static void
test_entry_guard_parse_from_state_full(void *arg)
{
(void)arg;
/* Here's a state I made while testing. The identities and locations for
* the bridges are redacted. */
const char STATE[] =
"Guard in=default rsa_id=214F44BD5B638E8C817D47FF7C97397790BF0345 "
"nickname=TotallyNinja sampled_on=2016-11-12T19:32:49 "
"sampled_by=0.3.0.0-alpha-dev "
"listed=1\n"
"Guard in=default rsa_id=052900AB0EA3ED54BAB84AE8A99E74E8693CE2B2 "
"nickname=5OfNovember sampled_on=2016-11-20T04:32:05 "
"sampled_by=0.3.0.0-alpha-dev "
"listed=1 confirmed_on=2016-11-22T08:13:28 confirmed_idx=0 "
"pb_circ_attempts=4.000000 pb_circ_successes=2.000000 "
"pb_successful_circuits_closed=2.000000\n"
"Guard in=default rsa_id=7B700C0C207EBD0002E00F499BE265519AC3C25A "
"nickname=dc6jgk11 sampled_on=2016-11-28T11:50:13 "
"sampled_by=0.3.0.0-alpha-dev "
"listed=1 confirmed_on=2016-11-24T08:45:30 confirmed_idx=4 "
"pb_circ_attempts=5.000000 pb_circ_successes=5.000000 "
"pb_successful_circuits_closed=5.000000\n"
"Guard in=wobblesome rsa_id=7B700C0C207EBD0002E00F499BE265519AC3C25A "
"nickname=dc6jgk11 sampled_on=2016-11-28T11:50:13 "
"sampled_by=0.3.0.0-alpha-dev "
"listed=1\n"
"Guard in=default rsa_id=E9025AD60D86875D5F11548D536CC6AF60F0EF5E "
"nickname=maibrunn sampled_on=2016-11-25T22:36:38 "
"sampled_by=0.3.0.0-alpha-dev listed=1\n"
"Guard in=default rsa_id=DCD30B90BA3A792DA75DC54A327EF353FB84C38E "
"nickname=Unnamed sampled_on=2016-11-25T14:34:00 "
"sampled_by=0.3.0.0-alpha-dev listed=1\n"
"Guard in=bridges rsa_id=8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF2E "
"bridge_addr=24.1.1.1:443 sampled_on=2016-11-25T06:44:14 "
"sampled_by=0.3.0.0-alpha-dev listed=1 "
"confirmed_on=2016-11-29T10:36:06 confirmed_idx=0 "
"pb_circ_attempts=8.000000 pb_circ_successes=8.000000 "
"pb_successful_circuits_closed=13.000000\n"
"Guard in=bridges rsa_id=5800000000000000000000000000000000000000 "
"bridge_addr=37.218.246.143:28366 "
"sampled_on=2016-11-18T15:07:34 sampled_by=0.3.0.0-alpha-dev listed=1\n";
config_line_t *lines = NULL;
or_state_t *state = tor_malloc_zero(sizeof(or_state_t));
int r = config_get_lines(STATE, &lines, 0);
char *msg = NULL;
smartlist_t *text = smartlist_new();
char *joined = NULL;
Tweak test_entrynodes comment
2017-03-26 12:30:00 +02:00
// So nodes aren't expired. This is Tue, 13 Dec 2016 09:37:14 GMT
Use update_approx_time() to run a test 100 days in the past. Fixes bug21799.
2017-03-23 10:44:43 +01:00
update_approx_time(1481621834);
prop271: Tests for the highlevel or_state_t encode/decode functions
2016-11-30 18:35:16 +01:00
MOCK(entry_guard_is_listed, mock_entry_guard_is_listed);
dummy_state = state;
MOCK(get_or_state,
get_or_state_replacement);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
prop271: Tests for the highlevel or_state_t encode/decode functions
2016-11-30 18:35:16 +01:00
tt_assert(lines);
state->Guard = lines;
/* Try it first without setting the result. */
r = entry_guards_parse_state(state, 0, &msg);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
prop271: Tests for the highlevel or_state_t encode/decode functions
2016-11-30 18:35:16 +01:00
guard_selection_t *gs_br =
get_guard_selection_by_name("bridges", GS_TYPE_BRIDGE, 0);
tt_assert(!gs_br);
r = entry_guards_parse_state(state, 1, &msg);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
prop271: Tests for the highlevel or_state_t encode/decode functions
2016-11-30 18:35:16 +01:00
gs_br = get_guard_selection_by_name("bridges", GS_TYPE_BRIDGE, 0);
guard_selection_t *gs_df =
get_guard_selection_by_name("default", GS_TYPE_NORMAL, 0);
guard_selection_t *gs_wb =
get_guard_selection_by_name("wobblesome", GS_TYPE_NORMAL, 0);
tt_assert(gs_br);
tt_assert(gs_df);
tt_assert(gs_wb);
tt_int_op(smartlist_len(gs_df->sampled_entry_guards), OP_EQ, 5);
tt_int_op(smartlist_len(gs_br->sampled_entry_guards), OP_EQ, 2);
tt_int_op(smartlist_len(gs_wb->sampled_entry_guards), OP_EQ, 1);
/* Try again; make sure it doesn't double-add the guards. */
r = entry_guards_parse_state(state, 1, &msg);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
prop271: Tests for the highlevel or_state_t encode/decode functions
2016-11-30 18:35:16 +01:00
gs_br = get_guard_selection_by_name("bridges", GS_TYPE_BRIDGE, 0);
gs_df = get_guard_selection_by_name("default", GS_TYPE_NORMAL, 0);
tt_assert(gs_br);
tt_assert(gs_df);
tt_int_op(smartlist_len(gs_df->sampled_entry_guards), OP_EQ, 5);
tt_int_op(smartlist_len(gs_br->sampled_entry_guards), OP_EQ, 2);
/* Re-encode; it should be the same... almost. */
{
/* (Make a guard nonpersistent first) */
entry_guard_t *g = smartlist_get(gs_df->sampled_entry_guards, 0);
g->is_persistent = 0;
}
config_free_lines(lines);
lines = state->Guard = NULL; // to prevent double-free.
entry_guards_update_state(state);
tt_assert(state->Guard);
lines = state->Guard;
config_line_t *ln;
for (ln = lines; ln; ln = ln->next) {
smartlist_add_asprintf(text, "%s %s\n",ln->key, ln->value);
}
joined = smartlist_join_strings(text, "", 0, NULL);
tt_str_op(joined, OP_EQ,
"Guard in=default rsa_id=052900AB0EA3ED54BAB84AE8A99E74E8693CE2B2 "
"nickname=5OfNovember sampled_on=2016-11-20T04:32:05 "
"sampled_by=0.3.0.0-alpha-dev "
"listed=1 confirmed_on=2016-11-22T08:13:28 confirmed_idx=0 "
"pb_circ_attempts=4.000000 pb_circ_successes=2.000000 "
"pb_successful_circuits_closed=2.000000\n"
"Guard in=default rsa_id=7B700C0C207EBD0002E00F499BE265519AC3C25A "
"nickname=dc6jgk11 sampled_on=2016-11-28T11:50:13 "
"sampled_by=0.3.0.0-alpha-dev "
"listed=1 confirmed_on=2016-11-24T08:45:30 confirmed_idx=1 "
"pb_circ_attempts=5.000000 pb_circ_successes=5.000000 "
"pb_successful_circuits_closed=5.000000\n"
"Guard in=default rsa_id=E9025AD60D86875D5F11548D536CC6AF60F0EF5E "
"nickname=maibrunn sampled_on=2016-11-25T22:36:38 "
"sampled_by=0.3.0.0-alpha-dev listed=1\n"
"Guard in=default rsa_id=DCD30B90BA3A792DA75DC54A327EF353FB84C38E "
"nickname=Unnamed sampled_on=2016-11-25T14:34:00 "
"sampled_by=0.3.0.0-alpha-dev listed=1\n"
"Guard in=wobblesome rsa_id=7B700C0C207EBD0002E00F499BE265519AC3C25A "
"nickname=dc6jgk11 sampled_on=2016-11-28T11:50:13 "
"sampled_by=0.3.0.0-alpha-dev "
"listed=1\n"
"Guard in=bridges rsa_id=8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF2E "
"bridge_addr=24.1.1.1:443 sampled_on=2016-11-25T06:44:14 "
"sampled_by=0.3.0.0-alpha-dev listed=1 "
"confirmed_on=2016-11-29T10:36:06 confirmed_idx=0 "
"pb_circ_attempts=8.000000 pb_circ_successes=8.000000 "
"pb_successful_circuits_closed=13.000000\n"
"Guard in=bridges rsa_id=5800000000000000000000000000000000000000 "
"bridge_addr=37.218.246.143:28366 "
"sampled_on=2016-11-18T15:07:34 sampled_by=0.3.0.0-alpha-dev listed=1\n");
done:
config_free_lines(lines);
tor_free(state);
tor_free(msg);
UNMOCK(get_or_state);
UNMOCK(entry_guard_is_listed);
SMARTLIST_FOREACH(text, char *, cp, tor_free(cp));
smartlist_free(text);
tor_free(joined);
}
static void
test_entry_guard_parse_from_state_broken(void *arg)
{
(void)arg;
/* Here's a variation on the previous state. Every line but the first is
* busted somehow. */
const char STATE[] =
/* Okay. */
"Guard in=default rsa_id=214F44BD5B638E8C817D47FF7C97397790BF0345 "
"nickname=TotallyNinja sampled_on=2016-11-12T19:32:49 "
"sampled_by=0.3.0.0-alpha-dev "
"listed=1\n"
/* No selection listed. */
"Guard rsa_id=052900AB0EA3ED54BAB84AE8A99E74E8693CE2B2 "
"nickname=5OfNovember sampled_on=2016-11-20T04:32:05 "
"sampled_by=0.3.0.0-alpha-dev "
"listed=1 confirmed_on=2016-11-22T08:13:28 confirmed_idx=0 "
"pb_circ_attempts=4.000000 pb_circ_successes=2.000000 "
"pb_successful_circuits_closed=2.000000\n"
/* Selection is "legacy"!! */
"Guard in=legacy rsa_id=7B700C0C207EBD0002E00F499BE265519AC3C25A "
"nickname=dc6jgk11 sampled_on=2016-11-28T11:50:13 "
"sampled_by=0.3.0.0-alpha-dev "
"listed=1 confirmed_on=2016-11-24T08:45:30 confirmed_idx=4 "
"pb_circ_attempts=5.000000 pb_circ_successes=5.000000 "
"pb_successful_circuits_closed=5.000000\n";
config_line_t *lines = NULL;
or_state_t *state = tor_malloc_zero(sizeof(or_state_t));
int r = config_get_lines(STATE, &lines, 0);
char *msg = NULL;
dummy_state = state;
MOCK(get_or_state,
get_or_state_replacement);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
prop271: Tests for the highlevel or_state_t encode/decode functions
2016-11-30 18:35:16 +01:00
tt_assert(lines);
state->Guard = lines;
/* First, no-set case. we should get an error. */
r = entry_guards_parse_state(state, 0, &msg);
tt_int_op(r, OP_LT, 0);
tt_ptr_op(msg, OP_NE, NULL);
/* And we shouldn't have made anything. */
guard_selection_t *gs_df =
get_guard_selection_by_name("default", GS_TYPE_NORMAL, 0);
tt_assert(gs_df == NULL);
tor_free(msg);
/* Now see about the set case (which shouldn't happen IRL) */
r = entry_guards_parse_state(state, 1, &msg);
tt_int_op(r, OP_LT, 0);
tt_ptr_op(msg, OP_NE, NULL);
gs_df = get_guard_selection_by_name("default", GS_TYPE_NORMAL, 0);
tt_assert(gs_df != NULL);
tt_int_op(smartlist_len(gs_df->sampled_entry_guards), OP_EQ, 1);
done:
config_free_lines(lines);
tor_free(state);
tor_free(msg);
UNMOCK(get_or_state);
}
Test get_guard_selection_by_name
2016-11-23 21:08:07 +01:00
static void
test_entry_guard_get_guard_selection_by_name(void *arg)
{
(void)arg;
guard_selection_t *gs1, *gs2, *gs3;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
gs1 = get_guard_selection_by_name("unlikely", GS_TYPE_NORMAL, 0);
Test get_guard_selection_by_name
2016-11-23 21:08:07 +01:00
tt_assert(gs1 == NULL);
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
gs1 = get_guard_selection_by_name("unlikely", GS_TYPE_NORMAL, 1);
Test get_guard_selection_by_name
2016-11-23 21:08:07 +01:00
tt_assert(gs1 != NULL);
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
gs2 = get_guard_selection_by_name("unlikely", GS_TYPE_NORMAL, 1);
Test get_guard_selection_by_name
2016-11-23 21:08:07 +01:00
tt_assert(gs2 == gs1);
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
gs2 = get_guard_selection_by_name("unlikely", GS_TYPE_NORMAL, 0);
Test get_guard_selection_by_name
2016-11-23 21:08:07 +01:00
tt_assert(gs2 == gs1);
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
gs2 = get_guard_selection_by_name("implausible", GS_TYPE_NORMAL, 0);
Test get_guard_selection_by_name
2016-11-23 21:08:07 +01:00
tt_assert(gs2 == NULL);
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
gs2 = get_guard_selection_by_name("implausible", GS_TYPE_NORMAL, 1);
Test get_guard_selection_by_name
2016-11-23 21:08:07 +01:00
tt_assert(gs2 != NULL);
tt_assert(gs2 != gs1);
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
gs3 = get_guard_selection_by_name("implausible", GS_TYPE_NORMAL, 0);
Test get_guard_selection_by_name
2016-11-23 21:08:07 +01:00
tt_assert(gs3 == gs2);
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
gs3 = get_guard_selection_by_name("default", GS_TYPE_NORMAL, 0);
Test get_guard_selection_by_name
2016-11-23 21:08:07 +01:00
tt_assert(gs3 == NULL);
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
gs3 = get_guard_selection_by_name("default", GS_TYPE_NORMAL, 1);
Test get_guard_selection_by_name
2016-11-23 21:08:07 +01:00
tt_assert(gs3 != NULL);
tt_assert(gs3 != gs2);
tt_assert(gs3 != gs1);
Re-enable some disabled tests about switching guard_selections
2016-11-29 20:28:43 +01:00
tt_assert(gs3 == get_guard_selection_info());
Test get_guard_selection_by_name
2016-11-23 21:08:07 +01:00
done:
entry_guards_free_all();
}
Tests for choosing which guard_selection to use
2016-11-30 20:11:36 +01:00
static void
test_entry_guard_choose_selection_initial(void *arg)
{
/* Tests for picking our initial guard selection (based on having had
* no previous selection */
(void)arg;
guard_selection_type_t type = GS_TYPE_INFER;
const char *name = choose_guard_selection(get_options(),
dummy_consensus, NULL, &type);
tt_str_op(name, OP_EQ, "default");
tt_int_op(type, OP_EQ, GS_TYPE_NORMAL);
/* If we're using bridges, we get the bridge selection. */
get_options_mutable()->UseBridges = 1;
name = choose_guard_selection(get_options(),
dummy_consensus, NULL, &type);
tt_str_op(name, OP_EQ, "bridges");
tt_int_op(type, OP_EQ, GS_TYPE_BRIDGE);
get_options_mutable()->UseBridges = 0;
/* If we discard >99% of our guards, though, we should be in the restricted
* set. */
tt_assert(get_options_mutable()->EntryNodes == NULL);
get_options_mutable()->EntryNodes = routerset_new();
routerset_parse(get_options_mutable()->EntryNodes, "1.0.0.0/8", "foo");
name = choose_guard_selection(get_options(),
dummy_consensus, NULL, &type);
tt_str_op(name, OP_EQ, "restricted");
tt_int_op(type, OP_EQ, GS_TYPE_RESTRICTED);
done:
;
}
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
static void
test_entry_guard_add_single_guard(void *arg)
{
(void)arg;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
/* 1: Add a single guard to the sample. */
node_t *n1 = smartlist_get(big_fake_net_nodes, 0);
time_t now = approx_time();
tt_assert(n1->is_possible_guard == 1);
entry_guard_t *g1 = entry_guard_add_to_sample(gs, n1);
tt_assert(g1);
/* Make sure its fields look right. */
tt_mem_op(n1->identity, OP_EQ, g1->identity, DIGEST_LEN);
tt_i64_op(g1->sampled_on_date, OP_GE, now - 12*86400);
tt_i64_op(g1->sampled_on_date, OP_LE, now);
tt_str_op(g1->sampled_by_version, OP_EQ, VERSION);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_uint_op(g1->currently_listed, OP_EQ, 1);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_i64_op(g1->confirmed_on_date, OP_EQ, 0);
tt_int_op(g1->confirmed_idx, OP_EQ, -1);
tt_int_op(g1->last_tried_to_connect, OP_EQ, 0);
tt_uint_op(g1->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
tt_i64_op(g1->failing_since, OP_EQ, 0);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_uint_op(g1->is_filtered_guard, OP_EQ, 1);
tt_uint_op(g1->is_usable_filtered_guard, OP_EQ, 1);
tt_uint_op(g1->is_primary, OP_EQ, 0);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_assert(g1->extra_state_fields == NULL);
/* Make sure it got added. */
tt_int_op(1, OP_EQ, smartlist_len(gs->sampled_entry_guards));
tt_ptr_op(g1, OP_EQ, smartlist_get(gs->sampled_entry_guards, 0));
tt_ptr_op(g1, OP_EQ, get_sampled_guard_with_id(gs, (uint8_t*)n1->identity));
const uint8_t bad_id[20] = {0};
tt_ptr_op(NULL, OP_EQ, get_sampled_guard_with_id(gs, bad_id));
done:
guard_selection_free(gs);
}
static void
test_entry_guard_node_filter(void *arg)
{
(void)arg;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
bridge_line_t *bl = NULL;
/* Initialize a bunch of node objects that are all guards. */
Fix another pointless stack-protector warning. This is the same as we fixed in 39f455468731d4746adb729a67.
2016-12-16 20:06:25 +01:00
#define NUM 7
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
node_t *n[NUM];
entry_guard_t *g[NUM];
int i;
for (i=0; i < NUM; ++i) {
n[i] = smartlist_get(big_fake_net_nodes, i*2); // even ones are guards.
g[i] = entry_guard_add_to_sample(gs, n[i]);
// everything starts out filtered-in
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_uint_op(g[i]->is_filtered_guard, OP_EQ, 1);
tt_uint_op(g[i]->is_usable_filtered_guard, OP_EQ, 1);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
}
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
tt_int_op(num_reachable_filtered_guards(gs, NULL), OP_EQ, NUM);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
/* Make sure refiltering doesn't hurt */
entry_guards_update_filtered_sets(gs);
for (i = 0; i < NUM; ++i) {
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_uint_op(g[i]->is_filtered_guard, OP_EQ, 1);
tt_uint_op(g[i]->is_usable_filtered_guard, OP_EQ, 1);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
}
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
tt_int_op(num_reachable_filtered_guards(gs, NULL), OP_EQ, NUM);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
/* Now start doing things to make the guards get filtered out, 1 by 1. */
/* 0: Not listed. */
g[0]->currently_listed = 0;
/* 1: path bias says this guard is maybe eeeevil. */
g[1]->pb.path_bias_disabled = 1;
/* 2: Unreachable address. */
n[2]->rs->addr = 0;
/* 3: ExcludeNodes */
n[3]->rs->addr = 0x90902020;
routerset_free(get_options_mutable()->ExcludeNodes);
get_options_mutable()->ExcludeNodes = routerset_new();
routerset_parse(get_options_mutable()->ExcludeNodes, "144.144.0.0/16", "");
/* 4: Bridge. */
sweep_bridge_list();
bl = tor_malloc_zero(sizeof(bridge_line_t));
tor_addr_from_ipv4h(&bl->addr, n[4]->rs->addr);
bl->port = n[4]->rs->or_port;
memcpy(bl->digest, n[4]->identity, 20);
bridge_add_from_config(bl);
bl = NULL; // prevent free.
/* 5: Unreachable. This stays in the filter, but isn't in usable-filtered */
g[5]->last_tried_to_connect = approx_time(); // prevent retry.
g[5]->is_reachable = GUARD_REACHABLE_NO;
/* 6: no change. */
/* Now refilter and inspect. */
entry_guards_update_filtered_sets(gs);
for (i = 0; i < NUM; ++i) {
tt_assert(g[i]->is_filtered_guard == (i == 5 || i == 6));
tt_assert(g[i]->is_usable_filtered_guard == (i == 6));
}
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
tt_int_op(num_reachable_filtered_guards(gs, NULL), OP_EQ, 1);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
Test no-consensus case for filter.
2016-11-23 21:32:48 +01:00
/* Now make sure we have no live consensus, and no nodes. Nothing should
* pass the filter any more. */
tor_free(dummy_consensus);
dummy_consensus = NULL;
SMARTLIST_FOREACH(big_fake_net_nodes, node_t *, node, {
memset(node->identity, 0xff, 20);
});
entry_guards_update_filtered_sets(gs);
for (i = 0; i < NUM; ++i) {
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_uint_op(g[i]->is_filtered_guard, OP_EQ, 0);
tt_uint_op(g[i]->is_usable_filtered_guard, OP_EQ, 0);
Test no-consensus case for filter.
2016-11-23 21:32:48 +01:00
}
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
tt_int_op(num_reachable_filtered_guards(gs, NULL), OP_EQ, 0);
Test no-consensus case for filter.
2016-11-23 21:32:48 +01:00
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
done:
guard_selection_free(gs);
tor_free(bl);
Fix another pointless stack-protector warning. This is the same as we fixed in 39f455468731d4746adb729a67.
2016-12-16 20:06:25 +01:00
#undef NUM
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
}
static void
test_entry_guard_expand_sample(void *arg)
{
(void)arg;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
digestmap_t *node_by_id = digestmap_new();
entry_guard_t *guard = entry_guards_expand_sample(gs);
tt_assert(guard); // the last guard returned.
// Every sampled guard here should be filtered and reachable for now.
tt_int_op(smartlist_len(gs->sampled_entry_guards), OP_EQ,
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
num_reachable_filtered_guards(gs, NULL));
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
/* Make sure we got the right number. */
Turn #defines for prop271 into networkstatus params Some of these will get torrc options to override them too; this is just the mechanical conversion. Also, add documentation for a couple of undocumented (but now used) parameters.
2016-11-26 16:06:50 +01:00
tt_int_op(DFLT_MIN_FILTERED_SAMPLE_SIZE, OP_EQ,
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
num_reachable_filtered_guards(gs, NULL));
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
// Make sure everything we got was from our fake node list, and everything
// was unique.
SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, g) {
const node_t *n = bfn_mock_node_get_by_id(g->identity);
tt_assert(n);
tt_ptr_op(NULL, OP_EQ, digestmap_get(node_by_id, g->identity));
digestmap_set(node_by_id, g->identity, (void*) n);
int idx = smartlist_pos(big_fake_net_nodes, n);
// The even ones are the guards; make sure we got guards.
tt_int_op(idx & 1, OP_EQ, 0);
} SMARTLIST_FOREACH_END(g);
// Nothing became unusable/unfiltered, so a subsequent expand should
// make no changes.
guard = entry_guards_expand_sample(gs);
tt_assert(! guard); // no guard was added.
Turn #defines for prop271 into networkstatus params Some of these will get torrc options to override them too; this is just the mechanical conversion. Also, add documentation for a couple of undocumented (but now used) parameters.
2016-11-26 16:06:50 +01:00
tt_int_op(DFLT_MIN_FILTERED_SAMPLE_SIZE, OP_EQ,
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
num_reachable_filtered_guards(gs, NULL));
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
// Make a few guards unreachable.
guard = smartlist_get(gs->sampled_entry_guards, 0);
guard->is_usable_filtered_guard = 0;
guard = smartlist_get(gs->sampled_entry_guards, 1);
guard->is_usable_filtered_guard = 0;
guard = smartlist_get(gs->sampled_entry_guards, 2);
guard->is_usable_filtered_guard = 0;
Turn #defines for prop271 into networkstatus params Some of these will get torrc options to override them too; this is just the mechanical conversion. Also, add documentation for a couple of undocumented (but now used) parameters.
2016-11-26 16:06:50 +01:00
tt_int_op(DFLT_MIN_FILTERED_SAMPLE_SIZE - 3, OP_EQ,
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
num_reachable_filtered_guards(gs, NULL));
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
// This time, expanding the sample will add some more guards.
guard = entry_guards_expand_sample(gs);
tt_assert(guard); // no guard was added.
Turn #defines for prop271 into networkstatus params Some of these will get torrc options to override them too; this is just the mechanical conversion. Also, add documentation for a couple of undocumented (but now used) parameters.
2016-11-26 16:06:50 +01:00
tt_int_op(DFLT_MIN_FILTERED_SAMPLE_SIZE, OP_EQ,
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
num_reachable_filtered_guards(gs, NULL));
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_int_op(smartlist_len(gs->sampled_entry_guards), OP_EQ,
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
num_reachable_filtered_guards(gs, NULL)+3);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
// Still idempotent.
guard = entry_guards_expand_sample(gs);
tt_assert(! guard); // no guard was added.
Turn #defines for prop271 into networkstatus params Some of these will get torrc options to override them too; this is just the mechanical conversion. Also, add documentation for a couple of undocumented (but now used) parameters.
2016-11-26 16:06:50 +01:00
tt_int_op(DFLT_MIN_FILTERED_SAMPLE_SIZE, OP_EQ,
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
num_reachable_filtered_guards(gs, NULL));
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
// Now, do a nasty trick: tell the filter to exclude 31/32 of the guards.
// This will cause the sample size to get reeeeally huge, while the
// filtered sample size grows only slowly.
routerset_free(get_options_mutable()->ExcludeNodes);
get_options_mutable()->ExcludeNodes = routerset_new();
routerset_parse(get_options_mutable()->ExcludeNodes, "144.144.0.0/16", "");
SMARTLIST_FOREACH(big_fake_net_nodes, node_t *, n, {
if (n_sl_idx % 64 != 0) {
n->rs->addr = 0x90903030;
}
});
entry_guards_update_filtered_sets(gs);
// Surely (p ~ 1-2**-60), one of our guards has been excluded.
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
tt_int_op(num_reachable_filtered_guards(gs, NULL), OP_LT,
Turn #defines for prop271 into networkstatus params Some of these will get torrc options to override them too; this is just the mechanical conversion. Also, add documentation for a couple of undocumented (but now used) parameters.
2016-11-26 16:06:50 +01:00
DFLT_MIN_FILTERED_SAMPLE_SIZE);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
// Try to regenerate the guards.
guard = entry_guards_expand_sample(gs);
tt_assert(guard); // no guard was added.
/* this time, it's possible that we didn't add enough sampled guards. */
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
tt_int_op(num_reachable_filtered_guards(gs, NULL), OP_LE,
Turn #defines for prop271 into networkstatus params Some of these will get torrc options to override them too; this is just the mechanical conversion. Also, add documentation for a couple of undocumented (but now used) parameters.
2016-11-26 16:06:50 +01:00
DFLT_MIN_FILTERED_SAMPLE_SIZE);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
/* but we definitely didn't exceed the sample maximum. */
Resolve some coverity complaints in test_entrynodes.c
2016-12-16 18:23:46 +01:00
const int n_guards = 271 / 2;
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_int_op(smartlist_len(gs->sampled_entry_guards), OP_LE,
Resolve some coverity complaints in test_entrynodes.c
2016-12-16 18:23:46 +01:00
(int)(n_guards * .3));
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
done:
guard_selection_free(gs);
digestmap_free(node_by_id, NULL);
}
static void
test_entry_guard_expand_sample_small_net(void *arg)
{
(void)arg;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
/* Fun corner case: not enough guards to make up our whole sample size. */
SMARTLIST_FOREACH(big_fake_net_nodes, node_t *, n, {
Repair unit test for tiny-network case. The test assumed that the old rules about handling small max_sample were in effect, and didn't actually handle that case very well anyway.
2016-11-30 15:19:10 +01:00
if (n_sl_idx >= 15) {
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tor_free(n->rs);
tor_free(n->md);
tor_free(n);
SMARTLIST_DEL_CURRENT(big_fake_net_nodes, n);
} else {
n->rs->addr = 0; // make the filter reject this.
}
});
entry_guard_t *guard = entry_guards_expand_sample(gs);
tt_assert(guard); // the last guard returned -- some guard was added.
Repair unit test for tiny-network case. The test assumed that the old rules about handling small max_sample were in effect, and didn't actually handle that case very well anyway.
2016-11-30 15:19:10 +01:00
// half the nodes are guards, so we have 8 guards left. The set
// is small, so we sampled everything.
tt_int_op(smartlist_len(gs->sampled_entry_guards), OP_EQ, 8);
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
tt_int_op(num_reachable_filtered_guards(gs, NULL), OP_EQ, 0);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
done:
guard_selection_free(gs);
}
static void
test_entry_guard_update_from_consensus_status(void *arg)
{
/* Here we're going to have some nodes become un-guardy, and say we got a
* new consensus. This should cause those nodes to get detected as
* unreachable. */
(void)arg;
int i;
time_t start = approx_time();
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
networkstatus_t *ns_tmp = NULL;
/* Don't randomly backdate stuff; it will make correctness harder to check.*/
MOCK(randomize_time, mock_randomize_time_no_randomization);
/* First, sample some guards. */
entry_guards_expand_sample(gs);
int n_sampled_pre = smartlist_len(gs->sampled_entry_guards);
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
int n_filtered_pre = num_reachable_filtered_guards(gs, NULL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_i64_op(n_sampled_pre, OP_EQ, n_filtered_pre);
tt_i64_op(n_sampled_pre, OP_GT, 10);
/* At this point, it should be a no-op to do this: */
sampled_guards_update_from_consensus(gs);
/* Now let's make some of our guards become unlisted. The easiest way to
* do that would be to take away their guard flag. */
for (i = 0; i < 5; ++i) {
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, i);
node_t *n = (node_t*) bfn_mock_node_get_by_id(g->identity);
n->is_possible_guard = 0;
}
update_approx_time(start + 30);
{
/* try this with no live networkstatus. Nothing should happen! */
ns_tmp = dummy_consensus;
dummy_consensus = NULL;
sampled_guards_update_from_consensus(gs);
tt_i64_op(smartlist_len(gs->sampled_entry_guards), OP_EQ, n_sampled_pre);
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
tt_i64_op(num_reachable_filtered_guards(gs, NULL), OP_EQ, n_filtered_pre);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
/* put the networkstatus back. */
dummy_consensus = ns_tmp;
ns_tmp = NULL;
}
/* Now those guards should become unlisted, and drop off the filter, but
* stay in the sample. */
update_approx_time(start + 60);
sampled_guards_update_from_consensus(gs);
tt_i64_op(smartlist_len(gs->sampled_entry_guards), OP_EQ, n_sampled_pre);
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
tt_i64_op(num_reachable_filtered_guards(gs, NULL), OP_EQ, n_filtered_pre-5);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
for (i = 0; i < 5; ++i) {
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, i);
tt_assert(! g->currently_listed);
tt_i64_op(g->unlisted_since_date, OP_EQ, start+60);
}
for (i = 5; i < n_sampled_pre; ++i) {
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, i);
tt_assert(g->currently_listed);
tt_i64_op(g->unlisted_since_date, OP_EQ, 0);
}
/* Now re-list one, and remove one completely. */
{
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, 0);
node_t *n = (node_t*) bfn_mock_node_get_by_id(g->identity);
n->is_possible_guard = 1;
}
{
/* try removing the node, to make sure we don't crash on an absent node
*/
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, 5);
node_t *n = (node_t*) bfn_mock_node_get_by_id(g->identity);
smartlist_remove(big_fake_net_nodes, n);
tor_free(n->rs);
tor_free(n->md);
tor_free(n);
}
update_approx_time(start + 300);
sampled_guards_update_from_consensus(gs);
/* guards 1..5 are now unlisted; 0,6,7.. are listed. */
tt_i64_op(smartlist_len(gs->sampled_entry_guards), OP_EQ, n_sampled_pre);
for (i = 1; i < 6; ++i) {
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, i);
tt_assert(! g->currently_listed);
if (i == 5)
tt_i64_op(g->unlisted_since_date, OP_EQ, start+300);
else
tt_i64_op(g->unlisted_since_date, OP_EQ, start+60);
}
for (i = 0; i < n_sampled_pre; i = (!i) ? 6 : i+1) { /* 0,6,7,8, ... */
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, i);
tt_assert(g->currently_listed);
tt_i64_op(g->unlisted_since_date, OP_EQ, 0);
}
done:
tor_free(ns_tmp); /* in case we couldn't put it back */
guard_selection_free(gs);
UNMOCK(randomize_time);
}
static void
test_entry_guard_update_from_consensus_repair(void *arg)
{
/* Here we'll make sure that our code to repair the unlisted-since
* times is correct. */
(void)arg;
int i;
time_t start = approx_time();
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
/* Don't randomly backdate stuff; it will make correctness harder to check.*/
MOCK(randomize_time, mock_randomize_time_no_randomization);
/* First, sample some guards. */
entry_guards_expand_sample(gs);
int n_sampled_pre = smartlist_len(gs->sampled_entry_guards);
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
int n_filtered_pre = num_reachable_filtered_guards(gs, NULL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_i64_op(n_sampled_pre, OP_EQ, n_filtered_pre);
tt_i64_op(n_sampled_pre, OP_GT, 10);
/* Now corrupt the list a bit. Call some unlisted-since-never, and some
* listed-and-unlisted-since-a-time. */
update_approx_time(start + 300);
for (i = 0; i < 3; ++i) {
/* these will get a date. */
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, i);
node_t *n = (node_t*) bfn_mock_node_get_by_id(g->identity);
n->is_possible_guard = 0;
g->currently_listed = 0;
}
for (i = 3; i < 6; ++i) {
/* these will become listed. */
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, i);
g->unlisted_since_date = start+100;
}
setup_full_capture_of_logs(LOG_WARN);
sampled_guards_update_from_consensus(gs);
expect_log_msg_containing(
"was listed, but with unlisted_since_date set");
expect_log_msg_containing(
"was unlisted, but with unlisted_since_date unset");
teardown_capture_of_logs();
tt_int_op(smartlist_len(gs->sampled_entry_guards), OP_EQ, n_sampled_pre);
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
tt_int_op(num_reachable_filtered_guards(gs, NULL), OP_EQ, n_filtered_pre-3);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
for (i = 3; i < n_sampled_pre; ++i) {
/* these will become listed. */
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, i);
if (i < 3) {
tt_assert(! g->currently_listed);
tt_i64_op(g->unlisted_since_date, OP_EQ, start+300);
} else {
tt_assert(g->currently_listed);
tt_i64_op(g->unlisted_since_date, OP_EQ, 0);
}
}
done:
teardown_capture_of_logs();
guard_selection_free(gs);
UNMOCK(randomize_time);
}
static void
test_entry_guard_update_from_consensus_remove(void *arg)
{
/* Now let's check the logic responsible for removing guards from the
* sample entirely. */
(void)arg;
//int i;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
smartlist_t *keep_ids = smartlist_new();
smartlist_t *remove_ids = smartlist_new();
/* Don't randomly backdate stuff; it will make correctness harder to check.*/
MOCK(randomize_time, mock_randomize_time_no_randomization);
/* First, sample some guards. */
entry_guards_expand_sample(gs);
int n_sampled_pre = smartlist_len(gs->sampled_entry_guards);
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
int n_filtered_pre = num_reachable_filtered_guards(gs, NULL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_i64_op(n_sampled_pre, OP_EQ, n_filtered_pre);
tt_i64_op(n_sampled_pre, OP_GT, 10);
const time_t one_day_ago = approx_time() - 1*24*60*60;
const time_t one_year_ago = approx_time() - 365*24*60*60;
const time_t two_years_ago = approx_time() - 2*365*24*60*60;
/* 0: unlisted for a day. (keep this) */
{
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, 0);
node_t *n = (node_t*) bfn_mock_node_get_by_id(g->identity);
n->is_possible_guard = 0;
g->currently_listed = 0;
g->unlisted_since_date = one_day_ago;
smartlist_add(keep_ids, tor_memdup(g->identity, 20));
}
/* 1: unlisted for a year. (remove this) */
{
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, 1);
node_t *n = (node_t*) bfn_mock_node_get_by_id(g->identity);
n->is_possible_guard = 0;
g->currently_listed = 0;
g->unlisted_since_date = one_year_ago;
smartlist_add(remove_ids, tor_memdup(g->identity, 20));
}
/* 2: added a day ago, never confirmed. (keep this) */
{
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, 2);
g->sampled_on_date = one_day_ago;
smartlist_add(keep_ids, tor_memdup(g->identity, 20));
}
/* 3: added a year ago, never confirmed. (remove this) */
{
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, 3);
g->sampled_on_date = one_year_ago;
smartlist_add(remove_ids, tor_memdup(g->identity, 20));
}
/* 4: added two year ago, confirmed yesterday, primary. (keep this.) */
{
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, 4);
g->sampled_on_date = one_year_ago;
g->confirmed_on_date = one_day_ago;
g->confirmed_idx = 0;
g->is_primary = 1;
smartlist_add(gs->confirmed_entry_guards, g);
smartlist_add(gs->primary_entry_guards, g);
smartlist_add(keep_ids, tor_memdup(g->identity, 20));
}
/* 5: added two years ago, confirmed a year ago, primary. (remove this) */
{
entry_guard_t *g = smartlist_get(gs->sampled_entry_guards, 5);
g->sampled_on_date = two_years_ago;
g->confirmed_on_date = one_year_ago;
g->confirmed_idx = 1;
g->is_primary = 1;
smartlist_add(gs->confirmed_entry_guards, g);
smartlist_add(gs->primary_entry_guards, g);
smartlist_add(remove_ids, tor_memdup(g->identity, 20));
}
sampled_guards_update_from_consensus(gs);
/* Did we remove the right ones? */
SMARTLIST_FOREACH(keep_ids, uint8_t *, id, {
tt_assert(get_sampled_guard_with_id(gs, id) != NULL);
});
SMARTLIST_FOREACH(remove_ids, uint8_t *, id, {
tt_want(get_sampled_guard_with_id(gs, id) == NULL);
});
/* Did we remove the right number? */
tt_int_op(smartlist_len(gs->sampled_entry_guards), OP_EQ, n_sampled_pre - 3);
done:
guard_selection_free(gs);
UNMOCK(randomize_time);
SMARTLIST_FOREACH(keep_ids, char *, cp, tor_free(cp));
SMARTLIST_FOREACH(remove_ids, char *, cp, tor_free(cp));
smartlist_free(keep_ids);
smartlist_free(remove_ids);
}
static void
test_entry_guard_confirming_guards(void *arg)
{
(void)arg;
/* Now let's check the logic responsible for manipulating the list
* of confirmed guards */
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
MOCK(randomize_time, mock_randomize_time_no_randomization);
/* Create the sample. */
entry_guards_expand_sample(gs);
/* Confirm a few guards. */
time_t start = approx_time();
entry_guard_t *g1 = smartlist_get(gs->sampled_entry_guards, 0);
entry_guard_t *g2 = smartlist_get(gs->sampled_entry_guards, 1);
entry_guard_t *g3 = smartlist_get(gs->sampled_entry_guards, 8);
make_guard_confirmed(gs, g2);
update_approx_time(start + 10);
make_guard_confirmed(gs, g1);
make_guard_confirmed(gs, g3);
/* Were the correct dates and indices fed in? */
tt_int_op(g1->confirmed_idx, OP_EQ, 1);
tt_int_op(g2->confirmed_idx, OP_EQ, 0);
tt_int_op(g3->confirmed_idx, OP_EQ, 2);
tt_i64_op(g1->confirmed_on_date, OP_EQ, start+10);
tt_i64_op(g2->confirmed_on_date, OP_EQ, start);
tt_i64_op(g3->confirmed_on_date, OP_EQ, start+10);
tt_ptr_op(smartlist_get(gs->confirmed_entry_guards, 0), OP_EQ, g2);
tt_ptr_op(smartlist_get(gs->confirmed_entry_guards, 1), OP_EQ, g1);
tt_ptr_op(smartlist_get(gs->confirmed_entry_guards, 2), OP_EQ, g3);
/* Now make sure we can regenerate the confirmed_entry_guards list. */
smartlist_clear(gs->confirmed_entry_guards);
g2->confirmed_idx = 0;
g1->confirmed_idx = 10;
g3->confirmed_idx = 100;
entry_guards_update_confirmed(gs);
tt_int_op(g1->confirmed_idx, OP_EQ, 1);
tt_int_op(g2->confirmed_idx, OP_EQ, 0);
tt_int_op(g3->confirmed_idx, OP_EQ, 2);
tt_ptr_op(smartlist_get(gs->confirmed_entry_guards, 0), OP_EQ, g2);
tt_ptr_op(smartlist_get(gs->confirmed_entry_guards, 1), OP_EQ, g1);
tt_ptr_op(smartlist_get(gs->confirmed_entry_guards, 2), OP_EQ, g3);
/* Now make sure we can regenerate the confirmed_entry_guards list if
* the indices are messed up. */
g1->confirmed_idx = g2->confirmed_idx = g3->confirmed_idx = 999;
smartlist_clear(gs->confirmed_entry_guards);
entry_guards_update_confirmed(gs);
tt_int_op(g1->confirmed_idx, OP_GE, 0);
tt_int_op(g2->confirmed_idx, OP_GE, 0);
tt_int_op(g3->confirmed_idx, OP_GE, 0);
tt_int_op(g1->confirmed_idx, OP_LE, 2);
tt_int_op(g2->confirmed_idx, OP_LE, 2);
tt_int_op(g3->confirmed_idx, OP_LE, 2);
g1 = smartlist_get(gs->confirmed_entry_guards, 0);
g2 = smartlist_get(gs->confirmed_entry_guards, 1);
g3 = smartlist_get(gs->confirmed_entry_guards, 2);
tt_int_op(g1->confirmed_idx, OP_EQ, 0);
tt_int_op(g2->confirmed_idx, OP_EQ, 1);
tt_int_op(g3->confirmed_idx, OP_EQ, 2);
tt_assert(g1 != g2);
tt_assert(g1 != g3);
tt_assert(g2 != g3);
done:
UNMOCK(randomize_time);
guard_selection_free(gs);
}
static void
test_entry_guard_sample_reachable_filtered(void *arg)
{
(void)arg;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
entry_guards_expand_sample(gs);
const int N = 10000;
bitarray_t *selected = NULL;
int i, j;
/* We've got a sampled list now; let's make one non-usable-filtered; some
* confirmed, some primary, some pending.
*/
int n_guards = smartlist_len(gs->sampled_entry_guards);
tt_int_op(n_guards, OP_GT, 10);
entry_guard_t *g;
g = smartlist_get(gs->sampled_entry_guards, 0);
g->is_pending = 1;
g = smartlist_get(gs->sampled_entry_guards, 1);
make_guard_confirmed(gs, g);
g = smartlist_get(gs->sampled_entry_guards, 2);
g->is_primary = 1;
g = smartlist_get(gs->sampled_entry_guards, 3);
g->pb.path_bias_disabled = 1;
entry_guards_update_filtered_sets(gs);
Make sure primary-guards are up-to-date when we inspect them. (Plus some magic to prevent and detect recursive invocation of entry_guards_update_primary(), since that can cause some pretty tricky misbehavior.)
2016-11-23 16:04:23 +01:00
gs->primary_guards_up_to_date = 1;
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
tt_int_op(num_reachable_filtered_guards(gs, NULL), OP_EQ, n_guards - 1);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_int_op(smartlist_len(gs->sampled_entry_guards), OP_EQ, n_guards);
// +1 since the one we made disabled will make another one get added.
++n_guards;
/* Try a bunch of selections. */
const struct {
int flag; int idx;
} tests[] = {
{ 0, -1 },
{ SAMPLE_EXCLUDE_CONFIRMED, 1 },
Make sure primary-guards are up-to-date when we inspect them. (Plus some magic to prevent and detect recursive invocation of entry_guards_update_primary(), since that can cause some pretty tricky misbehavior.)
2016-11-23 16:04:23 +01:00
{ SAMPLE_EXCLUDE_PRIMARY|SAMPLE_NO_UPDATE_PRIMARY, 2 },
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
{ SAMPLE_EXCLUDE_PENDING, 0 },
{ -1, -1},
};
for (j = 0; tests[j].flag >= 0; ++j) {
selected = bitarray_init_zero(n_guards);
const int excluded_flags = tests[j].flag;
const int excluded_idx = tests[j].idx;
for (i = 0; i < N; ++i) {
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
g = sample_reachable_filtered_entry_guards(gs, NULL, excluded_flags);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tor_assert(g);
int pos = smartlist_pos(gs->sampled_entry_guards, g);
tt_int_op(smartlist_len(gs->sampled_entry_guards), OP_EQ, n_guards);
tt_int_op(pos, OP_GE, 0);
tt_int_op(pos, OP_LT, n_guards);
bitarray_set(selected, pos);
}
for (i = 0; i < n_guards; ++i) {
const int should_be_set = (i != excluded_idx &&
i != 3); // filtered out.
tt_int_op(!!bitarray_is_set(selected, i), OP_EQ, should_be_set);
}
bitarray_free(selected);
selected = NULL;
}
done:
guard_selection_free(gs);
bitarray_free(selected);
}
static void
test_entry_guard_sample_reachable_filtered_empty(void *arg)
{
(void)arg;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
/* What if we try to sample from a set of 0? */
SMARTLIST_FOREACH(big_fake_net_nodes, node_t *, n,
n->is_possible_guard = 0);
Implement support for per-circuit guard restrictions. This is an important thing I hadn't considered when writing prop271: sometimes you have to restrict what guard you use for a particular circuit. Most frequently, that would be because you plan to use a certain node as your exit, and so you can't choose that for your guard. This change means that the upgrade-waiting-circuits algorithm needs a slight tweak too: circuit A cannot block circuit B from upgrading if circuit B needs to follow a restriction that circuit A does not follow.
2016-11-30 14:49:39 +01:00
entry_guard_t *g = sample_reachable_filtered_entry_guards(gs, NULL, 0);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_ptr_op(g, OP_EQ, NULL);
done:
guard_selection_free(gs);
}
static void
test_entry_guard_retry_unreachable(void *arg)
{
(void)arg;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
entry_guards_expand_sample(gs);
/* Let's say that we have two guards, and they're down.
*/
time_t start = approx_time();;
entry_guard_t *g1 = smartlist_get(gs->sampled_entry_guards, 0);
entry_guard_t *g2 = smartlist_get(gs->sampled_entry_guards, 1);
entry_guard_t *g3 = smartlist_get(gs->sampled_entry_guards, 2);
g1->is_reachable = GUARD_REACHABLE_NO;
g2->is_reachable = GUARD_REACHABLE_NO;
g1->is_primary = 1;
g1->failing_since = g2->failing_since = start;
g1->last_tried_to_connect = g2->last_tried_to_connect = start;
/* Wait 5 minutes. Nothing will get retried. */
update_approx_time(start + 5 * 60);
entry_guard_consider_retry(g1);
entry_guard_consider_retry(g2);
entry_guard_consider_retry(g3); // just to make sure this doesn't crash.
tt_int_op(g1->is_reachable, OP_EQ, GUARD_REACHABLE_NO);
tt_int_op(g2->is_reachable, OP_EQ, GUARD_REACHABLE_NO);
tt_int_op(g3->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
/* After 30 min, the primary one gets retried */
update_approx_time(start + 35 * 60);
entry_guard_consider_retry(g1);
entry_guard_consider_retry(g2);
tt_int_op(g1->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
tt_int_op(g2->is_reachable, OP_EQ, GUARD_REACHABLE_NO);
g1->is_reachable = GUARD_REACHABLE_NO;
Fix broken entrynodes/retry_unreachable test I broke this with 20292ec4974b777d430e7962cc38349c5f82b220 when I changed the primary guard retry schedule.
2016-12-16 17:49:07 +01:00
g1->last_tried_to_connect = start + 55*60;
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
/* After 1 hour, we'll retry the nonprimary one. */
update_approx_time(start + 61 * 60);
entry_guard_consider_retry(g1);
entry_guard_consider_retry(g2);
tt_int_op(g1->is_reachable, OP_EQ, GUARD_REACHABLE_NO);
tt_int_op(g2->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
g2->is_reachable = GUARD_REACHABLE_NO;
g2->last_tried_to_connect = start + 61*60;
/* And then the primary one again. */
update_approx_time(start + 66 * 60);
entry_guard_consider_retry(g1);
entry_guard_consider_retry(g2);
tt_int_op(g1->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
tt_int_op(g2->is_reachable, OP_EQ, GUARD_REACHABLE_NO);
done:
guard_selection_free(gs);
}
static void
test_entry_guard_manage_primary(void *arg)
{
(void)arg;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
smartlist_t *prev_guards = smartlist_new();
/* If no guards are confirmed, we should pick a few reachable guards and
* call them all primary. But not confirmed.*/
entry_guards_update_primary(gs);
int n_primary = smartlist_len(gs->primary_entry_guards);
tt_int_op(n_primary, OP_GE, 1);
SMARTLIST_FOREACH(gs->primary_entry_guards, entry_guard_t *, g, {
tt_assert(g->is_primary);
tt_assert(g->confirmed_idx == -1);
});
/* Calling it a second time should leave the guards unchanged. */
smartlist_add_all(prev_guards, gs->primary_entry_guards);
entry_guards_update_primary(gs);
tt_int_op(smartlist_len(gs->primary_entry_guards), OP_EQ, n_primary);
SMARTLIST_FOREACH(gs->primary_entry_guards, entry_guard_t *, g, {
tt_ptr_op(g, OP_EQ, smartlist_get(prev_guards, g_sl_idx));
});
/* If we have one confirmed guard, that guards becomes the first primary
* guard, and the other primary guards get kept. */
/* find a non-primary guard... */
entry_guard_t *confirmed = NULL;
SMARTLIST_FOREACH(gs->sampled_entry_guards, entry_guard_t *, g, {
if (! g->is_primary) {
confirmed = g;
break;
}
});
tt_assert(confirmed);
/* make it confirmed. */
make_guard_confirmed(gs, confirmed);
/* update the list... */
smartlist_clear(prev_guards);
smartlist_add_all(prev_guards, gs->primary_entry_guards);
entry_guards_update_primary(gs);
/* and see what's primary now! */
tt_int_op(smartlist_len(gs->primary_entry_guards), OP_EQ, n_primary);
tt_ptr_op(smartlist_get(gs->primary_entry_guards, 0), OP_EQ, confirmed);
SMARTLIST_FOREACH(gs->primary_entry_guards, entry_guard_t *, g, {
tt_assert(g->is_primary);
if (g_sl_idx == 0)
continue;
tt_ptr_op(g, OP_EQ, smartlist_get(prev_guards, g_sl_idx - 1));
});
{
entry_guard_t *prev_last_guard = smartlist_get(prev_guards, n_primary-1);
tt_assert(! prev_last_guard->is_primary);
}
/* Calling it a fourth time should leave the guards unchanged. */
smartlist_clear(prev_guards);
smartlist_add_all(prev_guards, gs->primary_entry_guards);
entry_guards_update_primary(gs);
tt_int_op(smartlist_len(gs->primary_entry_guards), OP_EQ, n_primary);
SMARTLIST_FOREACH(gs->primary_entry_guards, entry_guard_t *, g, {
tt_ptr_op(g, OP_EQ, smartlist_get(prev_guards, g_sl_idx));
});
done:
guard_selection_free(gs);
smartlist_free(prev_guards);
}
Test for entry_guard_has_higher_priority().
2016-11-27 20:48:17 +01:00
static void
test_entry_guard_guard_preferred(void *arg)
{
(void) arg;
entry_guard_t *g1 = tor_malloc_zero(sizeof(entry_guard_t));
entry_guard_t *g2 = tor_malloc_zero(sizeof(entry_guard_t));
g1->confirmed_idx = g2->confirmed_idx = -1;
g1->last_tried_to_connect = approx_time();
g2->last_tried_to_connect = approx_time();
tt_int_op(0, OP_EQ, entry_guard_has_higher_priority(g1, g1));
/* Neither is pending; priorities equal. */
tt_int_op(0, OP_EQ, entry_guard_has_higher_priority(g2, g1));
tt_int_op(0, OP_EQ, entry_guard_has_higher_priority(g1, g2));
/* If one is pending, the pending one has higher priority */
g1->is_pending = 1;
tt_int_op(1, OP_EQ, entry_guard_has_higher_priority(g1, g2));
tt_int_op(0, OP_EQ, entry_guard_has_higher_priority(g2, g1));
/* If both are pending, and last_tried_to_connect is equal:
priorities equal */
g2->is_pending = 1;
tt_int_op(0, OP_EQ, entry_guard_has_higher_priority(g2, g1));
tt_int_op(0, OP_EQ, entry_guard_has_higher_priority(g1, g2));
/* One had a connection that startied earlier: it has higher priority. */
g2->last_tried_to_connect -= 10;
tt_int_op(1, OP_EQ, entry_guard_has_higher_priority(g2, g1));
tt_int_op(0, OP_EQ, entry_guard_has_higher_priority(g1, g2));
/* Now, say that g1 is confirmed. It will get higher priority. */
g1->confirmed_idx = 5;
tt_int_op(0, OP_EQ, entry_guard_has_higher_priority(g2, g1));
tt_int_op(1, OP_EQ, entry_guard_has_higher_priority(g1, g2));
/* But if g2 was confirmed first, it will get priority */
g2->confirmed_idx = 2;
tt_int_op(1, OP_EQ, entry_guard_has_higher_priority(g2, g1));
tt_int_op(0, OP_EQ, entry_guard_has_higher_priority(g1, g2));
done:
tor_free(g1);
tor_free(g2);
}
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
static void
test_entry_guard_select_for_circuit_no_confirmed(void *arg)
{
/* Simpler cases: no gaurds are confirmed yet. */
(void)arg;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
/* simple starting configuration */
entry_guards_update_primary(gs);
unsigned state = 9999;
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
entry_guard_t *g = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC,
NULL, &state);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_assert(g);
tt_assert(g->is_primary);
tt_int_op(g->confirmed_idx, OP_EQ, -1);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_uint_op(g->is_pending, OP_EQ, 0); // primary implies non-pending.
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_uint_op(state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
tt_i64_op(g->last_tried_to_connect, OP_EQ, approx_time());
// If we do that again, we should get the same guard.
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
entry_guard_t *g2 = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC,
NULL, &state);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_ptr_op(g2, OP_EQ, g);
// if we mark that guard down, we should get a different primary guard.
// auto-retry it.
g->is_reachable = GUARD_REACHABLE_NO;
Wrap all of the legacy guard code, and its users, in #ifdefs This will make it easier to see what we remove down the line.
2016-12-07 18:36:13 +01:00
g->failing_since = approx_time() - 10;
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
g->last_tried_to_connect = approx_time() - 10;
state = 9999;
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
g2 = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL, &state);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_ptr_op(g2, OP_NE, g);
tt_assert(g2);
tt_assert(g2->is_primary);
tt_int_op(g2->confirmed_idx, OP_EQ, -1);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_uint_op(g2->is_pending, OP_EQ, 0); // primary implies non-pending.
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_uint_op(state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
tt_i64_op(g2->last_tried_to_connect, OP_EQ, approx_time());
// If we say that the first primary guard was last tried a long time ago, we
// should get an automatic retry on it.
Wrap all of the legacy guard code, and its users, in #ifdefs This will make it easier to see what we remove down the line.
2016-12-07 18:36:13 +01:00
g->failing_since = approx_time() - 72*60*60;
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
g->last_tried_to_connect = approx_time() - 72*60*60;
state = 9999;
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
g2 = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL, &state);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_ptr_op(g2, OP_EQ, g);
tt_assert(g2);
tt_uint_op(state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
tt_i64_op(g2->last_tried_to_connect, OP_EQ, approx_time());
tt_int_op(g2->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
// And if we mark ALL the primary guards down, we should get another guard
// at random.
SMARTLIST_FOREACH(gs->primary_entry_guards, entry_guard_t *, guard, {
guard->is_reachable = GUARD_REACHABLE_NO;
guard->last_tried_to_connect = approx_time() - 5;
Wrap all of the legacy guard code, and its users, in #ifdefs This will make it easier to see what we remove down the line.
2016-12-07 18:36:13 +01:00
guard->failing_since = approx_time() - 30;
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
});
state = 9999;
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
g2 = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL, &state);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_assert(g2);
tt_assert(!g2->is_primary);
tt_int_op(g2->confirmed_idx, OP_EQ, -1);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_uint_op(g2->is_pending, OP_EQ, 1);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_uint_op(state, OP_EQ, GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
tt_i64_op(g2->last_tried_to_connect, OP_EQ, approx_time());
tt_int_op(g2->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
// As a bonus, maybe we should be retrying the primary guards. Let's say so.
mark_primary_guards_maybe_reachable(gs);
SMARTLIST_FOREACH(gs->primary_entry_guards, entry_guard_t *, guard, {
tt_int_op(guard->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
tt_assert(guard->is_usable_filtered_guard == 1);
// no change to these fields.
tt_i64_op(guard->last_tried_to_connect, OP_EQ, approx_time() - 5);
Wrap all of the legacy guard code, and its users, in #ifdefs This will make it easier to see what we remove down the line.
2016-12-07 18:36:13 +01:00
tt_i64_op(guard->failing_since, OP_EQ, approx_time() - 30);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
});
Update node-selection tests to consider restrictions
2016-11-30 19:37:37 +01:00
/* Let's try again and we should get the first primary guard again */
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
g = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL, &state);
Update node-selection tests to consider restrictions
2016-11-30 19:37:37 +01:00
tt_ptr_op(g, OP_EQ, smartlist_get(gs->primary_entry_guards, 0));
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
g2 = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL, &state);
Update node-selection tests to consider restrictions
2016-11-30 19:37:37 +01:00
tt_ptr_op(g2, OP_EQ, g);
/* But if we impose a restriction, we don't get the same guard */
entry_guard_restriction_t rst;
memset(&rst, 0, sizeof(rst));
memcpy(rst.exclude_id, g->identity, DIGEST_LEN);
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
g2 = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC, &rst, &state);
Update node-selection tests to consider restrictions
2016-11-30 19:37:37 +01:00
tt_ptr_op(g2, OP_NE, g);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
done:
guard_selection_free(gs);
}
static void
test_entry_guard_select_for_circuit_confirmed(void *arg)
{
/* Case 2: if all the primary guards are down, and there are more confirmed
guards, we use a confirmed guard. */
(void)arg;
int i;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
const int N_CONFIRMED = 10;
/* slightly more complicated simple starting configuration */
entry_guards_update_primary(gs);
for (i = 0; i < N_CONFIRMED; ++i) {
entry_guard_t *guard = smartlist_get(gs->sampled_entry_guards, i);
make_guard_confirmed(gs, guard);
}
entry_guards_update_primary(gs); // rebuild the primary list.
unsigned state = 9999;
// As above, this gives us a primary guard.
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
entry_guard_t *g = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC,
NULL, &state);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_assert(g);
tt_assert(g->is_primary);
tt_int_op(g->confirmed_idx, OP_EQ, 0);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_uint_op(g->is_pending, OP_EQ, 0); // primary implies non-pending.
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_uint_op(state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
tt_i64_op(g->last_tried_to_connect, OP_EQ, approx_time());
tt_ptr_op(g, OP_EQ, smartlist_get(gs->primary_entry_guards, 0));
// But if we mark all the primary guards down...
SMARTLIST_FOREACH(gs->primary_entry_guards, entry_guard_t *, guard, {
guard->last_tried_to_connect = approx_time();
entry_guards_note_guard_failure(gs, guard);
});
// ... we should get a confirmed guard.
state = 9999;
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
g = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL, &state);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_assert(g);
tt_assert(! g->is_primary);
tt_int_op(g->confirmed_idx, OP_EQ, smartlist_len(gs->primary_entry_guards));
tt_assert(g->is_pending);
tt_uint_op(state, OP_EQ, GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
tt_i64_op(g->last_tried_to_connect, OP_EQ, approx_time());
// And if we try again, we should get a different confirmed guard, since
// that one is pending.
state = 9999;
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
entry_guard_t *g2 = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC,
NULL, &state);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_assert(g2);
tt_assert(! g2->is_primary);
tt_ptr_op(g2, OP_NE, g);
tt_int_op(g2->confirmed_idx, OP_EQ,
smartlist_len(gs->primary_entry_guards)+1);
tt_assert(g2->is_pending);
tt_uint_op(state, OP_EQ, GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
tt_i64_op(g2->last_tried_to_connect, OP_EQ, approx_time());
Adjust unit tests to account for fix to bug 22753. Our mock network put all the guards on the same IPv4 address, which doesn't fly when we start applying EnforceDistinctSubnets. So in this commit, I disable EnforceDistinctSubnets when running the old guard_restriction_t test. This commit also adds a regression test for #22753.
2017-06-29 16:09:06 +02:00
// If we say that the next confirmed guard in order is excluded, and
// we disable EnforceDistinctSubnets, we get the guard AFTER the
// one we excluded.
get_options_mutable()->EnforceDistinctSubnets = 0;
Update node-selection tests to consider restrictions
2016-11-30 19:37:37 +01:00
g = smartlist_get(gs->confirmed_entry_guards,
smartlist_len(gs->primary_entry_guards)+2);
entry_guard_restriction_t rst;
memset(&rst, 0, sizeof(rst));
memcpy(rst.exclude_id, g->identity, DIGEST_LEN);
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
g2 = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC, &rst, &state);
Adjust unit tests to account for fix to bug 22753. Our mock network put all the guards on the same IPv4 address, which doesn't fly when we start applying EnforceDistinctSubnets. So in this commit, I disable EnforceDistinctSubnets when running the old guard_restriction_t test. This commit also adds a regression test for #22753.
2017-06-29 16:09:06 +02:00
tt_ptr_op(g2, OP_NE, NULL);
Update node-selection tests to consider restrictions
2016-11-30 19:37:37 +01:00
tt_ptr_op(g2, OP_NE, g);
tt_int_op(g2->confirmed_idx, OP_EQ,
smartlist_len(gs->primary_entry_guards)+3);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
// If we make every confirmed guard become pending then we start poking
// other guards.
const int n_remaining_confirmed =
Update node-selection tests to consider restrictions
2016-11-30 19:37:37 +01:00
N_CONFIRMED - 3 - smartlist_len(gs->primary_entry_guards);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
for (i = 0; i < n_remaining_confirmed; ++i) {
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
g = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL, &state);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_int_op(g->confirmed_idx, OP_GE, 0);
tt_assert(g);
}
state = 9999;
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
g = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL, &state);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
tt_assert(g);
tt_assert(g->is_pending);
tt_int_op(g->confirmed_idx, OP_EQ, -1);
Adjust unit tests to account for fix to bug 22753. Our mock network put all the guards on the same IPv4 address, which doesn't fly when we start applying EnforceDistinctSubnets. So in this commit, I disable EnforceDistinctSubnets when running the old guard_restriction_t test. This commit also adds a regression test for #22753.
2017-06-29 16:09:06 +02:00
// If we EnforceDistinctSubnets and apply a restriction, we get
// nothing, since we put all of the nodes in the same /16.
// Regression test for bug 22753/TROVE-2017-006.
get_options_mutable()->EnforceDistinctSubnets = 1;
g = smartlist_get(gs->confirmed_entry_guards, 0);
memset(&rst, 0, sizeof(rst));
memcpy(rst.exclude_id, g->identity, DIGEST_LEN);
g2 = select_entry_guard_for_circuit(gs, GUARD_USAGE_TRAFFIC, &rst, &state);
tt_ptr_op(g2, OP_EQ, NULL);
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
done:
guard_selection_free(gs);
}
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
static void
test_entry_guard_select_for_circuit_highlevel_primary(void *arg)
{
/* Play around with selecting primary guards for circuits and markign
* them up and down */
(void)arg;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
time_t start = approx_time();
const node_t *node = NULL;
circuit_guard_state_t *guard = NULL;
entry_guard_t *g;
Change return value of entry_guard_succeeded to an enum. George pointed out that (-1,0,1) for (never usable, maybe usable later, usable right now) was a pretty rotten convention that made the code harder to read.
2016-11-29 17:47:12 +01:00
guard_usable_t u;
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
/*
* Make sure that the pick-for-circuit API basically works. We'll get
* a primary guard, so it'll be usable on completion.
*/
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
int r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &guard);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_assert(node);
tt_assert(guard);
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
g = entry_guard_handle_get(guard->guard);
tt_assert(g);
tt_mem_op(g->identity, OP_EQ, node->identity, DIGEST_LEN);
tt_int_op(g->is_primary, OP_EQ, 1);
tt_i64_op(g->last_tried_to_connect, OP_EQ, start);
tt_int_op(g->confirmed_idx, OP_EQ, -1);
/* Call that circuit successful. */
update_approx_time(start+15);
Change return value of entry_guard_succeeded to an enum. George pointed out that (-1,0,1) for (never usable, maybe usable later, usable right now) was a pretty rotten convention that made the code harder to read.
2016-11-29 17:47:12 +01:00
u = entry_guard_succeeded(&guard);
tt_int_op(u, OP_EQ, GUARD_USABLE_NOW); /* We can use it now. */
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_assert(guard);
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_COMPLETE);
g = entry_guard_handle_get(guard->guard);
tt_assert(g);
tt_int_op(g->is_reachable, OP_EQ, GUARD_REACHABLE_YES);
tt_int_op(g->confirmed_idx, OP_EQ, 0);
circuit_guard_state_free(guard);
guard = NULL;
node = NULL;
g = NULL;
/* Try again. We'll also get a primary guard this time. (The same one,
in fact.) But this time, we'll say the connection has failed. */
update_approx_time(start+35);
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &guard);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_assert(node);
tt_assert(guard);
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
tt_i64_op(guard->state_set_at, OP_EQ, start+35);
g = entry_guard_handle_get(guard->guard);
tt_assert(g);
tt_mem_op(g->identity, OP_EQ, node->identity, DIGEST_LEN);
tt_int_op(g->is_primary, OP_EQ, 1);
tt_i64_op(g->last_tried_to_connect, OP_EQ, start+35);
tt_int_op(g->confirmed_idx, OP_EQ, 0); // same one.
/* It's failed! What will happen to our poor guard? */
update_approx_time(start+45);
Remove guard_selection argument from status-reporting functions This prevents us from mixing up multiple guard_selections
2016-11-28 17:04:28 +01:00
entry_guard_failed(&guard);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_assert(guard);
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_DEAD);
tt_i64_op(guard->state_set_at, OP_EQ, start+45);
g = entry_guard_handle_get(guard->guard);
tt_assert(g);
tt_int_op(g->is_reachable, OP_EQ, GUARD_REACHABLE_NO);
tt_i64_op(g->failing_since, OP_EQ, start+45);
tt_int_op(g->confirmed_idx, OP_EQ, 0); // still confirmed.
circuit_guard_state_free(guard);
guard = NULL;
node = NULL;
entry_guard_t *g_prev = g;
g = NULL;
/* Now try a third time. Since the other one is down, we'll get a different
* (still primary) guard.
*/
update_approx_time(start+60);
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &guard);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_assert(node);
tt_assert(guard);
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
g = entry_guard_handle_get(guard->guard);
tt_assert(g);
tt_ptr_op(g, OP_NE, g_prev);
tt_mem_op(g->identity, OP_EQ, node->identity, DIGEST_LEN);
tt_mem_op(g->identity, OP_NE, g_prev->identity, DIGEST_LEN);
tt_int_op(g->is_primary, OP_EQ, 1);
tt_i64_op(g->last_tried_to_connect, OP_EQ, start+60);
tt_int_op(g->confirmed_idx, OP_EQ, -1); // not confirmd now.
/* Call this one up; watch it get confirmed. */
update_approx_time(start+90);
Change return value of entry_guard_succeeded to an enum. George pointed out that (-1,0,1) for (never usable, maybe usable later, usable right now) was a pretty rotten convention that made the code harder to read.
2016-11-29 17:47:12 +01:00
u = entry_guard_succeeded(&guard);
tt_int_op(u, OP_EQ, GUARD_USABLE_NOW);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_assert(guard);
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_COMPLETE);
g = entry_guard_handle_get(guard->guard);
tt_assert(g);
tt_int_op(g->is_reachable, OP_EQ, GUARD_REACHABLE_YES);
tt_int_op(g->confirmed_idx, OP_EQ, 1);
done:
guard_selection_free(gs);
circuit_guard_state_free(guard);
}
static void
test_entry_guard_select_for_circuit_highlevel_confirm_other(void *arg)
{
(void) arg;
const int N_PRIMARY = DFLT_N_PRIMARY_GUARDS;
/* At the start, we have no confirmed guards. We'll mark the primary guards
* down, then confirm something else. As soon as we do, it should become
* primary, and we should get it next time. */
time_t start = approx_time();
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
circuit_guard_state_t *guard = NULL;
int i, r;
const node_t *node = NULL;
Change return value of entry_guard_succeeded to an enum. George pointed out that (-1,0,1) for (never usable, maybe usable later, usable right now) was a pretty rotten convention that made the code harder to read.
2016-11-29 17:47:12 +01:00
guard_usable_t u;
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
/* Declare that we're on the internet. */
entry_guards_note_internet_connectivity(gs);
/* Primary guards are down! */
for (i = 0; i < N_PRIMARY; ++i) {
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &guard);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_assert(node);
tt_assert(guard);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
Remove guard_selection argument from status-reporting functions This prevents us from mixing up multiple guard_selections
2016-11-28 17:04:28 +01:00
entry_guard_failed(&guard);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
circuit_guard_state_free(guard);
guard = NULL;
node = NULL;
}
/* Next guard should be non-primary. */
node = NULL;
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &guard);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_assert(node);
tt_assert(guard);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
entry_guard_t *g = entry_guard_handle_get(guard->guard);
tt_assert(g);
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
tt_int_op(g->confirmed_idx, OP_EQ, -1);
tt_int_op(g->is_primary, OP_EQ, 0);
tt_int_op(g->is_pending, OP_EQ, 1);
(void)start;
Change return value of entry_guard_succeeded to an enum. George pointed out that (-1,0,1) for (never usable, maybe usable later, usable right now) was a pretty rotten convention that made the code harder to read.
2016-11-29 17:47:12 +01:00
u = entry_guard_succeeded(&guard);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
/* We're on the internet (by fiat), so this guard will get called "confirmed"
* and should immediately become primary.
*/
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_COMPLETE);
Change return value of entry_guard_succeeded to an enum. George pointed out that (-1,0,1) for (never usable, maybe usable later, usable right now) was a pretty rotten convention that made the code harder to read.
2016-11-29 17:47:12 +01:00
tt_assert(u == GUARD_USABLE_NOW);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_int_op(g->confirmed_idx, OP_EQ, 0);
tt_int_op(g->is_primary, OP_EQ, 1);
tt_int_op(g->is_pending, OP_EQ, 0);
done:
guard_selection_free(gs);
circuit_guard_state_free(guard);
}
static void
test_entry_guard_select_for_circuit_highlevel_primary_retry(void *arg)
{
(void) arg;
const int N_PRIMARY = DFLT_N_PRIMARY_GUARDS;
/* At the start, we have no confirmed guards. We'll mark the primary guards
* down, then confirm something else. As soon as we do, it should become
* primary, and we should get it next time. */
time_t start = approx_time();
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
circuit_guard_state_t *guard = NULL, *guard2 = NULL;
int i, r;
const node_t *node = NULL;
entry_guard_t *g;
Change return value of entry_guard_succeeded to an enum. George pointed out that (-1,0,1) for (never usable, maybe usable later, usable right now) was a pretty rotten convention that made the code harder to read.
2016-11-29 17:47:12 +01:00
guard_usable_t u;
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
/* Declare that we're on the internet. */
entry_guards_note_internet_connectivity(gs);
/* Make primary guards confirmed (so they won't be superseded by a later
* guard), then mark them down. */
for (i = 0; i < N_PRIMARY; ++i) {
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &guard);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_assert(node);
tt_assert(guard);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
g = entry_guard_handle_get(guard->guard);
make_guard_confirmed(gs, g);
tt_int_op(g->is_primary, OP_EQ, 1);
Remove guard_selection argument from status-reporting functions This prevents us from mixing up multiple guard_selections
2016-11-28 17:04:28 +01:00
entry_guard_failed(&guard);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
circuit_guard_state_free(guard);
tt_int_op(g->is_reachable, OP_EQ, GUARD_REACHABLE_NO);
guard = NULL;
node = NULL;
}
/* Get another guard that we might try. */
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &guard);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_assert(node);
tt_assert(guard);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
g = entry_guard_handle_get(guard->guard);
tt_int_op(g->is_primary, OP_EQ, 0);
tt_assert(entry_guards_all_primary_guards_are_down(gs));
/* And an hour has passed ... */
update_approx_time(start + 3600);
/* Say that guard has succeeded! */
Change return value of entry_guard_succeeded to an enum. George pointed out that (-1,0,1) for (never usable, maybe usable later, usable right now) was a pretty rotten convention that made the code harder to read.
2016-11-29 17:47:12 +01:00
u = entry_guard_succeeded(&guard);
tt_int_op(u, OP_EQ, GUARD_MAYBE_USABLE_LATER);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_WAITING_FOR_BETTER_GUARD);
g = entry_guard_handle_get(guard->guard);
/* The primary guards should have been marked up! */
SMARTLIST_FOREACH(gs->primary_entry_guards, entry_guard_t *, pg, {
tt_int_op(pg->is_primary, OP_EQ, 1);
tt_ptr_op(g, OP_NE, pg);
tt_int_op(pg->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
});
/* Have a circuit to a primary guard succeed. */
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &guard2);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_int_op(guard2->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
Change return value of entry_guard_succeeded to an enum. George pointed out that (-1,0,1) for (never usable, maybe usable later, usable right now) was a pretty rotten convention that made the code harder to read.
2016-11-29 17:47:12 +01:00
u = entry_guard_succeeded(&guard2);
tt_assert(u == GUARD_USABLE_NOW);
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
tt_int_op(guard2->state, OP_EQ, GUARD_CIRC_STATE_COMPLETE);
tt_assert(! entry_guards_all_primary_guards_are_down(gs));
done:
guard_selection_free(gs);
circuit_guard_state_free(guard);
circuit_guard_state_free(guard2);
}
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
static void
test_entry_guard_select_and_cancel(void *arg)
{
(void) arg;
const int N_PRIMARY = DFLT_N_PRIMARY_GUARDS;
int i,r;
const node_t *node = NULL;
circuit_guard_state_t *guard;
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = guard_selection_new("default", GS_TYPE_NORMAL);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
entry_guard_t *g;
/* Once more, we mark all the primary guards down. */
entry_guards_note_internet_connectivity(gs);
for (i = 0; i < N_PRIMARY; ++i) {
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &guard);
Resolve some coverity complaints in test_entrynodes.c
2016-12-16 18:23:46 +01:00
tt_int_op(r, OP_EQ, 0);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
g = entry_guard_handle_get(guard->guard);
tt_int_op(g->is_primary, OP_EQ, 1);
tt_int_op(g->is_pending, OP_EQ, 0);
make_guard_confirmed(gs, g);
Remove guard_selection argument from status-reporting functions This prevents us from mixing up multiple guard_selections
2016-11-28 17:04:28 +01:00
entry_guard_failed(&guard);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
circuit_guard_state_free(guard);
guard = NULL;
node = NULL;
}
tt_assert(entry_guards_all_primary_guards_are_down(gs));
/* Now get another guard we could try... */
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &guard);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
tt_assert(node);
tt_assert(guard);
apply ahf's test_assert_int.cocci
2017-08-24 21:49:59 +02:00
tt_int_op(r, OP_EQ, 0);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
g = entry_guard_handle_get(guard->guard);
tt_int_op(g->is_primary, OP_EQ, 0);
tt_int_op(g->is_pending, OP_EQ, 1);
/* Whoops! We should never have asked for this guard. Cancel the request! */
Remove guard_selection argument from status-reporting functions This prevents us from mixing up multiple guard_selections
2016-11-28 17:04:28 +01:00
entry_guard_cancel(&guard);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
tt_assert(guard == NULL);
tt_int_op(g->is_primary, OP_EQ, 0);
tt_int_op(g->is_pending, OP_EQ, 0);
done:
guard_selection_free(gs);
circuit_guard_state_free(guard);
}
Add a unit test for dropguards
2017-01-02 16:45:32 +01:00
static void
test_entry_guard_drop_guards(void *arg)
{
(void) arg;
int r;
const node_t *node = NULL;
circuit_guard_state_t *guard;
guard_selection_t *gs = get_guard_selection_info();
// Pick a guard, to get things set up.
r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &guard);
tt_int_op(r, OP_EQ, 0);
tt_int_op(smartlist_len(gs->sampled_entry_guards), OP_GE,
DFLT_MIN_FILTERED_SAMPLE_SIZE);
tt_ptr_op(gs, OP_EQ, get_guard_selection_info());
// Drop all the guards! (This is a bad idea....)
remove_all_entry_guards_for_guard_selection(gs);
gs = get_guard_selection_info();
tt_int_op(smartlist_len(gs->sampled_entry_guards), OP_EQ, 0);
tt_int_op(smartlist_len(gs->primary_entry_guards), OP_EQ, 0);
tt_int_op(smartlist_len(gs->confirmed_entry_guards), OP_EQ, 0);
done:
circuit_guard_state_free(guard);
guard_selection_free(gs);
}
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
/* Unit test setup function: Create a fake network, and set everything up
* for testing the upgrade-a-waiting-circuit code. */
typedef struct {
guard_selection_t *gs;
time_t start;
circuit_guard_state_t *guard1_state;
circuit_guard_state_t *guard2_state;
entry_guard_t *guard1;
entry_guard_t *guard2;
origin_circuit_t *circ1;
origin_circuit_t *circ2;
smartlist_t *all_origin_circuits;
} upgrade_circuits_data_t;
static void *
upgrade_circuits_setup(const struct testcase_t *testcase)
{
upgrade_circuits_data_t *data = tor_malloc_zero(sizeof(*data));
Have multiple guard contexts we can switch between. Currently, this code doesn't actually have the contexts behave differently, (except for the legacy context), but it does switch back and forth between them nicely.
2016-11-28 13:41:45 +01:00
guard_selection_t *gs = data->gs =
guard_selection_new("default", GS_TYPE_NORMAL);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
circuit_guard_state_t *guard;
const node_t *node;
entry_guard_t *g;
int i;
const int N_PRIMARY = DFLT_N_PRIMARY_GUARDS;
const char *argument = testcase->setup_data;
const int make_circ1_succeed = strstr(argument, "c1-done") != NULL;
const int make_circ2_succeed = strstr(argument, "c2-done") != NULL;
big_fake_network_setup(testcase);
/* We're going to set things up in a state where a circuit will be ready to
* be upgraded. Each test can make a single change (or not) that should
* block the upgrade.
*/
/* First, make all the primary guards confirmed, and down. */
data->start = approx_time();
entry_guards_note_internet_connectivity(gs);
for (i = 0; i < N_PRIMARY; ++i) {
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL, &node, &guard);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
g = entry_guard_handle_get(guard->guard);
make_guard_confirmed(gs, g);
Remove guard_selection argument from status-reporting functions This prevents us from mixing up multiple guard_selections
2016-11-28 17:04:28 +01:00
entry_guard_failed(&guard);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
circuit_guard_state_free(guard);
}
/* Grab another couple of guards */
data->all_origin_circuits = smartlist_new();
update_approx_time(data->start + 27);
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &data->guard1_state);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
origin_circuit_t *circ;
data->circ1 = circ = origin_circuit_new();
circ->base_.purpose = CIRCUIT_PURPOSE_C_GENERAL;
circ->guard_state = data->guard1_state;
smartlist_add(data->all_origin_circuits, circ);
update_approx_time(data->start + 30);
Make NumDirectoryGuards work with the new guard algorithm. Now that we support NumEntryGuards, NumDirectoryGuards is pretty easy to put back in.
2016-12-12 16:32:25 +01:00
entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
&node, &data->guard2_state);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
data->circ2 = circ = origin_circuit_new();
circ->base_.purpose = CIRCUIT_PURPOSE_C_GENERAL;
circ->guard_state = data->guard2_state;
smartlist_add(data->all_origin_circuits, circ);
data->guard1 = entry_guard_handle_get(data->guard1_state->guard);
data->guard2 = entry_guard_handle_get(data->guard2_state->guard);
tor_assert(data->guard1 != data->guard2);
tor_assert(data->guard1_state->state ==
GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
tor_assert(data->guard2_state->state ==
GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
Change return value of entry_guard_succeeded to an enum. George pointed out that (-1,0,1) for (never usable, maybe usable later, usable right now) was a pretty rotten convention that made the code harder to read.
2016-11-29 17:47:12 +01:00
guard_usable_t r;
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
update_approx_time(data->start + 32);
if (make_circ1_succeed) {
Remove guard_selection argument from status-reporting functions This prevents us from mixing up multiple guard_selections
2016-11-28 17:04:28 +01:00
r = entry_guard_succeeded(&data->guard1_state);
Change return value of entry_guard_succeeded to an enum. George pointed out that (-1,0,1) for (never usable, maybe usable later, usable right now) was a pretty rotten convention that made the code harder to read.
2016-11-29 17:47:12 +01:00
tor_assert(r == GUARD_MAYBE_USABLE_LATER);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
tor_assert(data->guard1_state->state ==
GUARD_CIRC_STATE_WAITING_FOR_BETTER_GUARD);
}
update_approx_time(data->start + 33);
if (make_circ2_succeed) {
Remove guard_selection argument from status-reporting functions This prevents us from mixing up multiple guard_selections
2016-11-28 17:04:28 +01:00
r = entry_guard_succeeded(&data->guard2_state);
Change return value of entry_guard_succeeded to an enum. George pointed out that (-1,0,1) for (never usable, maybe usable later, usable right now) was a pretty rotten convention that made the code harder to read.
2016-11-29 17:47:12 +01:00
tor_assert(r == GUARD_MAYBE_USABLE_LATER);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
tor_assert(data->guard2_state->state ==
GUARD_CIRC_STATE_WAITING_FOR_BETTER_GUARD);
}
return data;
}
static int
upgrade_circuits_cleanup(const struct testcase_t *testcase, void *ptr)
{
upgrade_circuits_data_t *data = ptr;
// circuit_guard_state_free(data->guard1_state); // held in circ1
// circuit_guard_state_free(data->guard2_state); // held in circ2
guard_selection_free(data->gs);
smartlist_free(data->all_origin_circuits);
circuit_free(TO_CIRCUIT(data->circ1));
circuit_free(TO_CIRCUIT(data->circ2));
tor_free(data);
Resolve some coverity complaints in test_entrynodes.c
2016-12-16 18:23:46 +01:00
return big_fake_network_cleanup(testcase, NULL);
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
}
static void
test_entry_guard_upgrade_a_circuit(void *arg)
{
upgrade_circuits_data_t *data = arg;
/* This is the easy case: we have no COMPLETED circuits, all the
* primary guards are down, we have two WAITING circuits: one will
* get upgraded to COMPLETED! (The one that started first.)
*/
smartlist_t *result = smartlist_new();
int r;
r = entry_guards_upgrade_waiting_circuits(data->gs,
data->all_origin_circuits,
result);
tt_int_op(r, OP_EQ, 1);
tt_int_op(smartlist_len(result), OP_EQ, 1);
origin_circuit_t *oc = smartlist_get(result, 0);
/* circ1 was started first, so we'll get told to ugrade it... */
tt_ptr_op(oc, OP_EQ, data->circ1);
/* And the guard state should be complete */
tt_ptr_op(data->guard1_state, OP_NE, NULL);
tt_int_op(data->guard1_state->state, OP_EQ, GUARD_CIRC_STATE_COMPLETE);
done:
smartlist_free(result);
}
static void
test_entry_guard_upgrade_blocked_by_live_primary_guards(void *arg)
{
upgrade_circuits_data_t *data = arg;
/* If any primary guards might be up, we can't upgrade any waiting
* circuits.
*/
mark_primary_guards_maybe_reachable(data->gs);
smartlist_t *result = smartlist_new();
int r;
setup_capture_of_logs(LOG_DEBUG);
r = entry_guards_upgrade_waiting_circuits(data->gs,
data->all_origin_circuits,
result);
tt_int_op(r, OP_EQ, 0);
tt_int_op(smartlist_len(result), OP_EQ, 0);
expect_log_msg_containing("not all primary guards were definitely down.");
done:
teardown_capture_of_logs();
smartlist_free(result);
}
static void
test_entry_guard_upgrade_blocked_by_lack_of_waiting_circuits(void *arg)
{
upgrade_circuits_data_t *data = arg;
/* If no circuits are waiting, we can't upgrade anything. (The test
* setup in this case was told not to make any of the circuits "waiting".)
*/
smartlist_t *result = smartlist_new();
int r;
setup_capture_of_logs(LOG_DEBUG);
r = entry_guards_upgrade_waiting_circuits(data->gs,
data->all_origin_circuits,
result);
tt_int_op(r, OP_EQ, 0);
tt_int_op(smartlist_len(result), OP_EQ, 0);
expect_log_msg_containing("Considered upgrading guard-stalled circuits, "
"but didn't find any.");
done:
teardown_capture_of_logs();
smartlist_free(result);
}
static void
test_entry_guard_upgrade_blocked_by_better_circ_complete(void *arg)
{
upgrade_circuits_data_t *data = arg;
/* We'll run through the logic of upgrade_a_circuit below...
* and then try again to make sure that circ2 isn't also upgraded.
*/
smartlist_t *result = smartlist_new();
int r;
r = entry_guards_upgrade_waiting_circuits(data->gs,
data->all_origin_circuits,
result);
tt_int_op(r, OP_EQ, 1);
tt_int_op(smartlist_len(result), OP_EQ, 1);
origin_circuit_t *oc = smartlist_get(result, 0);
tt_ptr_op(oc, OP_EQ, data->circ1);
tt_ptr_op(data->guard1_state, OP_NE, NULL);
tt_int_op(data->guard1_state->state, OP_EQ, GUARD_CIRC_STATE_COMPLETE);
/* Now, try again. Make sure that circ2 isn't upgraded. */
smartlist_clear(result);
setup_capture_of_logs(LOG_DEBUG);
r = entry_guards_upgrade_waiting_circuits(data->gs,
data->all_origin_circuits,
result);
tt_int_op(r, OP_EQ, 0);
tt_int_op(smartlist_len(result), OP_EQ, 0);
expect_log_msg_containing("At least one complete circuit had higher "
"priority, so not upgrading.");
done:
teardown_capture_of_logs();
smartlist_free(result);
}
Tests for restricted-circuit cases of upgrade_waiting_circuits()
2016-11-30 19:28:44 +01:00
static void
test_entry_guard_upgrade_not_blocked_by_restricted_circ_complete(void *arg)
{
upgrade_circuits_data_t *data = arg;
/* Once more, let circ1 become complete. But this time, we'll claim
* that circ2 was restricted to not use the same guard as circ1. */
data->guard2_state->restrictions =
tor_malloc_zero(sizeof(entry_guard_restriction_t));
memcpy(data->guard2_state->restrictions->exclude_id,
data->guard1->identity, DIGEST_LEN);
smartlist_t *result = smartlist_new();
int r;
r = entry_guards_upgrade_waiting_circuits(data->gs,
data->all_origin_circuits,
result);
tt_int_op(r, OP_EQ, 1);
tt_int_op(smartlist_len(result), OP_EQ, 1);
origin_circuit_t *oc = smartlist_get(result, 0);
tt_ptr_op(oc, OP_EQ, data->circ1);
tt_ptr_op(data->guard1_state, OP_NE, NULL);
tt_int_op(data->guard1_state->state, OP_EQ, GUARD_CIRC_STATE_COMPLETE);
/* Now, we try again. Since circ2 has a restriction that circ1 doesn't obey,
* circ2 _is_ eligible for upgrade. */
smartlist_clear(result);
r = entry_guards_upgrade_waiting_circuits(data->gs,
data->all_origin_circuits,
result);
tt_int_op(r, OP_EQ, 1);
tt_int_op(smartlist_len(result), OP_EQ, 1);
origin_circuit_t *oc2 = smartlist_get(result, 0);
tt_ptr_op(oc2, OP_EQ, data->circ2);
done:
smartlist_free(result);
}
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
static void
test_entry_guard_upgrade_not_blocked_by_worse_circ_complete(void *arg)
{
upgrade_circuits_data_t *data = arg;
smartlist_t *result = smartlist_new();
/* here we manually make circ2 COMPLETE, and make sure that circ1
* gets made complete anyway, since guard1 has higher priority
*/
update_approx_time(data->start + 300);
data->guard2_state->state = GUARD_CIRC_STATE_COMPLETE;
data->guard2_state->state_set_at = approx_time();
update_approx_time(data->start + 301);
/* Now, try again. Make sure that circ1 is approved. */
int r;
r = entry_guards_upgrade_waiting_circuits(data->gs,
data->all_origin_circuits,
result);
tt_int_op(r, OP_EQ, 1);
tt_int_op(smartlist_len(result), OP_EQ, 1);
origin_circuit_t *oc = smartlist_get(result, 0);
tt_ptr_op(oc, OP_EQ, data->circ1);
done:
smartlist_free(result);
}
static void
test_entry_guard_upgrade_blocked_by_better_circ_pending(void *arg)
{
upgrade_circuits_data_t *data = arg;
/* circ2 is done, but circ1 is still pending. Since circ1 is better,
* we won't upgrade circ2. */
/* XXXX Prop271 -- this is a kludge. I'm making sure circ1 _is_ better,
* by messing with the guards' confirmed_idx */
make_guard_confirmed(data->gs, data->guard1);
{
int tmp;
tmp = data->guard1->confirmed_idx;
data->guard1->confirmed_idx = data->guard2->confirmed_idx;
data->guard2->confirmed_idx = tmp;
}
smartlist_t *result = smartlist_new();
setup_capture_of_logs(LOG_DEBUG);
int r;
r = entry_guards_upgrade_waiting_circuits(data->gs,
data->all_origin_circuits,
result);
tt_int_op(r, OP_EQ, 0);
tt_int_op(smartlist_len(result), OP_EQ, 0);
expect_log_msg_containing("but 1 pending circuit(s) had higher guard "
"priority, so not upgrading.");
done:
teardown_capture_of_logs();
smartlist_free(result);
}
Tests for restricted-circuit cases of upgrade_waiting_circuits()
2016-11-30 19:28:44 +01:00
static void
test_entry_guard_upgrade_not_blocked_by_restricted_circ_pending(void *arg)
{
upgrade_circuits_data_t *data = arg;
/* circ2 is done, but circ1 is still pending. But when there is a
restriction on circ2 that circ1 can't satisfy, circ1 can't block
circ2. */
/* XXXX Prop271 -- this is a kludge. I'm making sure circ1 _is_ better,
* by messing with the guards' confirmed_idx */
make_guard_confirmed(data->gs, data->guard1);
{
int tmp;
tmp = data->guard1->confirmed_idx;
data->guard1->confirmed_idx = data->guard2->confirmed_idx;
data->guard2->confirmed_idx = tmp;
}
data->guard2_state->restrictions =
tor_malloc_zero(sizeof(entry_guard_restriction_t));
memcpy(data->guard2_state->restrictions->exclude_id,
data->guard1->identity, DIGEST_LEN);
smartlist_t *result = smartlist_new();
int r;
r = entry_guards_upgrade_waiting_circuits(data->gs,
data->all_origin_circuits,
result);
tt_int_op(r, OP_EQ, 1);
tt_int_op(smartlist_len(result), OP_EQ, 1);
origin_circuit_t *oc = smartlist_get(result, 0);
tt_ptr_op(oc, OP_EQ, data->circ2);
done:
smartlist_free(result);
}
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
static void
test_entry_guard_upgrade_not_blocked_by_worse_circ_pending(void *arg)
{
upgrade_circuits_data_t *data = arg;
/* circ1 is done, but circ2 is still pending. Since circ1 is better,
* we will upgrade it. */
smartlist_t *result = smartlist_new();
int r;
r = entry_guards_upgrade_waiting_circuits(data->gs,
data->all_origin_circuits,
result);
tt_int_op(r, OP_EQ, 1);
tt_int_op(smartlist_len(result), OP_EQ, 1);
origin_circuit_t *oc = smartlist_get(result, 0);
tt_ptr_op(oc, OP_EQ, data->circ1);
done:
smartlist_free(result);
}
Add a test for entry_guard_state_should_expire()
2016-11-30 17:28:18 +01:00
static void
test_enty_guard_should_expire_waiting(void *arg)
{
(void)arg;
circuit_guard_state_t *fake_state = tor_malloc_zero(sizeof(*fake_state));
/* We'll leave "guard" unset -- it won't matter here. */
/* No state? Can't expire. */
tt_assert(! entry_guard_state_should_expire(NULL));
/* Let's try one that expires. */
fake_state->state = GUARD_CIRC_STATE_WAITING_FOR_BETTER_GUARD;
fake_state->state_set_at =
approx_time() - DFLT_NONPRIMARY_GUARD_IDLE_TIMEOUT - 1;
tt_assert(entry_guard_state_should_expire(fake_state));
/* But it wouldn't expire if we changed the state. */
fake_state->state = GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD;
tt_assert(! entry_guard_state_should_expire(fake_state));
/* And it wouldn't have expired a few seconds ago. */
fake_state->state = GUARD_CIRC_STATE_WAITING_FOR_BETTER_GUARD;
fake_state->state_set_at =
approx_time() - DFLT_NONPRIMARY_GUARD_IDLE_TIMEOUT + 5;
tt_assert(! entry_guard_state_should_expire(fake_state));
done:
tor_free(fake_state);
}
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
static const struct testcase_setup_t big_fake_network = {
big_fake_network_setup, big_fake_network_cleanup
};
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
static const struct testcase_setup_t upgrade_circuits = {
upgrade_circuits_setup, upgrade_circuits_cleanup
};
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
#define BFN_TEST(name) \
{ #name, test_entry_guard_ ## name, TT_FORK, &big_fake_network, NULL }
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
#define UPGRADE_TEST(name, arg) \
{ #name, test_entry_guard_ ## name, TT_FORK, &upgrade_circuits, \
(void*)(arg) }
Add the entrynodes.c unit tests.
2014-06-24 20:22:52 +02:00
struct testcase_t entrynodes_tests[] = {
Add ClientUseIPv4 and ClientPreferIPv6DirPort torrc options ClientUseIPv4 0 tells tor to avoid IPv4 client connections. ClientPreferIPv6DirPort 1 tells tor to prefer IPv6 directory connections. Refactor policy for IPv4/IPv6 preferences. Fix a bug where node->ipv6_preferred could become stale if ClientPreferIPv6ORPort was changed after the consensus was loaded. Update documentation, existing code, add unit tests.
2015-12-14 07:23:10 +01:00
{ "node_preferred_orport",
test_node_preferred_orport,
0, NULL, NULL },
Add an entry_guard_describe() function This function helpfully removes all but one remaining use of an entry_guard_t private field in pathbias.c
2016-11-14 18:04:42 +01:00
{ "entry_guard_describe", test_entry_guard_describe, 0, NULL, NULL },
Initial code to parse/encode/sample prop271 guards The encoding code is very straightforward. The decoding code is a bit tricky, but clean-ish. The sampling code is untested and probably needs more work.
2016-11-14 21:46:09 +01:00
{ "randomize_time", test_entry_guard_randomize_time, 0, NULL, NULL },
{ "encode_for_state_minimal",
test_entry_guard_encode_for_state_minimal, 0, NULL, NULL },
{ "encode_for_state_maximal",
test_entry_guard_encode_for_state_maximal, 0, NULL, NULL },
{ "parse_from_state_minimal",
test_entry_guard_parse_from_state_minimal, 0, NULL, NULL },
{ "parse_from_state_maximal",
test_entry_guard_parse_from_state_maximal, 0, NULL, NULL },
{ "parse_from_state_failure",
test_entry_guard_parse_from_state_failure, 0, NULL, NULL },
{ "parse_from_state_partial_failure",
test_entry_guard_parse_from_state_partial_failure, 0, NULL, NULL },
prop271: Tests for the highlevel or_state_t encode/decode functions
2016-11-30 18:35:16 +01:00
{ "parse_from_state_full",
test_entry_guard_parse_from_state_full, TT_FORK, NULL, NULL },
{ "parse_from_state_broken",
test_entry_guard_parse_from_state_broken, TT_FORK, NULL, NULL },
Test get_guard_selection_by_name
2016-11-23 21:08:07 +01:00
{ "get_guard_selection_by_name",
test_entry_guard_get_guard_selection_by_name, TT_FORK, NULL, NULL },
Tests for choosing which guard_selection to use
2016-11-30 20:11:36 +01:00
BFN_TEST(choose_selection_initial),
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
BFN_TEST(add_single_guard),
BFN_TEST(node_filter),
BFN_TEST(expand_sample),
BFN_TEST(expand_sample_small_net),
BFN_TEST(update_from_consensus_status),
BFN_TEST(update_from_consensus_repair),
BFN_TEST(update_from_consensus_remove),
BFN_TEST(confirming_guards),
BFN_TEST(sample_reachable_filtered),
BFN_TEST(sample_reachable_filtered_empty),
BFN_TEST(retry_unreachable),
BFN_TEST(manage_primary),
Test for entry_guard_has_higher_priority().
2016-11-27 20:48:17 +01:00
{ "guard_preferred", test_entry_guard_guard_preferred, TT_FORK, NULL, NULL },
Implement most of the prop271 data structure backends. This code handles: * Maintaining the sampled set, the filtered set, and the usable_filtered set. * Maintaining the confirmed and primary guard lists. * Picking guards for circuits, and updating guard state when circuit state changes. Additionally, I've done code structure movement: even more constants and structures from entrynodes.c have become ENTRYNODES_PRIVATE fields of entrynodes.h. I've also included a bunch of documentation and a bunch of unit tests. Coverage on the new code is pretty high. I've noted important things to resolve before this branch is done with the /XXXX.*prop271/ regex.
2016-11-16 14:21:39 +01:00
BFN_TEST(select_for_circuit_no_confirmed),
BFN_TEST(select_for_circuit_confirmed),
Unit tests for entry_guard_{pick_for_circuit,succeeded,failed}
2016-11-27 19:55:36 +01:00
BFN_TEST(select_for_circuit_highlevel_primary),
BFN_TEST(select_for_circuit_highlevel_confirm_other),
BFN_TEST(select_for_circuit_highlevel_primary_retry),
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
BFN_TEST(select_and_cancel),
Add a unit test for dropguards
2017-01-02 16:45:32 +01:00
BFN_TEST(drop_guards),
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
UPGRADE_TEST(upgrade_a_circuit, "c1-done c2-done"),
UPGRADE_TEST(upgrade_blocked_by_live_primary_guards, "c1-done c2-done"),
UPGRADE_TEST(upgrade_blocked_by_lack_of_waiting_circuits, ""),
UPGRADE_TEST(upgrade_blocked_by_better_circ_complete, "c1-done c2-done"),
Tests for restricted-circuit cases of upgrade_waiting_circuits()
2016-11-30 19:28:44 +01:00
UPGRADE_TEST(upgrade_not_blocked_by_restricted_circ_complete,
"c1-done c2-done"),
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
UPGRADE_TEST(upgrade_not_blocked_by_worse_circ_complete, "c1-done c2-done"),
UPGRADE_TEST(upgrade_blocked_by_better_circ_pending, "c2-done"),
Tests for restricted-circuit cases of upgrade_waiting_circuits()
2016-11-30 19:28:44 +01:00
UPGRADE_TEST(upgrade_not_blocked_by_restricted_circ_pending,
"c2-done"),
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
UPGRADE_TEST(upgrade_not_blocked_by_worse_circ_pending, "c1-done"),
Add a test for entry_guard_state_should_expire()
2016-11-30 17:28:18 +01:00
{ "should_expire_waiting", test_enty_guard_should_expire_waiting, TT_FORK,
NULL, NULL },
More entry guard tests: for cancel, and for upgrade.
2016-11-28 00:47:27 +01:00
Add the entrynodes.c unit tests.
2014-06-24 20:22:52 +02:00
END_OF_TESTCASES
};
Reference in New Issue Copy Permalink