nihilist/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-11-10 13:13:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'maint-0.3.2'

Browse Source
This commit is contained in:
Nick Mathewson 2017-11-07 09:58:53 -05:00
commit c6c4a421fd
10 changed files with 126 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
changes/bug23623 Normal file
View File

@ -0,0 +1,4 @@
o Minor bugfixes (onion services):
- Cache some needed onion service client information instead of
continuously computing it over and over again. Fixes bug 23623; bugfix
on 0.3.2.1-alpha.

68
src/or/dirvote.c
View File

@ -2787,48 +2787,10 @@ dirvote_get_start_of_next_interval(time_t now, int interval, int offset)
return next;
}
/* Using the time <b>now</b>, return the next voting valid-after time. */
time_t
get_next_valid_after_time(time_t now)
{
time_t next_valid_after_time;
const or_options_t *options = get_options();
voting_schedule_t *new_voting_schedule =
get_voting_schedule(options, now, LOG_INFO);
tor_assert(new_voting_schedule);
next_valid_after_time = new_voting_schedule->interval_starts;
voting_schedule_free(new_voting_schedule);
return next_valid_after_time;
}
static voting_schedule_t voting_schedule;
/** Set voting_schedule to hold the timing for the next vote we should be
* doing. */
void
dirvote_recalculate_timing(const or_options_t *options, time_t now)
{
voting_schedule_t *new_voting_schedule;
if (!authdir_mode_v3(options)) {
return;
}
/* get the new voting schedule */
new_voting_schedule = get_voting_schedule(options, now, LOG_NOTICE);
tor_assert(new_voting_schedule);
/* Fill in the global static struct now */
memcpy(&voting_schedule, new_voting_schedule, sizeof(voting_schedule));
voting_schedule_free(new_voting_schedule);
}
/* Populate and return a new voting_schedule_t that can be used to schedule
* voting. The object is allocated on the heap and it's the responsibility of
* the caller to free it. Can't fail. */
voting_schedule_t *
static voting_schedule_t *
get_voting_schedule(const or_options_t *options, time_t now, int severity)
{
int interval, vote_delay, dist_delay;
@ -2883,7 +2845,7 @@ get_voting_schedule(const or_options_t *options, time_t now, int severity)
/** Frees a voting_schedule_t. This should be used instead of the generic
* tor_free. */
void
static void
voting_schedule_free(voting_schedule_t *voting_schedule_to_free)
{
if (!voting_schedule_to_free)
@ -2891,6 +2853,32 @@ voting_schedule_free(voting_schedule_t *voting_schedule_to_free)
tor_free(voting_schedule_to_free);
}
static voting_schedule_t voting_schedule;
/* Using the time <b>now</b>, return the next voting valid-after time. */
time_t
dirvote_get_next_valid_after_time(void)
{
return voting_schedule.interval_starts;
}
/** Set voting_schedule to hold the timing for the next vote we should be
* doing. All type of tor do that because HS subsystem needs the timing as
* well to function properly. */
void
dirvote_recalculate_timing(const or_options_t *options, time_t now)
{
voting_schedule_t *new_voting_schedule;
/* get the new voting schedule */
new_voting_schedule = get_voting_schedule(options, now, LOG_NOTICE);
tor_assert(new_voting_schedule);
/* Fill in the global static struct now */
memcpy(&voting_schedule, new_voting_schedule, sizeof(voting_schedule));
voting_schedule_free(new_voting_schedule);
}
/** Entry point: Take whatever voting actions are pending as of <b>now</b>. */
void
dirvote_act(const or_options_t *options, time_t now)

7
src/or/dirvote.h
View File

@ -170,18 +170,13 @@ typedef struct {
int have_published_consensus;
} voting_schedule_t;
voting_schedule_t *get_voting_schedule(const or_options_t *options,
time_t now, int severity);
void voting_schedule_free(voting_schedule_t *voting_schedule_to_free);
void dirvote_get_preferred_voting_intervals(vote_timing_t *timing_out);
time_t dirvote_get_start_of_next_interval(time_t now,
int interval,
int offset);
void dirvote_recalculate_timing(const or_options_t *options, time_t now);
void dirvote_act(const or_options_t *options, time_t now);
time_t get_next_valid_after_time(time_t now);
time_t dirvote_get_next_valid_after_time(void);
/* invoked on timers and by outside triggers. */
struct pending_vote_t * dirvote_add_vote(const char *vote_body,

8
src/or/shared_random.c
View File

@ -1333,13 +1333,7 @@ sr_act_post_consensus(const networkstatus_t *consensus)
}
/* Prepare our state so that it's ready for the next voting period. */
{
voting_schedule_t *voting_schedule =
get_voting_schedule(options,time(NULL), LOG_NOTICE);
time_t interval_starts = voting_schedule->interval_starts;
sr_state_update(interval_starts);
voting_schedule_free(voting_schedule);
}
sr_state_update(dirvote_get_next_valid_after_time());
}
/* Initialize shared random subsystem. This MUST be called early in the boot

17
src/or/shared_random_state.c
View File

@ -139,25 +139,18 @@ get_voting_interval(void)
* the SR protocol. For example, if it's 23:47:08, the current round thus
* started at 23:47:00 for a voting interval of 10 seconds. */
STATIC time_t
get_start_time_of_current_round(time_t now)
get_start_time_of_current_round(void)
{
const or_options_t *options = get_options();
int voting_interval = get_voting_interval();
voting_schedule_t *new_voting_schedule =
get_voting_schedule(options, now, LOG_DEBUG);
tor_assert(new_voting_schedule);
/* First, get the start time of the next round */
time_t next_start = new_voting_schedule->interval_starts;
time_t next_start = dirvote_get_next_valid_after_time();
/* Now roll back next_start by a voting interval to find the start time of
the current round. */
time_t curr_start = dirvote_get_start_of_next_interval(
next_start - voting_interval - 1,
voting_interval,
options->TestingV3AuthVotingStartOffset);
voting_schedule_free(new_voting_schedule);
return curr_start;
}
@ -170,7 +163,7 @@ sr_state_get_start_time_of_current_protocol_run(time_t now)
int total_rounds = SHARED_RANDOM_N_ROUNDS * SHARED_RANDOM_N_PHASES;
int voting_interval = get_voting_interval();
/* Find the time the current round started. */
time_t beginning_of_current_round = get_start_time_of_current_round(now);
time_t beginning_of_current_round = get_start_time_of_current_round();
/* Get current SR protocol round */
int current_round = (now / voting_interval) % total_rounds;
@ -208,7 +201,7 @@ get_state_valid_until_time(time_t now)
voting_interval = get_voting_interval();
/* Find the time the current round started. */
beginning_of_current_round = get_start_time_of_current_round(now);
beginning_of_current_round = get_start_time_of_current_round();
/* Find how many rounds are left till the end of the protocol run */
current_round = (now / voting_interval) % total_rounds;
@ -1370,7 +1363,7 @@ sr_state_init(int save_to_disk, int read_from_disk)
/* We have a state in memory, let's make sure it's updated for the current
* and next voting round. */
{
time_t valid_after = get_next_valid_after_time(now);
time_t valid_after = dirvote_get_next_valid_after_time();
sr_state_update(valid_after);
}
return 0;

2
src/or/shared_random_state.h
View File

@ -130,7 +130,7 @@ unsigned int sr_state_get_protocol_run_duration(void);
STATIC int disk_state_load_from_disk_impl(const char *fname);
STATIC sr_phase_t get_sr_protocol_phase(time_t valid_after);
STATIC time_t get_start_time_of_current_round(time_t now);
STATIC time_t get_start_time_of_current_round(void);
STATIC time_t get_state_valid_until_time(time_t now);
STATIC const char *get_phase_str(sr_phase_t phase);

1
src/test/test_dir.c
View File

@ -2379,6 +2379,7 @@ test_a_networkstatus(
sign_skey_2 = crypto_pk_new();
sign_skey_3 = crypto_pk_new();
sign_skey_leg1 = pk_generate(4);
dirvote_recalculate_timing(get_options(), now);
sr_state_init(0, 0);
tt_assert(!crypto_pk_read_private_key_from_string(sign_skey_1,

21
src/test/test_hs_common.c
View File

@ -23,6 +23,7 @@
#include "config.h"
#include "networkstatus.h"
#include "directory.h"
#include "dirvote.h"
#include "nodelist.h"
#include "routerlist.h"
#include "statefile.h"
@ -808,26 +809,41 @@ test_time_between_tp_and_srv(void *arg)
ret = parse_rfc1123_time("Sat, 26 Oct 1985 00:00:00 UTC", &ns.valid_after);
tt_int_op(ret, OP_EQ, 0);
ret = parse_rfc1123_time("Sat, 26 Oct 1985 01:00:00 UTC", &ns.fresh_until);
tt_int_op(ret, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), ns.valid_after);
ret = hs_in_period_between_tp_and_srv(&ns, 0);
tt_int_op(ret, OP_EQ, 0);
ret = parse_rfc1123_time("Sat, 26 Oct 1985 11:00:00 UTC", &ns.valid_after);
tt_int_op(ret, OP_EQ, 0);
ret = parse_rfc1123_time("Sat, 26 Oct 1985 12:00:00 UTC", &ns.fresh_until);
tt_int_op(ret, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), ns.valid_after);
ret = hs_in_period_between_tp_and_srv(&ns, 0);
tt_int_op(ret, OP_EQ, 0);
ret = parse_rfc1123_time("Sat, 26 Oct 1985 12:00:00 UTC", &ns.valid_after);
tt_int_op(ret, OP_EQ, 0);
ret = parse_rfc1123_time("Sat, 26 Oct 1985 13:00:00 UTC", &ns.fresh_until);
tt_int_op(ret, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), ns.valid_after);
ret = hs_in_period_between_tp_and_srv(&ns, 0);
tt_int_op(ret, OP_EQ, 1);
ret = parse_rfc1123_time("Sat, 26 Oct 1985 23:00:00 UTC", &ns.valid_after);
tt_int_op(ret, OP_EQ, 0);
ret = parse_rfc1123_time("Sat, 27 Oct 1985 00:00:00 UTC", &ns.fresh_until);
tt_int_op(ret, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), ns.valid_after);
ret = hs_in_period_between_tp_and_srv(&ns, 0);
tt_int_op(ret, OP_EQ, 1);
ret = parse_rfc1123_time("Sat, 26 Oct 1985 00:00:00 UTC", &ns.valid_after);
ret = parse_rfc1123_time("Sat, 27 Oct 1985 00:00:00 UTC", &ns.valid_after);
tt_int_op(ret, OP_EQ, 0);
ret = parse_rfc1123_time("Sat, 27 Oct 1985 01:00:00 UTC", &ns.fresh_until);
tt_int_op(ret, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), ns.valid_after);
ret = hs_in_period_between_tp_and_srv(&ns, 0);
tt_int_op(ret, OP_EQ, 0);
@ -1314,6 +1330,7 @@ run_reachability_scenario(const reachability_cfg_t *cfg, int num_scenario)
&mock_service_ns->valid_until);
set_consensus_times(cfg->service_valid_until,
&mock_service_ns->fresh_until);
dirvote_recalculate_timing(get_options(), mock_service_ns->valid_after);
/* Set client consensus time. */
set_consensus_times(cfg->client_valid_after,
&mock_client_ns->valid_after);
@ -1321,6 +1338,7 @@ run_reachability_scenario(const reachability_cfg_t *cfg, int num_scenario)
&mock_client_ns->valid_until);
set_consensus_times(cfg->client_valid_until,
&mock_client_ns->fresh_until);
dirvote_recalculate_timing(get_options(), mock_client_ns->valid_after);
/* New time period checks for this scenario. */
tt_int_op(hs_in_period_between_tp_and_srv(mock_service_ns, 0), OP_EQ,
@ -1544,6 +1562,7 @@ helper_set_consensus_and_system_time(networkstatus_t *ns, int position)
} else {
tt_assert(0);
}
dirvote_recalculate_timing(get_options(), ns->valid_after);
/* Set system time: pretend to be just 2 minutes before consensus expiry */
real_time = ns->valid_until - 120;

4
src/test/test_hs_service.c
View File

@ -33,6 +33,7 @@
#include "circuitlist.h"
#include "circuituse.h"
#include "crypto.h"
#include "dirvote.h"
#include "networkstatus.h"
#include "nodelist.h"
#include "relay.h"
@ -967,6 +968,7 @@ test_rotate_descriptors(void *arg)
ret = parse_rfc1123_time("Sat, 26 Oct 1985 14:00:00 UTC",
&mock_ns.fresh_until);
tt_int_op(ret, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), mock_ns.valid_after);
/* Create a service with a default descriptor and state. It's added to the
* global map. */
@ -1004,6 +1006,7 @@ test_rotate_descriptors(void *arg)
ret = parse_rfc1123_time("Sat, 27 Oct 1985 02:00:00 UTC",
&mock_ns.fresh_until);
tt_int_op(ret, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), mock_ns.valid_after);
/* Note down what to expect for the next rotation time which is 01:00 + 23h
* meaning 00:00:00. */
@ -1065,6 +1068,7 @@ test_build_update_descriptors(void *arg)
ret = parse_rfc1123_time("Sat, 26 Oct 1985 04:00:00 UTC",
&mock_ns.fresh_until);
tt_int_op(ret, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), mock_ns.valid_after);
/* Create a service without a current descriptor to trigger a build. */
service = helper_create_service();

149
src/test/test_shared_random.c
View File

@ -134,7 +134,15 @@ test_get_sr_protocol_phase(void *arg)
;
}
static networkstatus_t *mock_consensus = NULL;
static networkstatus_t mock_consensus;
/* Mock function to immediately return our local 'mock_consensus'. */
static networkstatus_t *
mock_networkstatus_get_live_consensus(time_t now)
{
(void) now;
return &mock_consensus;
}
static void
test_get_state_valid_until_time(void *arg)
@ -146,11 +154,23 @@ test_get_state_valid_until_time(void *arg)
(void) arg;
MOCK(networkstatus_get_live_consensus,
mock_networkstatus_get_live_consensus);
retval = parse_rfc1123_time("Mon, 20 Apr 2015 01:00:00 UTC",
&mock_consensus.fresh_until);
tt_int_op(retval, OP_EQ, 0);
retval = parse_rfc1123_time("Mon, 20 Apr 2015 00:00:00 UTC",
&mock_consensus.valid_after);
tt_int_op(retval, OP_EQ, 0);
{
/* Get the valid until time if called at 00:00:01 */
retval = parse_rfc1123_time("Mon, 20 Apr 2015 00:00:01 UTC",
&current_time);
tt_int_op(retval, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), current_time);
valid_until_time = get_state_valid_until_time(current_time);
/* Compare it with the correct result */
@ -162,6 +182,7 @@ test_get_state_valid_until_time(void *arg)
retval = parse_rfc1123_time("Mon, 20 Apr 2015 19:22:00 UTC",
&current_time);
tt_int_op(retval, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), current_time);
valid_until_time = get_state_valid_until_time(current_time);
format_iso_time(tbuf, valid_until_time);
@ -172,6 +193,7 @@ test_get_state_valid_until_time(void *arg)
retval = parse_rfc1123_time("Mon, 20 Apr 2015 23:59:00 UTC",
&current_time);
tt_int_op(retval, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), current_time);
valid_until_time = get_state_valid_until_time(current_time);
format_iso_time(tbuf, valid_until_time);
@ -182,6 +204,7 @@ test_get_state_valid_until_time(void *arg)
retval = parse_rfc1123_time("Mon, 20 Apr 2015 00:00:00 UTC",
&current_time);
tt_int_op(retval, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), current_time);
valid_until_time = get_state_valid_until_time(current_time);
format_iso_time(tbuf, valid_until_time);
@ -189,7 +212,7 @@ test_get_state_valid_until_time(void *arg)
}
done:
;
UNMOCK(networkstatus_get_live_consensus);
}
/** Test the function that calculates the start time of the current SRV
@ -203,11 +226,23 @@ test_get_start_time_of_current_run(void *arg)
(void) arg;
MOCK(networkstatus_get_live_consensus,
mock_networkstatus_get_live_consensus);
retval = parse_rfc1123_time("Mon, 20 Apr 2015 01:00:00 UTC",
&mock_consensus.fresh_until);
tt_int_op(retval, OP_EQ, 0);
retval = parse_rfc1123_time("Mon, 20 Apr 2015 00:00:00 UTC",
&mock_consensus.valid_after);
tt_int_op(retval, OP_EQ, 0);
{
/* Get start time if called at 00:00:01 */
retval = parse_rfc1123_time("Mon, 20 Apr 2015 00:00:01 UTC",
&current_time);
tt_int_op(retval, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), current_time);
run_start_time =
sr_state_get_start_time_of_current_protocol_run(current_time);
@ -220,6 +255,7 @@ test_get_start_time_of_current_run(void *arg)
retval = parse_rfc1123_time("Mon, 20 Apr 2015 23:59:59 UTC",
&current_time);
tt_int_op(retval, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), current_time);
run_start_time =
sr_state_get_start_time_of_current_protocol_run(current_time);
@ -232,6 +268,7 @@ test_get_start_time_of_current_run(void *arg)
retval = parse_rfc1123_time("Mon, 20 Apr 2015 00:00:00 UTC",
&current_time);
tt_int_op(retval, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), current_time);
run_start_time =
sr_state_get_start_time_of_current_protocol_run(current_time);
@ -240,6 +277,10 @@ test_get_start_time_of_current_run(void *arg)
tt_str_op("2015-04-20 00:00:00", OP_EQ, tbuf);
}
/* Next test is testing it without a consensus to use the testing voting
* interval . */
UNMOCK(networkstatus_get_live_consensus);
/* Now let's alter the voting schedule and check the correctness of the
* function. Voting interval of 10 seconds, means that an SRV protocol run
* takes 10 seconds * 24 rounds = 4 mins */
@ -249,8 +290,8 @@ test_get_start_time_of_current_run(void *arg)
options->TestingV3AuthInitialVotingInterval = 10;
retval = parse_rfc1123_time("Mon, 20 Apr 2015 00:15:32 UTC",
&current_time);
tt_int_op(retval, OP_EQ, 0);
dirvote_recalculate_timing(get_options(), current_time);
run_start_time =
sr_state_get_start_time_of_current_protocol_run(current_time);
@ -269,22 +310,31 @@ static void
test_get_start_time_functions(void *arg)
{
(void) arg;
time_t now = approx_time();
int retval;
MOCK(networkstatus_get_live_consensus,
mock_networkstatus_get_live_consensus);
retval = parse_rfc1123_time("Mon, 20 Apr 2015 01:00:00 UTC",
&mock_consensus.fresh_until);
tt_int_op(retval, OP_EQ, 0);
retval = parse_rfc1123_time("Mon, 20 Apr 2015 00:00:00 UTC",
&mock_consensus.valid_after);
tt_int_op(retval, OP_EQ, 0);
time_t now = mock_consensus.valid_after;
dirvote_recalculate_timing(get_options(), now);
time_t start_time_of_protocol_run =
sr_state_get_start_time_of_current_protocol_run(now);
tt_assert(start_time_of_protocol_run);
/* Check that the round start time of the beginning of the run, is itself */
tt_int_op(get_start_time_of_current_round(start_time_of_protocol_run), OP_EQ,
tt_int_op(get_start_time_of_current_round(), OP_EQ,
start_time_of_protocol_run);
/* Check that even if we increment the start time, we still get the start
time of the run as the beginning of the round. */
tt_int_op(get_start_time_of_current_round(start_time_of_protocol_run+1),
OP_EQ, start_time_of_protocol_run);
done: ;
done:
UNMOCK(networkstatus_get_live_consensus);
}
static void
@ -306,81 +356,6 @@ test_get_sr_protocol_duration(void *arg)
done: ;
}
/* Mock function to immediately return our local 'mock_consensus'. */
static networkstatus_t *
mock_networkstatus_get_live_consensus(time_t now)
{
(void) now;
return mock_consensus;
}
/** Test the get_next_valid_after_time() function. */
static void
test_get_next_valid_after_time(void *arg)
{
time_t current_time;
time_t valid_after_time;
char tbuf[ISO_TIME_LEN + 1];
int retval;
(void) arg;
{
/* Setup a fake consensus just to get the times out of it, since
get_next_valid_after_time() needs them. */
mock_consensus = tor_malloc_zero(sizeof(networkstatus_t));
retval = parse_rfc1123_time("Mon, 13 Jan 2016 16:00:00 UTC",
&mock_consensus->fresh_until);
tt_int_op(retval, OP_EQ, 0);
retval = parse_rfc1123_time("Mon, 13 Jan 2016 15:00:00 UTC",
&mock_consensus->valid_after);
tt_int_op(retval, OP_EQ, 0);
MOCK(networkstatus_get_live_consensus,
mock_networkstatus_get_live_consensus);
}
{
/* Get the valid after time if called at 00:00:00 */
retval = parse_rfc1123_time("Mon, 20 Apr 2015 00:00:00 UTC",
&current_time);
tt_int_op(retval, OP_EQ, 0);
valid_after_time = get_next_valid_after_time(current_time);
/* Compare it with the correct result */
format_iso_time(tbuf, valid_after_time);
tt_str_op("2015-04-20 01:00:00", OP_EQ, tbuf);
}
{
/* Get the valid until time if called at 00:00:01 */
retval = parse_rfc1123_time("Mon, 20 Apr 2015 00:00:01 UTC",
&current_time);
tt_int_op(retval, OP_EQ, 0);
valid_after_time = get_next_valid_after_time(current_time);
/* Compare it with the correct result */
format_iso_time(tbuf, valid_after_time);
tt_str_op("2015-04-20 01:00:00", OP_EQ, tbuf);
}
{
retval = parse_rfc1123_time("Mon, 20 Apr 2015 23:30:01 UTC",
&current_time);
tt_int_op(retval, OP_EQ, 0);
valid_after_time = get_next_valid_after_time(current_time);
/* Compare it with the correct result */
format_iso_time(tbuf, valid_after_time);
tt_str_op("2015-04-21 00:00:00", OP_EQ, tbuf);
}
done:
networkstatus_vote_free(mock_consensus);
}
/* In this test we are going to generate a sr_commit_t object and validate
* it. We first generate our values, and then we parse them as if they were
* received from the network. After we parse both the commit and the reveal,
@ -1389,8 +1364,6 @@ struct testcase_t sr_tests[] = {
NULL, NULL },
{ "encoding", test_encoding, TT_FORK,
NULL, NULL },
{ "get_next_valid_after_time", test_get_next_valid_after_time, TT_FORK,
NULL, NULL },
{ "get_start_time_of_current_run", test_get_start_time_of_current_run,
TT_FORK, NULL, NULL },
{ "get_start_time_functions", test_get_start_time_functions,