nihilist/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-09-23 14:34:58 +02:00
Code Issues Packages Projects Releases Wiki Activity
af1918d289
tor/src/or/entrynodes.c

3803 lines
128 KiB
C
Raw Normal View History

Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/* Copyright (c) 2001 Matej Pfajfar.
* Copyright (c) 2001-2004, Roger Dingledine.
* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
Update the copyright year.
2016-02-27 18:48:19 +01:00
* Copyright (c) 2007-2016, The Tor Project, Inc. */
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/* See LICENSE for licensing information */
/**
* \file entrynodes.c
* \brief Code to manage our fixed first nodes for various functions.
*
* Entry nodes can be guards (for general use) or bridges (for censorship
* circumvention).
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
*
* XXXX prop271 This module is in flux, since I'm currently in the middle of
* implementation proposal 271. The module documentation here will describe
* the new algorithm and data structures; the old ones should get removed as
* proposal 271 is completed.
*
* In general, we use entry guards to prevent traffic-sampling attacks:
* if we chose every circuit independently, an adversary controlling
* some fraction of paths on the network would observe a sample of every
* user's traffic. Using guards gives users a chance of not being
* profiled.
*
* The current entry guard selection code is designed to try to avoid
* _ever_ trying every guard on the network, to try to stick to guards
* that we've used before, to handle hostile/broken networks, and
* to behave sanely when the network goes up and down.
*
* Our algorithm works as follows: First, we maintain a SAMPLE of guards
* we've seen in the networkstatus consensus. We maintain this sample
* over time, and store it persistently; it is chosen without reference
* to our configuration or firewall rules. Guards remain in the sample
* as they enter and leave the consensus. We expand this sample as
* needed, up to a maximum size.
*
* As a subset of the sample, we maintain a FILTERED SET of the guards
* that we would be willing to use if we could connect to them. The
* filter removes all the guards that we're excluding because they're
* bridges (or not bridges), because we have restrictive firewall rules,
* because of ExcludeNodes, because we of path bias restrictions,
* because they're absent from the network at present, and so on.
*
* As a subset of the filtered set, we keep a REACHABLE FILTERED SET
* (also called a "usable filtered set") of those guards that we call
* "reachable" or "maybe reachable". A guard is reachable if we've
* connected to it more recently than we've failed. A guard is "maybe
* reachable" if we have never tried to connect to it, or if we
* failed to connect to it so long ago that we no longer think our
* failure means it's down.
*
* As a persistent ordered list whose elements are taken from the
* sampled set, we track a CONFIRMED GUARDS LIST. A guard becomes
* confirmed when we successfully build a circuit through it, and decide
* to use that circuit. We order the guards on this list by the order
* in which they became confirmed.
*
* And as a final group, we have an ordered list of PRIMARY GUARDS,
* whose elements are taken from the filtered set. We prefer
* confirmed guards to non-confirmed guards for this list, and place
* other restrictions on it. The primary guards are the ones that we
* connect to "when nothing is wrong" -- circuits through them can be used
* immediately.
*
* To build circuits, we take a primary guard if possible -- or a
* reachable filtered confirmed guard if no primary guard is possible --
* or a random reachable filtered guard otherwise. If the guard is
* primary, we can use the circuit immediately on success. Otherwise,
* the guard is now "pending" -- we won't use its circuit unless all
* of the circuits we're trying to build through better guards have
* definitely failed.
*
* While we're building circuits, we track a little "guard state" for
* each circuit. We use this to keep track of whether the circuit is
* one that we can use as soon as its done, or whether it's one that
* we should keep around to see if we can do better. In the latter case,
* a periodic call to entry_guards_upgrade_waiting_circuits() will
* eventually upgrade it.
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02: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
/* DOCDOC -- expand this.
*
* XXXX prop271 -- make sure we check all of these properties everywhere we
* should.
*
* Information invariants:
*
* [x] whenever a guard becomes unreachable, clear its usable_filtered flag.
*
* [x] Whenever a guard becomes reachable or maybe-reachable, if its filtered
* flag is set, set its usable_filtered flag.
*
* [ ] Whenever we get a new consensus, call update_from_consensus(). (LATER.)
*
* [ ] Whenever the configuration changes in a relevant way, update the
* filtered/usable flags. (LATER.)
*
* [x] Whenever we add a guard to the sample, make sure its filtered/usable
* flags are set as possible.
*
* [x] Whenever we remove a guard from the sample, remove it from the primary
* and confirmed lists.
*
* [ ] When we make a guard confirmed, update the primary list.
*
* [ ] When we make a guard filtered or unfiltered, update the primary list.
*
* [ ] When we are about to pick a guard, make sure that the primary list is
* full.
*
* [x] Before calling sample_reachable_filtered_entry_guards(), make sure
* that the filtered, primary, and confirmed flags are up-to-date.
*
* [x] Call entry_guard_consider_retry every time we are about to check
* is_usable_filtered or is_reachable, and every time we set
* is_filtered to 1.
*
* [x] Call entry_guards_changed_for_guard_selection() whenever we update
* a persistent field.
*/
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
Make a few entrynodes.c functions testable.
2014-06-16 03:38:52 +02:00
#define ENTRYNODES_PRIVATE
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
#include "or.h"
Split bridge functions into a new module. This patch is just: * Code movement * Adding headers here and there as needed * Adding a bridges_free_all() with a call to it. It breaks compilation, since the bridge code needed to make exactly 2 calls into entrynodes.c internals. I'll fix those in the next commit.
2016-11-15 13:49:06 +01:00
#include "bridges.h"
Add missing includes for circpathbias.h
2013-10-31 19:33:34 +01:00
#include "circpathbias.h"
Fix more madness from the split_circuitbuild merge
2012-10-22 20:36:30 +02:00
#include "circuitbuild.h"
New entry_guard_chan_failed function To be called when an entire channel has failed: tell any/all circuits pending for the guard of that channel that they have failed.
2016-11-21 23:18:35 +01:00
#include "circuitlist.h"
Fix more madness from the split_circuitbuild merge
2012-10-22 20:36:30 +02:00
#include "circuitstats.h"
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
#include "config.h"
Fix more madness from the split_circuitbuild merge
2012-10-22 20:36:30 +02:00
#include "confparse.h"
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
#include "connection.h"
#include "connection_or.h"
#include "control.h"
#include "directory.h"
#include "entrynodes.h"
Fix more madness from the split_circuitbuild merge
2012-10-22 20:36:30 +02:00
#include "main.h"
use microdescriptors if *any* of our bridges can handle them Now as we move into a future where most bridges can handle microdescs we will generally find ourselves using them, rather than holding back just because one of our bridges doesn't use them.
2012-01-26 02:18:51 +01:00
#include "microdesc.h"
Merge branch 'bug8240_v2_squashed' into maint-0.2.4 Conflicts: doc/tor.1.txt src/or/circuitbuild.c src/or/config.c src/or/or.h
2013-03-19 21:15:27 +01:00
#include "networkstatus.h"
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
#include "nodelist.h"
#include "policies.h"
#include "router.h"
#include "routerlist.h"
#include "routerparse.h"
#include "routerset.h"
#include "transports.h"
#include "statefile.h"
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
static smartlist_t *guard_contexts = NULL;
static guard_selection_t *curr_guard_context = NULL;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
static const node_t *choose_random_entry_impl(guard_selection_t *gs,
cpath_build_state_t *state,
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
int for_directory,
Fix our check for the "first" bridge descriptor. This is meant to be a better bug 9229 fix -- or at least, one more in tune with the intent of the original code, which calls router_retry_directory_downloads() only on the first bridge descriptor.
2014-03-10 20:11:21 +01:00
dirinfo_type_t dirtype,
int *n_options_out);
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 entry_guard_set_filtered_flags(const or_options_t *options,
guard_selection_t *gs,
entry_guard_t *guard);
Collect old guard algorithm parameters into one place
2016-11-15 14:28:41 +01:00
/** Return 0 if we should apply guardfraction information found in the
* consensus. A specific consensus can be specified with the
* <b>ns</b> argument, if NULL the most recent one will be picked.*/
int
should_apply_guardfraction(const networkstatus_t *ns)
{
/* We need to check the corresponding torrc option and the consensus
* parameter if we need to. */
const or_options_t *options = get_options();
/* If UseGuardFraction is 'auto' then check the same-named consensus
* parameter. If the consensus parameter is not present, default to
* "off". */
if (options->UseGuardFraction == -1) {
return networkstatus_get_param(ns, "UseGuardFraction",
0, /* default to "off" */
0, 1);
}
return options->UseGuardFraction;
}
Add parameters for new (prop271) guard algorithm. These are taken from the proposal, and defined there. Some of them should turn into consensus parameters. Also, remove some dead code that was there to make compilation work, and use ATTR_UNUSED like a normal person.
2016-11-15 14:38:33 +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
/** Allocate and return a new guard_selection_t */
Refactor to always allocate chosen_entry_guards in new guard_selection_new() function
2016-10-14 02:15:30 +02: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
STATIC guard_selection_t *
Refactor to always allocate chosen_entry_guards in new guard_selection_new() function
2016-10-14 02:15:30 +02:00
guard_selection_new(void)
{
guard_selection_t *gs;
gs = tor_malloc_zero(sizeof(*gs));
gs->chosen_entry_guards = smartlist_new();
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
gs->sampled_entry_guards = smartlist_new();
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
gs->confirmed_entry_guards = smartlist_new();
gs->primary_entry_guards = smartlist_new();
Refactor to always allocate chosen_entry_guards in new guard_selection_new() function
2016-10-14 02:15:30 +02:00
return gs;
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Get current default guard_selection_t, creating it if necessary */
guard_selection_t *
get_guard_selection_info(void)
{
if (!guard_contexts) {
guard_contexts = smartlist_new();
}
if (!curr_guard_context) {
Refactor to always allocate chosen_entry_guards in new guard_selection_new() function
2016-10-14 02:15:30 +02:00
curr_guard_context = guard_selection_new();
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
smartlist_add(guard_contexts, curr_guard_context);
}
return curr_guard_context;
}
/** Return the list of entry guards for a guard_selection_t, creating it
* if necessary. */
const smartlist_t *
get_entry_guards_for_guard_selection(guard_selection_t *gs)
{
tor_assert(gs != NULL);
Refactor to always allocate chosen_entry_guards in new guard_selection_new() function
2016-10-14 02:15:30 +02:00
tor_assert(gs->chosen_entry_guards != NULL);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
return gs->chosen_entry_guards;
}
/** Return the list of entry guards for the default guard_selection_t,
* creating it if necessary. */
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
const smartlist_t *
get_entry_guards(void)
{
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
return get_entry_guards_for_guard_selection(get_guard_selection_info());
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
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
/** Helper: mark an entry guard as not usable. */
void
entry_guard_mark_bad(entry_guard_t *guard)
{
guard->bad_since = approx_time();
entry_guards_changed();
}
/** Return a statically allocated human-readable description of <b>guard</b>
*/
const char *
entry_guard_describe(const entry_guard_t *guard)
{
static char buf[256];
tor_snprintf(buf, sizeof(buf),
"%s ($%s)",
guard->nickname, hex_str(guard->identity, DIGEST_LEN));
return buf;
}
Fix remaining case of circpathbias inspecting entryguard internals
2016-11-14 18:48:18 +01:00
/** Return <b>guard</b>'s 20-byte RSA identity digest */
const char *
entry_guard_get_rsa_id_digest(const entry_guard_t *guard)
{
return guard->identity;
}
Make entry_guard_t opaque to circpathbias.c This was a relatively mechanical change. First, I added an accessor function for the pathbias-state field of a guard. Then I did a search-and-replace in circpathbias.c to replace "guard->pb." with "pb->". Finally, I made sure that "pb" was declared whenever it was needed.
2016-11-14 18:57:05 +01:00
/** Return the pathbias state associated with <b>guard</b>. */
guard_pathbias_t *
entry_guard_get_pathbias_state(entry_guard_t *guard)
{
return &guard->pb;
}
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
HANDLE_IMPL(entry_guard, entry_guard_t, ATTR_UNUSED STATIC)
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
/** Return an interval betweeen 'now' and 'max_backdate' seconds in the past,
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
* chosen uniformly at random. We use this before recording persistent
* dates, so that we aren't leaking exactly when we recorded it.
*/
MOCK_IMPL(STATIC time_t,
randomize_time,(time_t now, time_t max_backdate))
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
{
tor_assert(max_backdate > 0);
time_t earliest = now - max_backdate;
time_t latest = now;
if (earliest <= 0)
earliest = 1;
if (latest <= earliest)
latest = earliest + 1;
return crypto_rand_time_range(earliest, latest);
}
/**
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
* Return true iff <b>node</b> has all the flags needed for us to consider it
* a possible guard when sampling guards.
*/
static int
node_is_possible_guard(guard_selection_t *gs, const node_t *node)
{
/* The "GUARDS" set is all nodes in the nodelist for which this predicate
* holds. */
/* XXXX -- prop271 spec deviation. We require node_is_dir() here. */
(void)gs;
tor_assert(node);
return (node->is_possible_guard &&
node->is_stable &&
node->is_fast &&
node->is_valid &&
node_is_dir(node));
}
/**
* Return the sampled guard with the RSA identity digest <b>rsa_id</b>, or
* NULL if we don't have one. */
STATIC entry_guard_t *
get_sampled_guard_with_id(guard_selection_t *gs,
const uint8_t *rsa_id)
{
tor_assert(gs);
tor_assert(rsa_id);
SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, guard) {
if (tor_memeq(guard->identity, rsa_id, DIGEST_LEN))
return guard;
} SMARTLIST_FOREACH_END(guard);
return NULL;
}
/**
* Return true iff we have a sampled guard with the RSA identity digest
* <b>rsa_id</b>. */
static inline int
have_sampled_guard_with_id(guard_selection_t *gs, const uint8_t *rsa_id)
{
return get_sampled_guard_with_id(gs, rsa_id) != NULL;
}
/**
* Allocate a new entry_guard_t object for <b>node</b>, add it to the
* sampled entry guards in <b>gs</b>, and return it. <b>node</b> must
* not currently be a sampled guard in <b>gs</b>.
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
*/
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 entry_guard_t *
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
entry_guard_add_to_sample(guard_selection_t *gs,
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 node_t *node)
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
{
Add parameters for new (prop271) guard algorithm. These are taken from the proposal, and defined there. Some of them should turn into consensus parameters. Also, remove some dead code that was there to make compilation work, and use ATTR_UNUSED like a normal person.
2016-11-15 14:38:33 +01:00
const int GUARD_LIFETIME = GUARD_LIFETIME_DAYS * 86400;
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
tor_assert(gs);
tor_assert(node);
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
log_info(LD_GUARD, "Adding %s as to the entry guard sample set.",
node_describe(node));
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
// XXXX prop271 take ed25519 identity here too.
/* make sure that the guard is not already sampled. */
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 (BUG(have_sampled_guard_with_id(gs, (uint8_t*)node->identity)))
return NULL; // LCOV_EXCL_LINE
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
entry_guard_t *guard = tor_malloc_zero(sizeof(entry_guard_t));
/* persistent fields */
memcpy(guard->identity, node->identity, DIGEST_LEN);
strlcpy(guard->nickname, node_get_nickname(node), sizeof(guard->nickname));
guard->sampled_on_date = randomize_time(approx_time(), GUARD_LIFETIME/10);
tor_free(guard->sampled_by_version);
guard->sampled_by_version = tor_strdup(VERSION);
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
guard->currently_listed = 1;
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
guard->confirmed_idx = -1;
/* non-persistent fields */
guard->is_reachable = GUARD_REACHABLE_MAYBE;
smartlist_add(gs->sampled_entry_guards, guard);
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_guard_set_filtered_flags(get_options(), gs, guard);
entry_guards_changed_for_guard_selection(gs);
return guard;
}
/**
* Return the number of sampled guards in <b>gs</b> that are "filtered"
* (that is, we're willing to connect to them) and that are "usable"
* (that is, either "reachable" or "maybe reachable"). */
STATIC int
num_reachable_filtered_guards(guard_selection_t *gs)
{
int n_reachable_filtered_guards = 0;
SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, guard) {
entry_guard_consider_retry(guard);
if (guard->is_usable_filtered_guard)
++n_reachable_filtered_guards;
} SMARTLIST_FOREACH_END(guard);
return n_reachable_filtered_guards;
}
/**
* Add new guards to the sampled guards in <b>gs</b> until there are
* enough usable filtered guards, but never grow the sample beyond its
* maximum size. Return the last guard added, or NULL if none were
* added.
*/
STATIC entry_guard_t *
entry_guards_expand_sample(guard_selection_t *gs)
{
tor_assert(gs);
int n_sampled = smartlist_len(gs->sampled_entry_guards);
entry_guard_t *added_guard = NULL;
smartlist_t *nodes = nodelist_get_list();
/* Construct eligible_guards as GUARDS - SAMPLED_GUARDS */
smartlist_t *eligible_guards = smartlist_new();
int n_guards = 0; // total size of "GUARDS"
int n_usable_filtered_guards = num_reachable_filtered_guards(gs);
{
/* Build a bloom filter of our current guards: let's keep this O(N). */
digestset_t *sampled_guard_ids = digestset_new(n_sampled);
SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, const entry_guard_t *,
guard) {
digestset_add(sampled_guard_ids, guard->identity);
} SMARTLIST_FOREACH_END(guard);
SMARTLIST_FOREACH_BEGIN(nodes, node_t *, node) {
if (! node_is_possible_guard(gs, node))
continue;
++n_guards;
if (digestset_contains(sampled_guard_ids, node->identity))
continue;
smartlist_add(eligible_guards, node);
} SMARTLIST_FOREACH_END(node);
/* Now we can free that bloom filter. */
digestset_free(sampled_guard_ids);
}
/* Is there at least one guard we haven't sampled? */
if (! smartlist_len(eligible_guards))
goto done;
const int max_sample = (int)(n_guards * MAX_SAMPLE_THRESHOLD);
const int min_filtered_sample = MIN_FILTERED_SAMPLE_SIZE;
log_info(LD_GUARD, "Expanding the sample guard set. We have %d guards "
"in the sample, and %d eligible guards to extend it with.",
n_sampled, smartlist_len(eligible_guards));
while (n_usable_filtered_guards < min_filtered_sample) {
/* Has our sample grown too large to expand? */
if (n_sampled >= max_sample) {
log_info(LD_GUARD, "Not expanding the guard sample any further; "
"just hit the maximum sample threshold of %d",
max_sample);
goto done;
}
/* Did we run out of guards? */
if (smartlist_len(eligible_guards) == 0) {
/* LCOV_EXCL_START
As long as MAX_SAMPLE_THRESHOLD makes can't be adjusted to
allow all guards to be sampled, this can't be reached.
*/
log_info(LD_GUARD, "Not expanding the guard sample any further; "
"just ran out of eligible guards");
goto done;
/* LCOV_EXCL_STOP */
}
/* Otherwise we can add at least one new guard. */
const node_t *node =
node_sl_choose_by_bandwidth(eligible_guards, WEIGHT_FOR_GUARD);
if (BUG(! node))
goto done; // LCOV_EXCL_LINE -- should be impossible.
added_guard = entry_guard_add_to_sample(gs, node);
if (!added_guard)
goto done; // LCOV_EXCL_LINE -- only fails on BUG.
++n_sampled;
if (added_guard->is_usable_filtered_guard)
++n_usable_filtered_guards;
smartlist_remove(eligible_guards, node);
}
done:
smartlist_free(eligible_guards);
return added_guard;
}
/**
* Helper: <b>guard</b> has just been removed from the sampled guards:
* also remove it from primary and confirmed. */
static void
remove_guard_from_confirmed_and_primary_lists(guard_selection_t *gs,
entry_guard_t *guard)
{
if (guard->is_primary) {
guard->is_primary = 0;
smartlist_remove_keeporder(gs->primary_entry_guards, guard);
} else {
if (BUG(smartlist_contains(gs->primary_entry_guards, guard))) {
smartlist_remove_keeporder(gs->primary_entry_guards, guard);
}
}
if (guard->confirmed_idx >= 0) {
entry_guard_t *found_guard = NULL;
if (guard->confirmed_idx < smartlist_len(gs->confirmed_entry_guards))
found_guard = smartlist_get(gs->confirmed_entry_guards,
guard->confirmed_idx);
if (BUG(guard != found_guard)) {
smartlist_remove_keeporder(gs->confirmed_entry_guards, guard);
} else {
smartlist_del_keeporder(gs->confirmed_entry_guards,
guard->confirmed_idx);
}
guard->confirmed_idx = -1;
guard->confirmed_on_date = 0;
} else {
if (BUG(smartlist_contains(gs->confirmed_entry_guards, guard))) {
smartlist_remove_keeporder(gs->confirmed_entry_guards, guard);
}
}
}
/**
* Update the status of all sampled guards based on the arrival of a
* new consensus networkstatus document. This will include marking
* some guards as listed or unlisted, and removing expired guards. */
STATIC void
sampled_guards_update_from_consensus(guard_selection_t *gs)
{
tor_assert(gs);
const int REMOVE_UNLISTED_GUARDS_AFTER =
(REMOVE_UNLISTED_GUARDS_AFTER_DAYS * 86400);
const int unlisted_since_slop = REMOVE_UNLISTED_GUARDS_AFTER / 5;
// It's important to use only a live consensus here; we don't want to
// make changes based on anything expired or old.
networkstatus_t *ns = networkstatus_get_live_consensus(approx_time());
log_info(LD_GUARD, "Updating sampled guard status based on received "
"consensus.");
if (! ns || ns->valid_until < approx_time()) {
log_info(LD_GUARD, "Hey, that consensus isn't still valid. Ignoring.");
return;
}
int n_changes = 0;
/* First: Update listed/unlisted. */
SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, guard) {
/* XXXX prop271 handle bridges right? */
/* XXXX prop271 check ed ID too */
const node_t *node = node_get_by_id(guard->identity);
const unsigned is_listed = node && node_is_possible_guard(gs, node);
if (is_listed && ! guard->currently_listed) {
++n_changes;
guard->currently_listed = 1;
guard->unlisted_since_date = 0;
log_info(LD_GUARD, "Sampled guard %s is now listed again.",
entry_guard_describe(guard));
} else if (!is_listed && guard->currently_listed) {
++n_changes;
guard->currently_listed = 0;
guard->unlisted_since_date = randomize_time(approx_time(),
unlisted_since_slop);
log_info(LD_GUARD, "Sampled guard %s is now unlisted.",
entry_guard_describe(guard));
} else if (is_listed && guard->currently_listed) {
log_debug(LD_GUARD, "Sampled guard %s is still listed.",
entry_guard_describe(guard));
} else {
tor_assert(! is_listed && ! guard->currently_listed);
log_debug(LD_GUARD, "Sampled guard %s is still unlisted.",
entry_guard_describe(guard));
}
/* Clean up unlisted_since_date, just in case. */
if (guard->currently_listed && guard->unlisted_since_date) {
++n_changes;
guard->unlisted_since_date = 0;
log_warn(LD_BUG, "Sampled guard %s was listed, but with "
"unlisted_since_date set. Fixing.",
entry_guard_describe(guard));
} else if (!guard->currently_listed && ! guard->unlisted_since_date) {
++n_changes;
guard->unlisted_since_date = randomize_time(approx_time(),
unlisted_since_slop);
log_warn(LD_BUG, "Sampled guard %s was unlisted, but with "
"unlisted_since_date unset. Fixing.",
entry_guard_describe(guard));
}
} SMARTLIST_FOREACH_END(guard);
const time_t remove_if_unlisted_since =
approx_time() - REMOVE_UNLISTED_GUARDS_AFTER;
const time_t maybe_remove_if_sampled_before =
approx_time() - (GUARD_LIFETIME_DAYS * 86400);
const time_t remove_if_confirmed_before =
approx_time() - (GUARD_CONFIRMED_MIN_LIFETIME_DAYS * 86400);
/* Then: remove the ones that have been junk for too long */
SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, guard) {
/* XXXX prop271 handle bridges right? */
int remove = 0;
if (guard->currently_listed == 0 &&
guard->unlisted_since_date < remove_if_unlisted_since) {
/*
"We have a live consensus, and {IS_LISTED} is false, and
{FIRST_UNLISTED_AT} is over {REMOVE_UNLISTED_GUARDS_AFTER}
days in the past."
*/
log_info(LD_GUARD, "Removing sampled guard %s: it has been unlisted "
"for over %d days", entry_guard_describe(guard),
REMOVE_UNLISTED_GUARDS_AFTER_DAYS);
remove = 1;
} else if (guard->sampled_on_date < maybe_remove_if_sampled_before) {
/* We have a live consensus, and {ADDED_ON_DATE} is over
{GUARD_LIFETIME} ago, *and* {CONFIRMED_ON_DATE} is either
"never", or over {GUARD_CONFIRMED_MIN_LIFETIME} ago.
*/
if (guard->confirmed_on_date == 0) {
remove = 1;
log_info(LD_GUARD, "Removing sampled guard %s: it was sampled "
"over %d days ago, but never confirmed.",
entry_guard_describe(guard),
GUARD_LIFETIME_DAYS);
} else if (guard->confirmed_on_date < remove_if_confirmed_before) {
remove = 1;
log_info(LD_GUARD, "Removing sampled guard %s: it was sampled "
"over %d days ago, and confirmed over %d days ago.",
entry_guard_describe(guard),
GUARD_LIFETIME_DAYS, GUARD_CONFIRMED_MIN_LIFETIME_DAYS);
}
}
if (remove) {
++n_changes;
SMARTLIST_DEL_CURRENT(gs->sampled_entry_guards, guard);
remove_guard_from_confirmed_and_primary_lists(gs, guard);
entry_guard_free(guard);
}
} SMARTLIST_FOREACH_END(guard);
if (n_changes) {
/* Regnerate other things. XXXXXX prop271 */
// XXXX prop271 rebuild confirmed list.
entry_guards_update_filtered_sets(gs);
entry_guards_changed_for_guard_selection(gs);
}
}
/**
* Return true iff <b>node</b> is a Tor relay that we are configured to
* be able to connect to. */
static int
node_passes_guard_filter(const or_options_t *options, guard_selection_t *gs,
const node_t *node)
{
(void)gs;
if (routerset_contains_node(options->ExcludeNodes, node))
return 0;
/* XXXX -- prop271 spec deviation -- add entrynodes to spec. */
if (options->EntryNodes &&
!options->UseBridges &&
!routerset_contains_node(options->EntryNodes, node))
return 0;
if (!fascist_firewall_allows_node(node, FIREWALL_OR_CONNECTION, 0))
return 0;
if (bool_neq(options->UseBridges, node_is_a_configured_bridge(node)))
return 0;
return 1;
}
/**
* Return true iff <b>guard</b> is a Tor relay that we are configured to
* be able to connect to, and we haven't disabled it for omission from
* the consensus or path bias issues. */
static int
entry_guard_passes_filter(const or_options_t *options, guard_selection_t *gs,
entry_guard_t *guard)
{
if (guard->currently_listed == 0)
return 0;
if (guard->pb.path_bias_disabled)
return 0;
const node_t *node = node_get_by_id(guard->identity);
if (BUG(node == NULL)) {
// should be impossible, since currently_listed was true.
return 0;
}
return node_passes_guard_filter(options, gs, node);
}
/**
* Update the <b>is_filtered_guard</b> and <b>is_usable_filtered_guard</b>
* flags on <b>guard</b>. */
void
entry_guard_set_filtered_flags(const or_options_t *options,
guard_selection_t *gs,
entry_guard_t *guard)
{
guard->is_filtered_guard = 0;
guard->is_usable_filtered_guard = 0;
if (entry_guard_passes_filter(options, gs, guard)) {
guard->is_filtered_guard = 1;
if (guard->is_reachable != GUARD_REACHABLE_NO)
guard->is_usable_filtered_guard = 1;
entry_guard_consider_retry(guard);
}
log_debug(LD_GUARD, "Updated sampled guard %s: filtered=%d; "
"reachable_filtered=%d.", entry_guard_describe(guard),
guard->is_filtered_guard, guard->is_usable_filtered_guard);
}
/**
* Update the <b>is_filtered_guard</b> and <b>is_usable_filtered_guard</b>
* flag on every guard in <b>gs</b>. */
STATIC void
entry_guards_update_filtered_sets(guard_selection_t *gs)
{
const or_options_t *options = get_options();
SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, guard) {
entry_guard_set_filtered_flags(options, gs, guard);
} SMARTLIST_FOREACH_END(guard);
}
/**
* Return a random guard from the reachable filtered sample guards
* in <b>gs</b>, subject to the exclusion rules listed in <b>flags</b>.
* Return NULL if no such guard can be found.
*
* Make sure that the sample is big enough, and that all the filter flags
* are set correctly, before calling this function.
**/
STATIC entry_guard_t *
sample_reachable_filtered_entry_guards(guard_selection_t *gs,
unsigned flags)
{
tor_assert(gs);
entry_guard_t *result = NULL;
const unsigned exclude_confirmed = flags & SAMPLE_EXCLUDE_CONFIRMED;
const unsigned exclude_primary = flags & SAMPLE_EXCLUDE_PRIMARY;
const unsigned exclude_pending = flags & SAMPLE_EXCLUDE_PENDING;
SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, guard) {
entry_guard_consider_retry(guard);
} SMARTLIST_FOREACH_END(guard);
const int n_reachable_filtered = num_reachable_filtered_guards(gs);
log_info(LD_GUARD, "Trying to sample a reachable guard: We know of %d "
"in the USABLE_FILTERED set.", n_reachable_filtered);
if (n_reachable_filtered < MIN_FILTERED_SAMPLE_SIZE) {
log_info(LD_GUARD, " (That isn't enough. Trying to expand the sample.)");
entry_guards_expand_sample(gs);
}
/* Build the set of reachable filtered guards. */
smartlist_t *reachable_filtered_sample = smartlist_new();
SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, guard) {
entry_guard_consider_retry(guard);// redundant, but cheap.
if (! guard->is_usable_filtered_guard)
continue;
if (exclude_confirmed && guard->confirmed_idx >= 0)
continue;
if (exclude_primary && guard->is_primary)
continue;
if (exclude_pending && guard->is_pending)
continue;
smartlist_add(reachable_filtered_sample, guard);
} SMARTLIST_FOREACH_END(guard);
log_info(LD_GUARD, " (After filters [%x], we have %d guards to consider.)",
flags, smartlist_len(reachable_filtered_sample));
if (smartlist_len(reachable_filtered_sample)) {
result = smartlist_choose(reachable_filtered_sample);
log_info(LD_GUARD, " (Selected %s.)",
result ? entry_guard_describe(result) : "<null>");
}
smartlist_free(reachable_filtered_sample);
return result;
}
/**
* Helper: compare two entry_guard_t by their confirmed_idx values.
* Used to sort the confirmed list.
*/
static int
compare_guards_by_confirmed_idx(const void **a_, const void **b_)
{
const entry_guard_t *a = *a_, *b = *b_;
if (a->confirmed_idx < b->confirmed_idx)
return -1;
else if (a->confirmed_idx > b->confirmed_idx)
return 1;
else
return 0;
}
/**
* Find the confirmed guards from among the sampled guards in <b>gs</b>,
* and put them in confirmed_entry_guards in the correct
* order. Recalculate their indices.
*/
STATIC void
entry_guards_update_confirmed(guard_selection_t *gs)
{
smartlist_clear(gs->confirmed_entry_guards);
SMARTLIST_FOREACH_BEGIN(gs->sampled_entry_guards, entry_guard_t *, guard) {
if (guard->confirmed_idx >= 0)
smartlist_add(gs->confirmed_entry_guards, guard);
} SMARTLIST_FOREACH_END(guard);
smartlist_sort(gs->confirmed_entry_guards, compare_guards_by_confirmed_idx);
int any_changed = 0;
SMARTLIST_FOREACH_BEGIN(gs->confirmed_entry_guards, entry_guard_t *, guard) {
if (guard->confirmed_idx != guard_sl_idx) {
any_changed = 1;
guard->confirmed_idx = guard_sl_idx;
}
} SMARTLIST_FOREACH_END(guard);
gs->next_confirmed_idx = smartlist_len(gs->confirmed_entry_guards);
if (any_changed) {
entry_guards_changed_for_guard_selection(gs);
}
}
/**
* Mark <b>guard</b> as a confirmed guard -- that is, one that we have
* connected to, and intend to use again.
*/
STATIC void
make_guard_confirmed(guard_selection_t *gs, entry_guard_t *guard)
{
if (BUG(guard->confirmed_on_date && guard->confirmed_idx >= 0))
return;
if (BUG(smartlist_contains(gs->confirmed_entry_guards, guard)))
return;
const int GUARD_LIFETIME = GUARD_LIFETIME_DAYS * 86400;
guard->confirmed_on_date = randomize_time(approx_time(), GUARD_LIFETIME/10);
log_info(LD_GUARD, "Marking %s as a confirmed guard (index %d)",
entry_guard_describe(guard),
gs->next_confirmed_idx);
guard->confirmed_idx = gs->next_confirmed_idx++;
smartlist_add(gs->confirmed_entry_guards, guard);
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
entry_guards_changed_for_guard_selection(gs);
}
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
/**
* Recalculate the list of primary guards (the ones we'd prefer to use) from
* the filtered sample and the confirmed list.
*
* XXXXX prop271 are calling this enough ???
*/
STATIC void
entry_guards_update_primary(guard_selection_t *gs)
{
tor_assert(gs);
smartlist_t *new_primary_guards = smartlist_new();
smartlist_t *old_primary_guards = smartlist_new();
smartlist_add_all(old_primary_guards, gs->primary_entry_guards);
/* First, can we fill it up with confirmed guards? */
SMARTLIST_FOREACH_BEGIN(gs->confirmed_entry_guards, entry_guard_t *, guard) {
if (smartlist_len(new_primary_guards) >= N_PRIMARY_GUARDS)
break;
if (! guard->is_filtered_guard)
continue;
guard->is_primary = 1;
smartlist_add(new_primary_guards, guard);
} SMARTLIST_FOREACH_END(guard);
/* Can we keep any older primary guards? First remove all the ones
* that we already kept. */
SMARTLIST_FOREACH_BEGIN(old_primary_guards, entry_guard_t *, guard) {
if (smartlist_contains(new_primary_guards, guard)) {
SMARTLIST_DEL_CURRENT_KEEPORDER(old_primary_guards, guard);
}
} SMARTLIST_FOREACH_END(guard);
/* Now add any that are still good. */
SMARTLIST_FOREACH_BEGIN(old_primary_guards, entry_guard_t *, guard) {
if (smartlist_len(new_primary_guards) >= N_PRIMARY_GUARDS)
break;
if (! guard->is_filtered_guard)
continue;
guard->is_primary = 1;
smartlist_add(new_primary_guards, guard);
SMARTLIST_DEL_CURRENT_KEEPORDER(old_primary_guards, guard);
} SMARTLIST_FOREACH_END(guard);
/* Mark the remaining previous primary guards as non-primary */
SMARTLIST_FOREACH_BEGIN(old_primary_guards, entry_guard_t *, guard) {
guard->is_primary = 0;
} SMARTLIST_FOREACH_END(guard);
/* Finally, fill out the list with sampled guards. */
while (smartlist_len(new_primary_guards) < N_PRIMARY_GUARDS) {
entry_guard_t *guard = sample_reachable_filtered_entry_guards(gs,
SAMPLE_EXCLUDE_CONFIRMED|
SAMPLE_EXCLUDE_PRIMARY);
if (!guard)
break;
guard->is_primary = 1;
smartlist_add(new_primary_guards, guard);
}
#if 1
/* Debugging. */
SMARTLIST_FOREACH(gs->sampled_entry_guards, entry_guard_t *, guard, {
tor_assert_nonfatal(
bool_eq(guard->is_primary,
smartlist_contains(new_primary_guards, guard)));
});
#endif
int any_change = 0;
if (smartlist_len(gs->primary_entry_guards) !=
smartlist_len(new_primary_guards)) {
any_change = 1;
} else {
SMARTLIST_FOREACH_BEGIN(gs->primary_entry_guards, entry_guard_t *, g) {
if (g != smartlist_get(new_primary_guards, g_sl_idx)) {
any_change = 1;
}
} SMARTLIST_FOREACH_END(g);
}
if (any_change) {
log_info(LD_GUARD, "Primary entry guards have changed. "
"New primary guard list is: ");
int n = smartlist_len(new_primary_guards);
SMARTLIST_FOREACH_BEGIN(new_primary_guards, entry_guard_t *, g) {
log_info(LD_GUARD, " %d/%d: %s%s%s",
g_sl_idx+1, n, entry_guard_describe(g),
g->confirmed_idx >= 0 ? " (confirmed)" : "",
g->is_filtered_guard ? "" : " (excluded by filter)");
} SMARTLIST_FOREACH_END(g);
}
smartlist_free(old_primary_guards);
smartlist_free(gs->primary_entry_guards);
gs->primary_entry_guards = new_primary_guards;
}
/**
* Return the number of seconds after the last attempt at which we should
* retry a guard that has been failing since <b>failing_since</b>.
*/
static unsigned
get_retry_schedule(time_t failing_since, time_t now,
int is_primary)
{
const unsigned SIX_HOURS = 6 * 3600;
const unsigned FOUR_DAYS = 4 * 86400;
const unsigned SEVEN_DAYS = 7 * 86400;
time_t tdiff;
if (now > failing_since) {
tdiff = now - failing_since;
} else {
tdiff = 0;
}
const struct {
time_t maximum; int primary_delay; int nonprimary_delay;
} delays[] = {
{ SIX_HOURS, 30*60, 1*60*60 },
{ FOUR_DAYS, 2*60*60, 4*60*60 },
{ SEVEN_DAYS, 4*60*60, 18*60*60 },
{ TIME_MAX, 9*60*60, 36*60*60 }
};
unsigned i;
for (i = 0; i < ARRAY_LENGTH(delays); ++i) {
if (tdiff <= delays[i].maximum) {
return is_primary ? delays[i].primary_delay : delays[i].nonprimary_delay;
}
}
/* LCOV_EXCL_START -- can't reach, since delays ends with TIME_MAX. */
tor_assert_nonfatal_unreached();
return 36*60*60;
/* LCOV_EXCL_STOP */
}
/**
* If <b>guard</b> is unreachable, consider whether enough time has passed
* to consider it maybe-reachable again.
*/
STATIC void
entry_guard_consider_retry(entry_guard_t *guard)
{
if (guard->is_reachable != GUARD_REACHABLE_NO)
return; /* No retry needed. */
const time_t now = approx_time();
const unsigned delay =
get_retry_schedule(guard->failing_since, now, guard->is_primary);
const time_t last_attempt = guard->last_tried_to_connect;
if (BUG(last_attempt == 0) ||
now >= last_attempt + delay) {
/* We should mark this retriable. */
char tbuf[ISO_TIME_LEN+1];
format_local_iso_time(tbuf, last_attempt);
log_info(LD_GUARD, "Marked %s%sguard %s for possible retry, since we "
"haven't tried to use it since %s.",
guard->is_primary?"primary ":"",
guard->confirmed_idx>=0?"confirmed ":"",
entry_guard_describe(guard),
tbuf);
guard->is_reachable = GUARD_REACHABLE_MAYBE;
if (guard->is_filtered_guard)
guard->is_usable_filtered_guard = 1;
}
}
New function to tell the guard module "We're on the net!" (Call it whenever we read a cell.)
2016-11-21 23:14:04 +01:00
/** Tell the entry guards subsystem that we have confirmed that as of
* just now, we're on the internet. */
void
entry_guards_note_internet_connectivity(guard_selection_t *gs)
{
gs->last_time_on_internet = approx_time();
}
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
/**
* Get a guard for use with a circuit. Prefer to pick a running primary
* guard; then a non-pending running filtered confirmed guard; then a
* non-pending runnable filtered guard. Update the
* <b>last_tried_to_connect</b> time and the <b>is_pending</b> fields of the
* guard as appropriate. Set <b>state_out</b> to the new guard-state
* of the circuit.
*/
STATIC entry_guard_t *
select_entry_guard_for_circuit(guard_selection_t *gs, unsigned *state_out)
{
tor_assert(gs);
tor_assert(state_out);
/* "If any entry in PRIMARY_GUARDS has {is_reachable} status of
<maybe> or <yes>, return the first such guard." */
SMARTLIST_FOREACH_BEGIN(gs->primary_entry_guards, entry_guard_t *, guard) {
entry_guard_consider_retry(guard);
if (guard->is_reachable != GUARD_REACHABLE_NO) {
*state_out = GUARD_CIRC_STATE_USABLE_ON_COMPLETION;
guard->last_tried_to_connect = approx_time();
log_info(LD_GUARD, "Selected primary guard %s for circuit.",
entry_guard_describe(guard));
return guard;
}
} SMARTLIST_FOREACH_END(guard);
/* "Otherwise, if the ordered intersection of {CONFIRMED_GUARDS}
and {USABLE_FILTERED_GUARDS} is nonempty, return the first
entry in that intersection that has {is_pending} set to
false." */
SMARTLIST_FOREACH_BEGIN(gs->confirmed_entry_guards, entry_guard_t *, guard) {
if (guard->is_primary)
continue; /* we already considered this one. */
entry_guard_consider_retry(guard);
if (guard->is_usable_filtered_guard && ! guard->is_pending) {
guard->is_pending = 1;
guard->last_tried_to_connect = approx_time();
*state_out = GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD;
log_info(LD_GUARD, "No primary guards available. Selected confirmed "
"guard %s for circuit. Will try other guards before using "
"this circuit.",
entry_guard_describe(guard));
return guard;
}
} SMARTLIST_FOREACH_END(guard);
/* "Otherwise, if there is no such entry, select a member at
random from {USABLE_FILTERED_GUARDS}." */
{
entry_guard_t *guard;
guard = sample_reachable_filtered_entry_guards(gs,
SAMPLE_EXCLUDE_CONFIRMED |
SAMPLE_EXCLUDE_PRIMARY |
SAMPLE_EXCLUDE_PENDING);
if (guard == NULL) {
log_info(LD_GUARD, "Absolutely no sampled guards were available.");
return NULL;
}
guard->is_pending = 1;
guard->last_tried_to_connect = approx_time();
*state_out = GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD;
log_info(LD_GUARD, "No primary or confirmed guards available. Selected "
"random guard %s for circuit. Will try other guards before "
"using this circuit.",
entry_guard_describe(guard));
return guard;
}
}
/**
* Note that we failed to connect to or build circuits through <b>guard</b>.
* Use with a guard returned by select_entry_guards_for_circuit().
*/
STATIC void
entry_guards_note_guard_failure(guard_selection_t *gs,
entry_guard_t *guard)
{
tor_assert(gs);
guard->is_reachable = GUARD_REACHABLE_NO;
guard->is_usable_filtered_guard = 0;
guard->is_pending = 0;
if (guard->failing_since == 0)
guard->failing_since = approx_time();
log_info(LD_GUARD, "Recorded failure for %s%sguard %s",
guard->is_primary?"primary ":"",
guard->confirmed_idx>=0?"confirmed ":"",
entry_guard_describe(guard));
}
/**
* Called when the network comes up after having seemed to be down for
* a while: Mark the primary guards as maybe-reachable so that we'll
* try them again.
*/
STATIC void
mark_primary_guards_maybe_reachable(guard_selection_t *gs)
{
SMARTLIST_FOREACH_BEGIN(gs->primary_entry_guards, entry_guard_t *, guard) {
if (guard->is_reachable != GUARD_REACHABLE_NO)
continue;
/* Note that we do not clear failing_since: this guard is now only
* _maybe-reachable_. */
guard->is_reachable = GUARD_REACHABLE_MAYBE;
if (guard->is_filtered_guard)
guard->is_usable_filtered_guard = 1;
} SMARTLIST_FOREACH_END(guard);
}
/**
* Note that we successfully connected to, and built a circuit through
* <b>guard</b>. Given the old guard-state of the circuit in <b>old_state</b>,
* return the new guard-state of the circuit.
*
* Be aware: the circuit is only usable when its guard-state becomes
* GUARD_CIRC_STATE_COMPLETE.
**/
STATIC unsigned
entry_guards_note_guard_success(guard_selection_t *gs,
entry_guard_t *guard,
unsigned old_state)
{
tor_assert(gs);
/* Save this, since we're about to overwrite it. */
const time_t last_time_on_internet = gs->last_time_on_internet;
gs->last_time_on_internet = approx_time();
guard->is_reachable = GUARD_REACHABLE_YES;
guard->failing_since = 0;
guard->is_pending = 0;
if (guard->is_filtered_guard)
guard->is_usable_filtered_guard = 1;
if (guard->confirmed_idx < 0) {
// XXXX prop271 XXXX update primary guards, since we confirmed something?
make_guard_confirmed(gs, guard);
}
unsigned new_state;
if (old_state == GUARD_CIRC_STATE_USABLE_ON_COMPLETION) {
new_state = GUARD_CIRC_STATE_COMPLETE;
} else {
tor_assert_nonfatal(
old_state == GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
new_state = GUARD_CIRC_STATE_WAITING_FOR_BETTER_GUARD;
if (last_time_on_internet + INTERNET_LIKELY_DOWN_INTERVAL
< approx_time()) {
mark_primary_guards_maybe_reachable(gs);
} else {
// update_waiting_circuits(gs); // XXXX prop271 write this function.
}
}
// XXXX prop271 XXXX update primary guards, since we confirmed something?
// XXXX prop261 XXXX if so, here or above?
log_info(LD_GUARD, "Recorded success for %s%sguard %s",
guard->is_primary?"primary ":"",
guard->confirmed_idx>=0?"confirmed ":"",
entry_guard_describe(guard));
return new_state;
}
/**
* Helper: Return true iff <b>a</b> has higher priority than <b>b</b>.
*/
STATIC int
entry_guard_has_higher_priority(entry_guard_t *a, entry_guard_t *b)
{
tor_assert(a && b);
if (a == b)
return 0;
/* Confirmed is always better than unconfirmed; lower index better
than higher */
if (a->confirmed_idx < 0) {
if (b->confirmed_idx >= 0)
return 0;
} else {
if (b->confirmed_idx < 0)
return 1;
/* Lower confirmed_idx is better than higher. */
return (a->confirmed_idx < b->confirmed_idx);
}
/* If we reach this point, both are unconfirmed. If one is pending, it
* has higher priority. */
if (a->is_pending) {
if (! b->is_pending)
return 1;
/* Both are pending: earlier last_tried_connect wins. */
return a->last_tried_to_connect < b->last_tried_to_connect;
} else {
if (b->is_pending)
return 0;
/* Neither is pending: priorities are equal. */
return 0; // XXXX prop271 return a tristate instead?
}
}
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
/**
* Release all storage held in <b>state</b>.
*/
void
circuit_guard_state_free(circuit_guard_state_t *state)
{
/* XXXX prop271 -- do we want to inline this structure? */
if (!state)
return;
entry_guard_handle_free(state->guard);
tor_free(state);
}
/**
* Pick a suitable entry guard for a circuit in, and place that guard
* in *<b>chosen_node_out</b>. Set *<b>guard_state_out</b> to an opaque
* state object that will record whether the circuit is ready to be used
* or not. Return 0 on success; on failure, return -1.
*/
int
entry_guard_pick_for_circuit(guard_selection_t *gs,
const node_t **chosen_node_out,
circuit_guard_state_t **guard_state_out)
{
tor_assert(gs);
tor_assert(chosen_node_out);
tor_assert(guard_state_out);
*chosen_node_out = NULL;
*guard_state_out = NULL;
unsigned state = 0;
entry_guard_t *guard = select_entry_guard_for_circuit(gs, &state);
if (! guard)
return -1;
if (BUG(state == 0))
return -1;
const node_t *node = node_get_by_id(guard->identity);
// XXXX prop271 check Ed ID.
if (! node)
return -1;
*chosen_node_out = node;
*guard_state_out = tor_malloc_zero(sizeof(circuit_guard_state_t));
(*guard_state_out)->guard = entry_guard_handle_new(guard);
(*guard_state_out)->state = state;
(*guard_state_out)->state_set_at = approx_time();
return 0;
}
/**
* Called by the circuit building module when a circuit has succeeded:
* informs the guards code that the guard in *<b>guard_state_p</b> is
* working, and advances the state of the guard module. On a -1 return
* value, the circuit is broken and should not be used. On a 1 return
* value, the circuit is ready to use. On a 0 return value, the circuit
* should not be used until we find out whether preferred guards will
* work for us.
*
* XXXXX prop271 tristates are ugly; reconsider that interface.
*/
int
entry_guard_succeeded(guard_selection_t *gs,
circuit_guard_state_t **guard_state_p)
{
Add an (as yet) unused UseDeprecatedGuardAlgorithm_ option. I expect we'll be ripping this out somewhere in 0.3.0, but let's keep it around for a little while in case it turns out to be the only way to avert disaster?
2016-11-21 23:02:51 +01:00
if (get_options()->UseDeprecatedGuardAlgorithm)
return 1;
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
if (BUG(*guard_state_p == NULL))
return -1;
entry_guard_t *guard = entry_guard_handle_get((*guard_state_p)->guard);
if (! guard)
return -1;
unsigned newstate =
entry_guards_note_guard_success(gs, guard, (*guard_state_p)->state);
(*guard_state_p)->state = newstate;
(*guard_state_p)->state_set_at = approx_time();
if (newstate == GUARD_CIRC_STATE_COMPLETE) {
return 1;
} else {
return 0;
}
}
/**
* Called by the circuit building module when a circuit has succeeded:
* informs the guards code that the guard in *<b>guard_state_p</b> is
* not working, and advances the state of the guard module. Return -1 on
* bug or inconsistency; 0 on success.
*/
int
entry_guard_failed(guard_selection_t *gs,
circuit_guard_state_t **guard_state_p)
{
Add an (as yet) unused UseDeprecatedGuardAlgorithm_ option. I expect we'll be ripping this out somewhere in 0.3.0, but let's keep it around for a little while in case it turns out to be the only way to avert disaster?
2016-11-21 23:02:51 +01:00
if (get_options()->UseDeprecatedGuardAlgorithm)
return;
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
if (BUG(*guard_state_p == NULL))
return -1;
entry_guard_t *guard = entry_guard_handle_get((*guard_state_p)->guard);
if (! guard)
return -1;
entry_guards_note_guard_failure(gs, guard);
(*guard_state_p)->state = GUARD_CIRC_STATE_DEAD;
(*guard_state_p)->state_set_at = approx_time();
New entry_guard_chan_failed function To be called when an entire channel has failed: tell any/all circuits pending for the guard of that channel that they have failed.
2016-11-21 23:18:35 +01:00
/**
* Run the entry_guard_failed() function on every circuit that is
* pending on <b>chan</b>.
*/
void
entry_guard_chan_failed(guard_selection_t *gs,
channel_t *chan)
{
tor_assert(gs);
if (!chan)
return;
if (get_options()->UseDeprecatedGuardAlgorithm)
return;
smartlist_t *pending = smartlist_new();
circuit_get_all_pending_on_channel(pending, chan);
SMARTLIST_FOREACH_BEGIN(pending, circuit_t *, circ) {
if (!CIRCUIT_IS_ORIGIN(circ))
continue;
origin_circuit_t *origin_circ = TO_ORIGIN_CIRCUIT(circ);
entry_guard_failed(gs, &origin_circ->guard_state);
} SMARTLIST_FOREACH_END(circ);
smartlist_free(pending);
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
}
/**
* Return true iff every primary guard in <b>gs</b> is believed to
* be unreachable.
*/
static int
entry_guards_all_primary_guards_are_down(guard_selection_t *gs)
{
/* XXXXX prop271 do we have to call entry_guards_update_primary() ?? */
tor_assert(gs);
SMARTLIST_FOREACH_BEGIN(gs->primary_entry_guards, entry_guard_t *, guard) {
entry_guard_consider_retry(guard);
if (guard->is_reachable != GUARD_REACHABLE_NO)
return 0;
} SMARTLIST_FOREACH_END(guard);
return 1;
}
Backend for upgrading 'waiting' circuits to 'complete' When a nonprimary guard's circuit is complete, we don't call it actually usable until we are pretty sure that every better guard is indeed not going to give us a working circuit.
2016-11-21 15:40:45 +01:00
/** Wrapper for entry_guard_has_higher_priority that compares the
* guard-priorities of a pair of circuits. */
static int
circ_state_has_higher_priority(origin_circuit_t *a,
origin_circuit_t *b)
{
circuit_guard_state_t *state_a = origin_circuit_get_guard_state(a);
circuit_guard_state_t *state_b = origin_circuit_get_guard_state(b);
tor_assert(state_a);
tor_assert(state_b);
entry_guard_t *guard_a = entry_guard_handle_get(state_a->guard);
entry_guard_t *guard_b = entry_guard_handle_get(state_b->guard);
if (! guard_a) {
/* Unknown guard -- never higher priority. */
return 0;
} else if (! guard_b) {
/* Known guard -- higher priority than any unknown guard. */
return 1;
} else {
/* Both known -- compare.*/
return entry_guard_has_higher_priority(guard_a, guard_b);
}
}
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
/**
* Look at all of the origin_circuit_t * objects in <b>all_circuits</b>,
* and see if any of them that were previously not ready to use for
* guard-related reasons are now ready to use. Place those circuits
* in <b>newly_complete_out</b>, and mark them COMPLETE.
*
* Return 1 if we upgraded any circuits, and 0 otherwise.
*/
int
entry_guards_upgrade_waiting_circuits(guard_selection_t *gs,
smartlist_t *all_circuits,
smartlist_t *newly_complete_out)
{
tor_assert(gs);
tor_assert(all_circuits);
tor_assert(newly_complete_out);
if (! entry_guards_all_primary_guards_are_down(gs)) {
/* We only upgrade a waiting circuit if the primary guards are all
* down. */
Backend for upgrading 'waiting' circuits to 'complete' When a nonprimary guard's circuit is complete, we don't call it actually usable until we are pretty sure that every better guard is indeed not going to give us a working circuit.
2016-11-21 15:40:45 +01:00
log_debug(LD_GUARD, "Considered upgrading guard-stalled circuits, "
"but not all primary guards were definitely down.");
return 0;
}
int n_waiting = 0;
int n_complete = 0;
origin_circuit_t *best_waiting_circuit = NULL;
origin_circuit_t *best_complete_circuit = NULL;
SMARTLIST_FOREACH_BEGIN(all_circuits, origin_circuit_t *, circ) {
circuit_guard_state_t *state = origin_circuit_get_guard_state(circ);
if (state == NULL)
continue;
if (state->state == GUARD_CIRC_STATE_WAITING_FOR_BETTER_GUARD) {
++n_waiting;
if (! best_waiting_circuit ||
circ_state_has_higher_priority(circ, best_waiting_circuit)) {
best_waiting_circuit = circ;
}
} else if (state->state == GUARD_CIRC_STATE_COMPLETE) {
++n_complete;
if (! best_complete_circuit ||
circ_state_has_higher_priority(circ, best_complete_circuit)) {
best_complete_circuit = circ;
}
}
} SMARTLIST_FOREACH_END(circ);
if (! best_waiting_circuit) {
log_debug(LD_GUARD, "Considered upgrading guard-stalled circuits, "
"but didn't find any.");
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
return 0;
}
Backend for upgrading 'waiting' circuits to 'complete' When a nonprimary guard's circuit is complete, we don't call it actually usable until we are pretty sure that every better guard is indeed not going to give us a working circuit.
2016-11-21 15:40:45 +01:00
if (best_complete_circuit) {
if (circ_state_has_higher_priority(best_complete_circuit,
best_waiting_circuit)) {
/* "If any circuit is <complete>, then do not use any
<waiting_for_better_guard> or <usable_if_no_better_guard> circuits
circuits whose guards have lower priority." */
log_debug(LD_GUARD, "Considered upgrading guard-stalled circuits: found "
"%d complete and %d guard-stalled. At least one complete "
"circuit had higher priority, so not upgrading.",
n_complete, n_waiting);
/* XXXX prop271 implement: "(Time them out after a
{NONPRIMARY_GUARD_IDLE_TIMEOUT} seconds.)"
*/
return 0;
}
}
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
/* "If any circuit is <waiting_for_better_guard>, and every currently
Backend for upgrading 'waiting' circuits to 'complete' When a nonprimary guard's circuit is complete, we don't call it actually usable until we are pretty sure that every better guard is indeed not going to give us a working circuit.
2016-11-21 15:40:45 +01:00
{is_pending} circuit whose guard has higher priority has been in
state <usable_if_no_better_guard> for at least
{NONPRIMARY_GUARD_CONNECT_TIMEOUT} seconds, and all primary guards
have reachable status of <no>, then call that circuit <complete>."
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
Backend for upgrading 'waiting' circuits to 'complete' When a nonprimary guard's circuit is complete, we don't call it actually usable until we are pretty sure that every better guard is indeed not going to give us a working circuit.
2016-11-21 15:40:45 +01:00
XXXX --- prop271 deviation. there's no such thing in the spec as
an {is_pending circuit}; fix the spec.
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
*/
Backend for upgrading 'waiting' circuits to 'complete' When a nonprimary guard's circuit is complete, we don't call it actually usable until we are pretty sure that every better guard is indeed not going to give us a working circuit.
2016-11-21 15:40:45 +01:00
int n_blockers_found = 0;
const time_t state_set_at_cutoff =
approx_time() - NONPRIMARY_GUARD_CONNECT_TIMEOUT;
SMARTLIST_FOREACH_BEGIN(all_circuits, origin_circuit_t *, circ) {
circuit_guard_state_t *state = origin_circuit_get_guard_state(circ);
if (state == NULL)
continue;
if (state->state != GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD)
continue;
if (state->state_set_at > state_set_at_cutoff &&
circ_state_has_higher_priority(circ, best_waiting_circuit))
++n_blockers_found;
} SMARTLIST_FOREACH_END(circ);
if (n_blockers_found) {
log_debug(LD_GUARD, "Considered upgrading guard-stalled circuits: found "
"%d guard-stalled, but %d pending circuit(s) had higher "
"guard priority, so not upgrading.",
n_waiting, n_blockers_found);
return 0;
}
/* Okay. We have a best waiting circuit, and we aren't waiting for
anything better. Add all circuits with that priority to the
list, and call them COMPLETE. */
int n_succeeded = 0;
SMARTLIST_FOREACH_BEGIN(all_circuits, origin_circuit_t *, circ) {
circuit_guard_state_t *state = origin_circuit_get_guard_state(circ);
if (state == NULL)
continue;
if (state->state != GUARD_CIRC_STATE_WAITING_FOR_BETTER_GUARD)
continue;
if (circ_state_has_higher_priority(best_waiting_circuit, circ))
continue;
state->state = GUARD_CIRC_STATE_COMPLETE;
state->state_set_at = approx_time();
smartlist_add(newly_complete_out, circ);
++n_succeeded;
} SMARTLIST_FOREACH_END(circ);
log_info(LD_GUARD, "Considered upgrading guard-stalled circuits: found "
"%d guard-stalled, %d complete. %d of the guard-stalled "
"circuit(s) had high enough priority to upgrade.",
n_waiting, n_complete, n_succeeded);
tor_assert_nonfatal(n_succeeded >= 1);
return 1;
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
}
/**
* Update all derived pieces of the guard selection state in <b>gs</b>.
*/
void
entry_guards_update_all(guard_selection_t *gs)
{
sampled_guards_update_from_consensus(gs);
entry_guards_update_filtered_sets(gs);
entry_guards_update_confirmed(gs);
entry_guards_update_primary(gs);
}
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
/**
* Return a newly allocated string for encoding the persistent parts of
* <b>guard</b> to the state file.
*/
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 char *
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
entry_guard_encode_for_state(entry_guard_t *guard)
{
/*
* The meta-format we use is K=V K=V K=V... where K can be any
* characters excepts space and =, and V can be any characters except
* space. The order of entries is not allowed to matter.
* Unrecognized K=V entries are persisted; recognized but erroneous
* entries are corrected.
*/
smartlist_t *result = smartlist_new();
char tbuf[ISO_TIME_LEN+1];
tor_assert(guard);
smartlist_add_asprintf(result, "rsa_id=%s",
hex_str(guard->identity, DIGEST_LEN));
if (strlen(guard->nickname)) {
smartlist_add_asprintf(result, "nickname=%s", guard->nickname);
}
format_iso_time_nospace(tbuf, guard->sampled_on_date);
smartlist_add_asprintf(result, "sampled_on=%s", tbuf);
if (guard->sampled_by_version) {
smartlist_add_asprintf(result, "sampled_by=%s",
guard->sampled_by_version);
}
if (guard->unlisted_since_date > 0) {
format_iso_time_nospace(tbuf, guard->unlisted_since_date);
smartlist_add_asprintf(result, "unlisted_since=%s", tbuf);
}
smartlist_add_asprintf(result, "listed=%d",
(int)guard->currently_listed);
if (guard->confirmed_idx >= 0) {
format_iso_time_nospace(tbuf, guard->confirmed_on_date);
smartlist_add_asprintf(result, "confirmed_on=%s", tbuf);
smartlist_add_asprintf(result, "confirmed_idx=%d", guard->confirmed_idx);
}
if (guard->extra_state_fields)
smartlist_add_strdup(result, guard->extra_state_fields);
char *joined = smartlist_join_strings(result, " ", 0, NULL);
SMARTLIST_FOREACH(result, char *, cp, tor_free(cp));
smartlist_free(result);
return joined;
}
/**
* Given a string generated by entry_guard_encode_for_state(), parse it
* (if possible) and return an entry_guard_t object for it. Return NULL
* on complete failure.
*/
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 entry_guard_t *
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
entry_guard_parse_from_state(const char *s)
{
/* Unrecognized entries get put in here. */
smartlist_t *extra = smartlist_new();
/* These fields get parsed from the string. */
char *rsa_id = NULL;
char *nickname = NULL;
char *sampled_on = NULL;
char *sampled_by = NULL;
char *unlisted_since = NULL;
char *listed = NULL;
char *confirmed_on = NULL;
char *confirmed_idx = NULL;
/* Split up the entries. Put the ones we know about in strings and the
* rest in "extra". */
{
smartlist_t *entries = smartlist_new();
strmap_t *vals = strmap_new(); // Maps keyword to location
strmap_set(vals, "rsa_id", &rsa_id);
strmap_set(vals, "nickname", &nickname);
strmap_set(vals, "sampled_on", &sampled_on);
strmap_set(vals, "sampled_by", &sampled_by);
strmap_set(vals, "unlisted_since", &unlisted_since);
strmap_set(vals, "listed", &listed);
strmap_set(vals, "confirmed_on", &confirmed_on);
strmap_set(vals, "confirmed_idx", &confirmed_idx);
smartlist_split_string(entries, s, " ",
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
SMARTLIST_FOREACH_BEGIN(entries, char *, entry) {
const char *eq = strchr(entry, '=');
if (!eq) {
smartlist_add(extra, entry);
continue;
}
char *key = tor_strndup(entry, eq-entry);
char **target = strmap_get(vals, key);
if (target == NULL || *target != NULL) {
/* unrecognized or already set */
smartlist_add(extra, entry);
tor_free(key);
continue;
}
*target = tor_strdup(eq+1);
tor_free(key);
tor_free(entry);
} SMARTLIST_FOREACH_END(entry);
smartlist_free(entries);
strmap_free(vals, NULL);
}
entry_guard_t *guard = tor_malloc_zero(sizeof(entry_guard_t));
if (rsa_id == NULL) {
log_warn(LD_CIRC, "Guard missing RSA ID field");
goto err;
}
/* Process the identity and nickname. */
if (base16_decode(guard->identity, sizeof(guard->identity),
rsa_id, strlen(rsa_id)) != DIGEST_LEN) {
log_warn(LD_CIRC, "Unable to decode guard identity %s", escaped(rsa_id));
goto err;
}
if (nickname) {
strlcpy(guard->nickname, nickname, sizeof(guard->nickname));
} else {
guard->nickname[0]='$';
base16_encode(guard->nickname+1, sizeof(guard->nickname)-1,
guard->identity, DIGEST_LEN);
}
/* Process the various time fields. */
#define HANDLE_TIME(field) do { \
if (field) { \
int r = parse_iso_time_nospace(field, &field ## _time); \
if (r < 0) { \
log_warn(LD_CIRC, "Unable to parse %s %s from guard", \
#field, escaped(field)); \
field##_time = -1; \
} \
} \
} while (0)
time_t sampled_on_time = 0;
time_t unlisted_since_time = 0;
time_t confirmed_on_time = 0;
HANDLE_TIME(sampled_on);
HANDLE_TIME(unlisted_since);
HANDLE_TIME(confirmed_on);
if (sampled_on_time <= 0)
sampled_on_time = approx_time();
if (unlisted_since_time < 0)
unlisted_since_time = 0;
if (confirmed_on_time < 0)
confirmed_on_time = 0;
#undef HANDLE_TIME
guard->sampled_on_date = sampled_on_time;
guard->unlisted_since_date = unlisted_since_time;
guard->confirmed_on_date = confirmed_on_time;
/* Take sampled_by_version verbatim. */
guard->sampled_by_version = sampled_by;
sampled_by = NULL; /* prevent free */
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
// XXXX -- prop271 spec deviation -- we do not require sampled_by_version
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
/* Listed is a boolean */
if (listed && strcmp(listed, "0"))
guard->currently_listed = 1;
/* The index is a nonnegative integer. */
guard->confirmed_idx = -1;
if (confirmed_idx) {
int ok=1;
long idx = tor_parse_long(confirmed_idx, 10, 0, INT_MAX, &ok, NULL);
if (! ok) {
log_warn(LD_CIRC, "Guard has invalid confirmed_idx %s",
escaped(confirmed_idx));
} else {
guard->confirmed_idx = (int)idx;
}
}
/* Anything we didn't recognize gets crammed together */
if (smartlist_len(extra) > 0) {
guard->extra_state_fields = smartlist_join_strings(extra, " ", 0, NULL);
}
/* initialize non-persistent fields */
guard->is_reachable = GUARD_REACHABLE_MAYBE;
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
/* XXXX prop271 Update everything on this guard. */
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
goto done;
err:
// only consider it an error if the guard state was totally unparseable.
entry_guard_free(guard);
guard = NULL;
done:
tor_free(rsa_id);
tor_free(nickname);
tor_free(sampled_on);
tor_free(sampled_by);
tor_free(unlisted_since);
tor_free(listed);
tor_free(confirmed_on);
tor_free(confirmed_idx);
SMARTLIST_FOREACH(extra, char *, cp, tor_free(cp));
smartlist_free(extra);
return guard;
}
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
/* XXXXprop271 This is a dummy function added for now so that all of the
* new guard code will be counted as reachable. It should get removed.
*/
__attribute__((noreturn)) void
entry_guards_DUMMY_ENTRY_POINT(void)
{
// prop271 XXXXX kludge; remove this
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
entry_guard_encode_for_state(NULL);
entry_guard_parse_from_state(NULL);
tor_assert(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
}
/* XXXXX ----------------------------------------------- */
/* XXXXX prop271 ----- end of new-for-prop271 code ----- */
/* XXXXX ----------------------------------------------- */
/**
* @name Constants for old (pre-prop271) guard selection algorithm.
*/
/**@{*/
/* Default number of entry guards in the case where the NumEntryGuards
* consensus parameter is not set */
#define DEFAULT_N_GUARDS 1
/* Minimum and maximum number of entry guards (in case the NumEntryGuards
* consensus parameter is set). */
#define MIN_N_GUARDS 1
#define MAX_N_GUARDS 10
/** Largest amount that we'll backdate chosen_on_date */
#define CHOSEN_ON_DATE_SLOP (30*86400)
/** How long (in seconds) do we allow an entry guard to be nonfunctional,
* unlisted, excluded, or otherwise nonusable before we give up on it? */
#define ENTRY_GUARD_REMOVE_AFTER (30*24*60*60)
/**}@*/
/**
* @name Networkstatus parameters for old (pre-prop271) guard selection
*/
/**@}*/
/** Choose how many entry guards or directory guards we'll use. If
* <b>for_directory</b> is true, we return how many directory guards to
* use; else we return how many entry guards to use. */
STATIC int
decide_num_guards(const or_options_t *options, int for_directory)
{
if (for_directory) {
int answer;
if (options->NumDirectoryGuards != 0)
return options->NumDirectoryGuards;
answer = networkstatus_get_param(NULL, "NumDirectoryGuards", 0, 0, 10);
if (answer) /* non-zero means use the consensus value */
return answer;
}
if (options->NumEntryGuards)
return options->NumEntryGuards;
/* Use the value from the consensus, or 3 if no guidance. */
return networkstatus_get_param(NULL, "NumEntryGuards", DEFAULT_N_GUARDS,
MIN_N_GUARDS, MAX_N_GUARDS);
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/** Check whether the entry guard <b>e</b> is usable, given the directory
* authorities' opinion about the router (stored in <b>ri</b>) and the user's
Make entry_guard_set_status consistent with entry_is_live Check fascist_firewall_allows_node in entry_guard_set_status and return the same message as entry_is_live.
2016-01-03 13:16:06 +01:00
* configuration (in <b>options</b>). Set <b>e</b>->bad_since
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
* accordingly. Return true iff the entry guard's status changes.
*
* If it's not usable, set *<b>reason</b> to a static string explaining why.
*/
static int
entry_guard_set_status(entry_guard_t *e, const node_t *node,
time_t now, const or_options_t *options,
const char **reason)
{
char buf[HEX_DIGEST_LEN+1];
int changed = 0;
*reason = NULL;
/* Do we want to mark this guard as bad? */
if (!node)
*reason = "unlisted";
else if (!node->is_running)
*reason = "down";
else if (options->UseBridges && (!node->ri ||
node->ri->purpose != ROUTER_PURPOSE_BRIDGE))
*reason = "not a bridge";
else if (options->UseBridges && !node_is_a_configured_bridge(node))
*reason = "not a configured bridge";
else if (!options->UseBridges && !node->is_possible_guard &&
!routerset_contains_node(options->EntryNodes,node))
*reason = "not recommended as a guard";
else if (routerset_contains_node(options->ExcludeNodes, node))
*reason = "excluded";
Make entry_guard_set_status consistent with entry_is_live Check fascist_firewall_allows_node in entry_guard_set_status and return the same message as entry_is_live.
2016-01-03 13:16:06 +01:00
/* We only care about OR connection connectivity for entry guards. */
else if (!fascist_firewall_allows_node(node, FIREWALL_OR_CONNECTION, 0))
*reason = "unreachable by config";
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
else if (e->pb.path_bias_disabled)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*reason = "path-biased";
if (*reason && ! e->bad_since) {
/* Router is newly bad. */
base16_encode(buf, sizeof(buf), e->identity, DIGEST_LEN);
log_info(LD_CIRC, "Entry guard %s (%s) is %s: marking as unusable.",
e->nickname, buf, *reason);
e->bad_since = now;
control_event_guard(e->nickname, e->identity, "BAD");
changed = 1;
} else if (!*reason && e->bad_since) {
/* There's nothing wrong with the router any more. */
base16_encode(buf, sizeof(buf), e->identity, DIGEST_LEN);
log_info(LD_CIRC, "Entry guard %s (%s) is no longer unusable: "
"marking as ok.", e->nickname, buf);
e->bad_since = 0;
control_event_guard(e->nickname, e->identity, "GOOD");
changed = 1;
}
Remember which of our guards are directory caches
2012-12-11 17:43:27 +01:00
if (node) {
Remove version checks for microdescriptor support At this point, relays without microdescriptor support are no longer allowed on the Tor network.
2015-03-24 14:18:03 +01:00
int is_dir = node_is_dir(node);
Fix bootstrapping with bridges by making is_dir_cache is set on them. This fixes bug 8367, introduced in d7089ff228227259137b5a8b. Not in any released Tor.
2013-02-28 23:20:46 +01:00
if (options->UseBridges && node_is_a_configured_bridge(node))
is_dir = 1;
Remember which of our guards are directory caches
2012-12-11 17:43:27 +01:00
if (e->is_dir_cache != is_dir) {
e->is_dir_cache = is_dir;
changed = 1;
}
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
return changed;
}
/** Return true iff enough time has passed since we last tried to connect
* to the unreachable guard <b>e</b> that we're willing to try again. */
Unit testing entry_is_time_to_retry().
2014-08-20 21:07:08 +02:00
STATIC int
Constify aggressively in populate_live_entry_guards().
2014-06-09 19:23:41 +02:00
entry_is_time_to_retry(const entry_guard_t *e, time_t now)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
Rewriting entry_is_time_to_retry() using table approach.
2014-08-19 21:12:19 +02:00
struct guard_retry_period_s {
time_t period_duration;
time_t interval_during_period;
};
struct guard_retry_period_s periods[] = {
Write comments for members of periods array.
2014-08-19 21:23:11 +02:00
{ 6*60*60, 60*60 }, /* For first 6 hrs., retry hourly; */
{ 3*24*60*60, 4*60*60 }, /* Then retry every 4 hrs. until the
3-day mark; */
{ 7*24*60*60, 18*60*60 }, /* After 3 days, retry every 18 hours until
1 week mark. */
{ TIME_MAX, 36*60*60 } /* After 1 week, retry every 36 hours. */
Rewriting entry_is_time_to_retry() using table approach.
2014-08-19 21:12:19 +02:00
};
time_t ith_deadline_for_retry;
time_t unreachable_for;
Avoid unsigned/sign compare warning from last patch.
2014-09-01 21:42:17 +02:00
unsigned i;
Rewriting entry_is_time_to_retry() using table approach.
2014-08-19 21:12:19 +02:00
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (e->last_attempted < e->unreachable_since)
return 1;
Rewriting entry_is_time_to_retry() using table approach.
2014-08-19 21:12:19 +02:00
unreachable_for = now - e->unreachable_since;
Bounds check while looping over a fixed size table or array (Edited to use existing ARRAY_LENGTH macro --nickm)
2014-08-23 00:35:26 +02:00
for (i = 0; i < ARRAY_LENGTH(periods); i++) {
Rewriting entry_is_time_to_retry() using table approach.
2014-08-19 21:12:19 +02:00
if (unreachable_for <= periods[i].period_duration) {
ith_deadline_for_retry = e->last_attempted +
periods[i].interval_during_period;
return (now > ith_deadline_for_retry);
}
}
Bounds check while looping over a fixed size table or array (Edited to use existing ARRAY_LENGTH macro --nickm)
2014-08-23 00:35:26 +02:00
return 0;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
/** Return the node corresponding to <b>e</b>, if <b>e</b> is
* working well enough that we are willing to use it as an entry
* right now. (Else return NULL.) In particular, it must be
* - Listed as either up or never yet contacted;
* - Present in the routerlist;
* - Listed as 'stable' or 'fast' by the current dirserver consensus,
* if demanded by <b>need_uptime</b> or <b>need_capacity</b>
* (unless it's a configured EntryNode);
* - Allowed by our current ReachableORAddresses config option; and
* - Currently thought to be reachable by us (unless <b>assume_reachable</b>
* is true).
*
* If the answer is no, set *<b>msg</b> to an explanation of why.
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
*
* If need_descriptor is true, only return the node if we currently have
* a descriptor (routerinfo or microdesc) for it.
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*/
Fix wide lines, make entry_is_live() non-inline
2014-07-16 16:52:16 +02:00
STATIC const node_t *
entry_is_live(const entry_guard_t *e, entry_is_live_flags_t flags,
const char **msg)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
const node_t *node;
const or_options_t *options = get_options();
Change the interface of entry_is_live() to take a bitmap.
2014-06-25 21:44:36 +02:00
int need_uptime = (flags & ENTRY_NEED_UPTIME) != 0;
int need_capacity = (flags & ENTRY_NEED_CAPACITY) != 0;
const int assume_reachable = (flags & ENTRY_ASSUME_REACHABLE) != 0;
const int need_descriptor = (flags & ENTRY_NEED_DESCRIPTOR) != 0;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
tor_assert(msg);
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
if (e->pb.path_bias_disabled) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*msg = "path-biased";
return NULL;
}
if (e->bad_since) {
*msg = "bad";
return NULL;
}
/* no good if it's unreachable, unless assume_unreachable or can_retry. */
if (!assume_reachable && !e->can_retry &&
e->unreachable_since && !entry_is_time_to_retry(e, time(NULL))) {
*msg = "unreachable";
return NULL;
}
node = node_get_by_id(e->identity);
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
if (!node) {
*msg = "no node info";
return NULL;
}
if (need_descriptor && !node_has_descriptor(node)) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*msg = "no descriptor";
return NULL;
}
if (get_options()->UseBridges) {
if (node_get_purpose(node) != ROUTER_PURPOSE_BRIDGE) {
*msg = "not a bridge";
return NULL;
}
if (!node_is_a_configured_bridge(node)) {
*msg = "not a configured bridge";
return NULL;
}
} else { /* !get_options()->UseBridges */
if (node_get_purpose(node) != ROUTER_PURPOSE_GENERAL) {
*msg = "not general-purpose";
return NULL;
}
}
if (routerset_contains_node(options->EntryNodes, node)) {
/* they asked for it, they get it */
need_uptime = need_capacity = 0;
}
if (node_is_unreliable(node, need_uptime, need_capacity, 0)) {
*msg = "not fast/stable";
return NULL;
}
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
if (!fascist_firewall_allows_node(node, FIREWALL_OR_CONNECTION, 0)) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*msg = "unreachable by config";
return NULL;
}
return node;
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Return the number of entry guards that we think are usable, in the
* context of the given guard_selection_t */
Bug 3443: Don't count ORconn setup in circuit build time. Also, add a hack Roger suggested where we're more patient if no circuits are opened yet.
2012-10-26 02:43:10 +02:00
int
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
num_live_entry_guards_for_guard_selection(guard_selection_t *gs,
int for_directory)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
int n = 0;
const char *msg;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_assert(gs != NULL);
Change the interface of entry_is_live() to take a bitmap.
2014-06-25 21:44:36 +02:00
/* Set the entry node attributes we are interested in. */
entry_is_live_flags_t entry_flags = ENTRY_NEED_CAPACITY;
if (!for_directory) {
entry_flags |= ENTRY_NEED_DESCRIPTOR;
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
if (!(gs->chosen_entry_guards)) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
return 0;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
}
SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, entry) {
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
if (for_directory && !entry->is_dir_cache)
continue;
Change the interface of entry_is_live() to take a bitmap.
2014-06-25 21:44:36 +02:00
if (entry_is_live(entry, entry_flags, &msg))
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
++n;
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
} SMARTLIST_FOREACH_END(entry);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
return n;
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Return the number of entry guards that we think are usable, for the
* default guard selection */
int
num_live_entry_guards(int for_directory)
{
return num_live_entry_guards_for_guard_selection(
get_guard_selection_info(), for_directory);
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/** If <b>digest</b> matches the identity of any node in the
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
* entry_guards list for the provided guard selection state,
return that node. Else return NULL. */
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
entry_guard_t *
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
entry_guard_get_by_id_digest_for_guard_selection(guard_selection_t *gs,
const char *digest)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_assert(gs != NULL);
SMARTLIST_FOREACH(gs->chosen_entry_guards, entry_guard_t *, entry,
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (tor_memeq(digest, entry->identity, DIGEST_LEN))
return entry;
);
return NULL;
}
prop271: make entry_guard_t mostly-private The entry_guard_t structure should really be opaque, so that we can change its contents and have the rest of Tor not care. This commit makes it "mostly opaque" -- circpathbias.c can still see inside it. (I'm making circpathbias.c exempt since it's the only part of Tor outside of entrynodes.c that made serious use of entry_guard_t internals.)
2016-11-14 17:41:37 +01:00
/** Return the node_t associated with a single entry_guard_t. May
* return NULL if the guard is not currently in the consensus. */
const node_t *
entry_guard_find_node(const entry_guard_t *guard)
{
tor_assert(guard);
return node_get_by_id(guard->identity);
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** If <b>digest</b> matches the identity of any node in the
* entry_guards list for the default guard selection state,
return that node. Else return NULL. */
entry_guard_t *
entry_guard_get_by_id_digest(const char *digest)
{
return entry_guard_get_by_id_digest_for_guard_selection(
get_guard_selection_info(), digest);
}
/** Dump a description of our list of entry guards in the given guard
* selection context to the log at level <b>severity</b>. */
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
static void
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
log_entry_guards_for_guard_selection(guard_selection_t *gs, int severity)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
smartlist_t *elements = smartlist_new();
char *s;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/*
* TODO this should probably log more info about prop-271 state too
* when it's implemented.
*/
tor_assert(gs != NULL);
SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
const char *msg = NULL;
Change the interface of entry_is_live() to take a bitmap.
2014-06-25 21:44:36 +02:00
if (entry_is_live(e, ENTRY_NEED_CAPACITY, &msg))
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
smartlist_add_asprintf(elements, "%s [%s] (up %s)",
e->nickname,
hex_str(e->identity, DIGEST_LEN),
e->made_contact ? "made-contact" : "never-contacted");
else
smartlist_add_asprintf(elements, "%s [%s] (%s, %s)",
e->nickname,
hex_str(e->identity, DIGEST_LEN),
msg,
e->made_contact ? "made-contact" : "never-contacted");
}
SMARTLIST_FOREACH_END(e);
s = smartlist_join_strings(elements, ",", 0, NULL);
SMARTLIST_FOREACH(elements, char*, cp, tor_free(cp));
smartlist_free(elements);
log_fn(severity,LD_CIRC,"%s",s);
tor_free(s);
}
/** Called when one or more guards that we would previously have used for some
* purpose are no longer in use because a higher-priority guard has become
* usable again. */
static void
control_event_guard_deferred(void)
{
/* XXXX We don't actually have a good way to figure out _how many_ entries
* are live for some purpose. We need an entry_is_even_slightly_live()
* function for this to work right. NumEntryGuards isn't reliable: if we
* need guards with weird properties, we can have more than that number
* live.
**/
#if 0
int n = 0;
const char *msg;
const or_options_t *options = get_options();
if (!entry_guards)
return;
SMARTLIST_FOREACH(entry_guards, entry_guard_t *, entry,
{
if (entry_is_live(entry, 0, 1, 0, &msg)) {
if (n++ == options->NumEntryGuards) {
control_event_guard(entry->nickname, entry->identity, "DEFERRED");
return;
}
}
});
#endif
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Add a new (preferably stable and fast) router to our chosen_entry_guards
* list for the supplied guard selection. Return a pointer to the router if
* we succeed, or NULL if we can't find any more suitable entries.
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*
* If <b>chosen</b> is defined, use that one, and if it's not
* already in our entry_guards list, put it at the *beginning*.
* Else, put the one we pick at the end of the list. */
Make a few entrynodes.c functions testable.
2014-06-16 03:38:52 +02:00
STATIC const node_t *
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
add_an_entry_guard(guard_selection_t *gs,
const node_t *chosen, int reset_status, int prepend,
be willing to bootstrap from all three of our directory guards Also fix a bug where if the guard we choose first doesn't answer, we would try the second guard, but once we connected to the second guard we would abandon it and retry the first one, slowing down bootstrapping. The fix in both cases is to treat all our initially chosen guards as acceptable to use. Fixes bug 9946.
2013-10-11 02:09:16 +02:00
int for_discovery, int for_directory)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
const node_t *node;
entry_guard_t *entry;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_assert(gs != NULL);
Refactor to always allocate chosen_entry_guards in new guard_selection_new() function
2016-10-14 02:15:30 +02:00
tor_assert(gs->chosen_entry_guards != NULL);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (chosen) {
node = chosen;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
entry = entry_guard_get_by_id_digest_for_guard_selection(gs,
node->identity);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (entry) {
if (reset_status) {
entry->bad_since = 0;
entry->can_retry = 1;
}
Remove version checks for microdescriptor support At this point, relays without microdescriptor support are no longer allowed on the Tor network.
2015-03-24 14:18:03 +01:00
entry->is_dir_cache = node_is_dir(node);
Bridges are always dirs This check was accidentally deleted in 05f7336624d6a47b3cf0fe82.
2015-04-01 21:07:46 +02:00
if (get_options()->UseBridges && node_is_a_configured_bridge(node))
entry->is_dir_cache = 1;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
return NULL;
}
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
} else if (!for_directory) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
node = choose_good_entry_server(CIRCUIT_PURPOSE_C_GENERAL, NULL);
if (!node)
return NULL;
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
} else {
const routerstatus_t *rs;
rs = router_pick_directory_server(MICRODESC_DIRINFO|V3_DIRINFO,
Remove TunnelDirConns and PreferTunnelledDirConns These options were added back in 0.1.2.5-alpha, but no longer make any sense now that all directories support tunneled connections and BEGIN_DIR cells. These options were on by default; now they are always-on. This is a fix for 10849, where TunnelDirConns 0 would break hidden services -- and that bug arrived, I think, in 0.2.0.10-alpha.
2014-02-11 17:10:55 +01:00
PDS_FOR_GUARD);
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
if (!rs)
return NULL;
node = node_get_by_id(rs->identity_digest);
if (!node)
return NULL;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
if (entry_guard_get_by_id_digest_for_guard_selection(gs, node->identity)
!= NULL) {
Add some code to bluntly prevent duplicate guards from getting added Apparently something in the directory guard code made it possible for the same node to get added as a guard over and over when there were no actual running guard nodes.
2013-02-14 17:48:47 +01:00
log_info(LD_CIRC, "I was about to add a duplicate entry guard.");
/* This can happen if we choose a guard, then the node goes away, then
* comes back. */
return NULL;
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
entry = tor_malloc_zero(sizeof(entry_guard_t));
log_info(LD_CIRC, "Chose %s as new entry guard.",
node_describe(node));
strlcpy(entry->nickname, node_get_nickname(node), sizeof(entry->nickname));
memcpy(entry->identity, node->identity, DIGEST_LEN);
Remove version checks for microdescriptor support At this point, relays without microdescriptor support are no longer allowed on the Tor network.
2015-03-24 14:18:03 +01:00
entry->is_dir_cache = node_is_dir(node);
Correctly set entry->is_dir_cache when adding an entry guard for the first time (Second part of a bug8367 fix. -NM)
2013-03-01 10:59:25 +01:00
if (get_options()->UseBridges && node_is_a_configured_bridge(node))
entry->is_dir_cache = 1;
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/* Choose expiry time smudged over the past month. The goal here
* is to a) spread out when Tor clients rotate their guards, so they
* don't all select them on the same day, and b) avoid leaving a
* precise timestamp in the state file about when we first picked
* this guard. For details, see the Jan 2010 or-dev thread. */
Add crypto_rand_int_range() and use it Incidently, this fixes a bug where the maximum value was never used when only using crypto_rand_int(). For instance this example below in rendservice.c never gets to INTRO_POINT_LIFETIME_MAX_SECONDS. int intro_point_lifetime_seconds = INTRO_POINT_LIFETIME_MIN_SECONDS + crypto_rand_int(INTRO_POINT_LIFETIME_MAX_SECONDS - INTRO_POINT_LIFETIME_MIN_SECONDS); Signed-off-by: David Goulet <dgoulet@ev0ke.net>
2015-04-21 16:17:12 +02:00
time_t now = time(NULL);
Fix some conversion problems
2015-04-23 15:16:42 +02:00
entry->chosen_on_date = crypto_rand_time_range(now - 3600*24*30, now);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
entry->chosen_by_version = tor_strdup(VERSION);
be willing to bootstrap from all three of our directory guards Also fix a bug where if the guard we choose first doesn't answer, we would try the second guard, but once we connected to the second guard we would abandon it and retry the first one, slowing down bootstrapping. The fix in both cases is to treat all our initially chosen guards as acceptable to use. Fixes bug 9946.
2013-10-11 02:09:16 +02:00
/* Are we picking this guard because all of our current guards are
* down so we need another one (for_discovery is 1), or because we
* decided we need more variety in our guard list (for_discovery is 0)?
*
* Currently we hack this behavior into place by setting "made_contact"
* for guards of the latter variety, so we'll be willing to use any of
* them right off the bat.
*/
if (!for_discovery)
entry->made_contact = 1;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (prepend)
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
smartlist_insert(gs->chosen_entry_guards, 0, entry);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
else
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
smartlist_add(gs->chosen_entry_guards, entry);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
control_event_guard(entry->nickname, entry->identity, "NEW");
control_event_guard_deferred();
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
log_entry_guards_for_guard_selection(gs, LOG_INFO);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
return node;
}
Add accessors as needed to repair compilation The previous commit, in moving a bunch of functions to bridges.c, broke compilation because bridges.c required two entry points to entrynodes.c it didn't have.
2016-11-15 14:15:29 +01:00
/** Entry point for bridges.c to add a bridge as guard.
*
* XXXX prop271 refactor.*/
void
add_bridge_as_entry_guard(guard_selection_t *gs,
const node_t *chosen)
{
add_an_entry_guard(gs, chosen, 1, 1, 0, 0);
}
Collect old guard algorithm parameters into one place
2016-11-15 14:28:41 +01:00
/**
* Return the minimum lifetime of working entry guard, in seconds,
* as given in the consensus networkstatus. (Plus CHOSEN_ON_DATE_SLOP,
* so that we can do the chosen_on_date randomization while achieving the
* desired minimum lifetime.)
*/
static int32_t
guards_get_lifetime(void)
NumDirectoryGuards now tracks NumEntryGuards by default Now a user who changes only NumEntryGuards will get the behavior she expects. Fixes bug 9354; bugfix on 0.2.4.8-alpha.
2013-07-30 18:05:39 +02:00
{
Collect old guard algorithm parameters into one place
2016-11-15 14:28:41 +01:00
const or_options_t *options = get_options();
#define DFLT_GUARD_LIFETIME (86400 * 60) /* Two months. */
#define MIN_GUARD_LIFETIME (86400 * 30) /* One months. */
#define MAX_GUARD_LIFETIME (86400 * 1826) /* Five years. */
add a NumDirectoryGuards consensus param too
2014-07-23 21:28:40 +02:00
Collect old guard algorithm parameters into one place
2016-11-15 14:28:41 +01:00
if (options->GuardLifetime >= 1) {
return CLAMP(MIN_GUARD_LIFETIME,
options->GuardLifetime,
MAX_GUARD_LIFETIME) + CHOSEN_ON_DATE_SLOP;
}
add a NumDirectoryGuards consensus param too
2014-07-23 21:28:40 +02:00
Collect old guard algorithm parameters into one place
2016-11-15 14:28:41 +01:00
return networkstatus_get_param(NULL, "GuardLifetime",
DFLT_GUARD_LIFETIME,
MIN_GUARD_LIFETIME,
MAX_GUARD_LIFETIME) + CHOSEN_ON_DATE_SLOP;
NumDirectoryGuards now tracks NumEntryGuards by default Now a user who changes only NumEntryGuards will get the behavior she expects. Fixes bug 9354; bugfix on 0.2.4.8-alpha.
2013-07-30 18:05:39 +02:00
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/** If the use of entry guards is configured, choose more entry guards
* until we have enough in the list. */
static void
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
pick_entry_guards(guard_selection_t *gs,
const or_options_t *options,
int for_directory)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
int changed = 0;
NumDirectoryGuards now tracks NumEntryGuards by default Now a user who changes only NumEntryGuards will get the behavior she expects. Fixes bug 9354; bugfix on 0.2.4.8-alpha.
2013-07-30 18:05:39 +02:00
const int num_needed = decide_num_guards(options, for_directory);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_assert(gs != NULL);
Refactor to always allocate chosen_entry_guards in new guard_selection_new() function
2016-10-14 02:15:30 +02:00
tor_assert(gs->chosen_entry_guards != NULL);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
while (num_live_entry_guards_for_guard_selection(gs, for_directory)
< num_needed) {
if (!add_an_entry_guard(gs, NULL, 0, 0, 0, for_directory))
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
break;
changed = 1;
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (changed)
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
entry_guards_changed_for_guard_selection(gs);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
/** Release all storage held by <b>e</b>. */
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
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
entry_guard_free(entry_guard_t *e)
{
if (!e)
return;
Write the easy parts of the public entryguard interface. Here we add a little bit of state to origin circuits, and set up the necessary functions for the circuit code to call in order to find guards, use guards, and decide when circuits can be used. There's also an incomplete function for the hard part of the circuit-maintenance code, where we figure out whether any waiting guards are ready to become usable. (This patch finally uses the handle.c code to make safe handles to entry_guard_t objects, so that we are allowed to free an entry_guard_t without checking whether any origin_circuit_t is holding a reference to it.)
2016-11-18 22:05:09 +01:00
entry_guard_handles_clear(e);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
tor_free(e->chosen_by_version);
Add the prop271 fields to entry_guard_t. Not used yet.
2016-11-14 19:27:35 +01:00
tor_free(e->sampled_by_version);
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
tor_free(e->extra_state_fields);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
tor_free(e);
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Remove from a guard selection context any entry guard which was selected
* by an unknown version of Tor, or which was selected by a version of Tor
* that's known to select entry guards badly, or which was selected more 2
* months ago. */
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/* XXXX The "obsolete guards" and "chosen long ago guards" things should
* probably be different functions. */
static int
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
remove_obsolete_entry_guards(guard_selection_t *gs, time_t now)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
int changed = 0, i;
Merge branch 'bug8240_v2_squashed' into maint-0.2.4 Conflicts: doc/tor.1.txt src/or/circuitbuild.c src/or/config.c src/or/or.h
2013-03-19 21:15:27 +01:00
int32_t guard_lifetime = guards_get_lifetime();
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_assert(gs != NULL);
if (!(gs->chosen_entry_guards)) goto done;
for (i = 0; i < smartlist_len(gs->chosen_entry_guards); ++i) {
entry_guard_t *entry = smartlist_get(gs->chosen_entry_guards, i);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
const char *ver = entry->chosen_by_version;
const char *msg = NULL;
tor_version_t v;
int version_is_bad = 0, date_is_bad = 0;
if (!ver) {
msg = "does not say what version of Tor it was selected by";
version_is_bad = 1;
} else if (tor_version_parse(ver, &v)) {
msg = "does not seem to be from any recognized version of Tor";
version_is_bad = 1;
}
Merge branch 'bug8240_v2_squashed' into maint-0.2.4 Conflicts: doc/tor.1.txt src/or/circuitbuild.c src/or/config.c src/or/or.h
2013-03-19 21:15:27 +01:00
if (!version_is_bad && entry->chosen_on_date + guard_lifetime < now) {
/* It's been too long since the date listed in our state file. */
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
msg = "was selected several months ago";
date_is_bad = 1;
}
if (version_is_bad || date_is_bad) { /* we need to drop it */
char dbuf[HEX_DIGEST_LEN+1];
tor_assert(msg);
base16_encode(dbuf, sizeof(dbuf), entry->identity, DIGEST_LEN);
log_fn(version_is_bad ? LOG_NOTICE : LOG_INFO, LD_CIRC,
"Entry guard '%s' (%s) %s. (Version=%s.) Replacing it.",
entry->nickname, dbuf, msg, ver?escaped(ver):"none");
control_event_guard(entry->nickname, entry->identity, "DROPPED");
entry_guard_free(entry);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
smartlist_del_keeporder(gs->chosen_entry_guards, i--);
log_entry_guards_for_guard_selection(gs, LOG_INFO);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
changed = 1;
}
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
done:
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
return changed ? 1 : 0;
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Remove all entry guards from this guard selection context that have
* been down or unlisted for so long that we don't think they'll come up
* again. Return 1 if we removed any, or 0 if we did nothing. */
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
static int
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
remove_dead_entry_guards(guard_selection_t *gs, time_t now)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
char dbuf[HEX_DIGEST_LEN+1];
char tbuf[ISO_TIME_LEN+1];
int i;
int changed = 0;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_assert(gs != NULL);
if (!(gs->chosen_entry_guards)) goto done;
for (i = 0; i < smartlist_len(gs->chosen_entry_guards); ) {
entry_guard_t *entry = smartlist_get(gs->chosen_entry_guards, i);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (entry->bad_since &&
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
! entry->pb.path_bias_disabled &&
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
entry->bad_since + ENTRY_GUARD_REMOVE_AFTER < now) {
base16_encode(dbuf, sizeof(dbuf), entry->identity, DIGEST_LEN);
format_local_iso_time(tbuf, entry->bad_since);
log_info(LD_CIRC, "Entry guard '%s' (%s) has been down or unlisted "
"since %s local time; removing.",
entry->nickname, dbuf, tbuf);
control_event_guard(entry->nickname, entry->identity, "DROPPED");
entry_guard_free(entry);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
smartlist_del_keeporder(gs->chosen_entry_guards, i);
log_entry_guards_for_guard_selection(gs, LOG_INFO);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
changed = 1;
} else
++i;
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
done:
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
return changed ? 1 : 0;
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Remove all currently listed entry guards for a given guard selection
* context */
DROPGUARDS controller command Implements ticket 9934; patch from "ra"
2013-10-21 19:02:25 +02:00
void
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
remove_all_entry_guards_for_guard_selection(guard_selection_t *gs)
DROPGUARDS controller command Implements ticket 9934; patch from "ra"
2013-10-21 19:02:25 +02:00
{
char dbuf[HEX_DIGEST_LEN+1];
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_assert(gs != NULL);
if (gs->chosen_entry_guards) {
while (smartlist_len(gs->chosen_entry_guards)) {
entry_guard_t *entry = smartlist_get(gs->chosen_entry_guards, 0);
base16_encode(dbuf, sizeof(dbuf), entry->identity, DIGEST_LEN);
log_info(LD_CIRC, "Entry guard '%s' (%s) has been dropped.",
entry->nickname, dbuf);
control_event_guard(entry->nickname, entry->identity, "DROPPED");
entry_guard_free(entry);
smartlist_del(gs->chosen_entry_guards, 0);
}
DROPGUARDS controller command Implements ticket 9934; patch from "ra"
2013-10-21 19:02:25 +02:00
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
log_entry_guards_for_guard_selection(gs, LOG_INFO);
entry_guards_changed_for_guard_selection(gs);
}
/** Remove all currently listed entry guards. So new ones will be chosen. */
void
remove_all_entry_guards(void)
{
remove_all_entry_guards_for_guard_selection(get_guard_selection_info());
DROPGUARDS controller command Implements ticket 9934; patch from "ra"
2013-10-21 19:02:25 +02:00
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/** A new directory or router-status has arrived; update the down/listed
* status of the entry guards.
*
* An entry is 'down' if the directory lists it as nonrunning.
* An entry is 'unlisted' if the directory doesn't include it.
*
* Don't call this on startup; only on a fresh download. Otherwise we'll
* think that things are unlisted.
*/
void
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
entry_guards_compute_status_for_guard_selection(guard_selection_t *gs,
const or_options_t *options,
time_t now)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
int changed = 0;
digestmap_t *reasons;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
if ((!gs) || !(gs->chosen_entry_guards))
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
return;
Add an (as yet) unused UseDeprecatedGuardAlgorithm_ option. I expect we'll be ripping this out somewhere in 0.3.0, but let's keep it around for a little while in case it turns out to be the only way to avert disaster?
2016-11-21 23:02:51 +01:00
if (!get_options()->UseDeprecatedGuardAlgorithm)
return;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (options->EntryNodes) /* reshuffle the entry guard list if needed */
entry_nodes_should_be_added();
reasons = digestmap_new();
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, entry)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
const node_t *r = node_get_by_id(entry->identity);
const char *reason = NULL;
if (entry_guard_set_status(entry, r, now, options, &reason))
changed = 1;
if (entry->bad_since)
tor_assert(reason);
if (reason)
digestmap_set(reasons, entry->identity, (char*)reason);
}
SMARTLIST_FOREACH_END(entry);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
if (remove_dead_entry_guards(gs, now))
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
changed = 1;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
if (remove_obsolete_entry_guards(gs, now))
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
changed = 1;
if (changed) {
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *,
entry) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
const char *reason = digestmap_get(reasons, entry->identity);
const char *live_msg = "";
Change the interface of entry_is_live() to take a bitmap.
2014-06-25 21:44:36 +02:00
const node_t *r = entry_is_live(entry, ENTRY_NEED_CAPACITY, &live_msg);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
log_info(LD_CIRC, "Summary: Entry %s [%s] is %s, %s%s%s, and %s%s.",
entry->nickname,
hex_str(entry->identity, DIGEST_LEN),
entry->unreachable_since ? "unreachable" : "reachable",
entry->bad_since ? "unusable" : "usable",
reason ? ", ": "",
reason ? reason : "",
r ? "live" : "not live / ",
r ? "" : live_msg);
} SMARTLIST_FOREACH_END(entry);
log_info(LD_CIRC, " (%d/%d entry guards are usable/new)",
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
num_live_entry_guards_for_guard_selection(gs, 0),
smartlist_len(gs->chosen_entry_guards));
log_entry_guards_for_guard_selection(gs, LOG_INFO);
entry_guards_changed_for_guard_selection(gs);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
digestmap_free(reasons, NULL);
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** A new directory or router-status has arrived; update the down/listed
* status of the entry guards.
*
* An entry is 'down' if the directory lists it as nonrunning.
* An entry is 'unlisted' if the directory doesn't include it.
*
* Don't call this on startup; only on a fresh download. Otherwise we'll
* think that things are unlisted.
*/
void
entry_guards_compute_status(const or_options_t *options, time_t now)
{
entry_guards_compute_status_for_guard_selection(get_guard_selection_info(),
options, now);
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/** Called when a connection to an OR with the identity digest <b>digest</b>
* is established (<b>succeeded</b>==1) or has failed (<b>succeeded</b>==0).
* If the OR is an entry, change that entry's up/down status.
* Return 0 normally, or -1 if we want to tear down the new connection.
*
* If <b>mark_relay_status</b>, also call router_set_status() on this
* relay.
Replace nearly all XXX0vv comments with smarter ones So, back long ago, XXX012 meant, "before Tor 0.1.2 is released, we had better revisit this comment and fix it!" But we have a huge pile of such comments accumulated for a large number of released versions! Not cool. So, here's what I tried to do: * 0.2.9 and 0.2.8 are retained, since those are not yet released. * XXX+ or XXX++ or XXX++++ or whatever means, "This one looks quite important!" * The others, after one-by-one examination, are downgraded to plain old XXX. Which doesn't mean they aren't a problem -- just that they cannot possibly be a release-blocking problem.
2016-05-30 22:18:16 +02:00
*/
/* XXX We could change succeeded and mark_relay_status into 'int flags'.
* Too many boolean arguments is a recipe for confusion.
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*/
int
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
entry_guard_register_connect_status_for_guard_selection(
guard_selection_t *gs, const char *digest, int succeeded,
int mark_relay_status, time_t now)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
int changed = 0;
int refuse_conn = 0;
int first_contact = 0;
entry_guard_t *entry = NULL;
int idx = -1;
char buf[HEX_DIGEST_LEN+1];
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
if (!(gs) || !(gs->chosen_entry_guards)) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
return 0;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
Add an (as yet) unused UseDeprecatedGuardAlgorithm_ option. I expect we'll be ripping this out somewhere in 0.3.0, but let's keep it around for a little while in case it turns out to be the only way to avert disaster?
2016-11-21 23:02:51 +01:00
if (! get_options()->UseDeprecatedGuardAlgorithm) {
return 0;
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
tor_assert(e);
if (tor_memeq(e->identity, digest, DIGEST_LEN)) {
entry = e;
idx = e_sl_idx;
break;
}
} SMARTLIST_FOREACH_END(e);
if (!entry)
return 0;
base16_encode(buf, sizeof(buf), entry->identity, DIGEST_LEN);
if (succeeded) {
if (entry->unreachable_since) {
log_info(LD_CIRC, "Entry guard '%s' (%s) is now reachable again. Good.",
entry->nickname, buf);
entry->can_retry = 0;
entry->unreachable_since = 0;
entry->last_attempted = now;
control_event_guard(entry->nickname, entry->identity, "UP");
changed = 1;
}
if (!entry->made_contact) {
entry->made_contact = 1;
first_contact = changed = 1;
}
} else { /* ! succeeded */
if (!entry->made_contact) {
/* We've never connected to this one. */
log_info(LD_CIRC,
"Connection to never-contacted entry guard '%s' (%s) failed. "
"Removing from the list. %d/%d entry guards usable/new.",
entry->nickname, buf,
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
num_live_entry_guards_for_guard_selection(gs, 0) - 1,
smartlist_len(gs->chosen_entry_guards)-1);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
control_event_guard(entry->nickname, entry->identity, "DROPPED");
entry_guard_free(entry);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
smartlist_del_keeporder(gs->chosen_entry_guards, idx);
log_entry_guards_for_guard_selection(gs, LOG_INFO);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
changed = 1;
} else if (!entry->unreachable_since) {
log_info(LD_CIRC, "Unable to connect to entry guard '%s' (%s). "
"Marking as unreachable.", entry->nickname, buf);
entry->unreachable_since = entry->last_attempted = now;
control_event_guard(entry->nickname, entry->identity, "DOWN");
changed = 1;
entry->can_retry = 0; /* We gave it an early chance; no good. */
} else {
char tbuf[ISO_TIME_LEN+1];
format_iso_time(tbuf, entry->unreachable_since);
log_debug(LD_CIRC, "Failed to connect to unreachable entry guard "
"'%s' (%s). It has been unreachable since %s.",
entry->nickname, buf, tbuf);
entry->last_attempted = now;
entry->can_retry = 0; /* We gave it an early chance; no good. */
}
}
/* if the caller asked us to, also update the is_running flags for this
* relay */
if (mark_relay_status)
router_set_status(digest, succeeded);
if (first_contact) {
/* We've just added a new long-term entry guard. Perhaps the network just
* came back? We should give our earlier entries another try too,
* and close this connection so we don't use it before we've given
* the others a shot. */
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (e == entry)
break;
if (e->made_contact) {
const char *msg;
Change the interface of entry_is_live() to take a bitmap.
2014-06-25 21:44:36 +02:00
const node_t *r = entry_is_live(e,
ENTRY_NEED_CAPACITY | ENTRY_ASSUME_REACHABLE,
&msg);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (r && e->unreachable_since) {
refuse_conn = 1;
e->can_retry = 1;
}
}
} SMARTLIST_FOREACH_END(e);
if (refuse_conn) {
log_info(LD_CIRC,
"Connected to new entry guard '%s' (%s). Marking earlier "
"entry guards up. %d/%d entry guards usable/new.",
entry->nickname, buf,
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
num_live_entry_guards_for_guard_selection(gs, 0),
smartlist_len(gs->chosen_entry_guards));
log_entry_guards_for_guard_selection(gs, LOG_INFO);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
changed = 1;
}
}
if (changed)
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
entry_guards_changed_for_guard_selection(gs);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
return refuse_conn ? -1 : 0;
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Called when a connection to an OR with the identity digest <b>digest</b>
* is established (<b>succeeded</b>==1) or has failed (<b>succeeded</b>==0).
* If the OR is an entry, change that entry's up/down status in the default
* guard selection context.
* Return 0 normally, or -1 if we want to tear down the new connection.
*
* If <b>mark_relay_status</b>, also call router_set_status() on this
* relay.
*/
int
entry_guard_register_connect_status(const char *digest, int succeeded,
int mark_relay_status, time_t now)
{
return entry_guard_register_connect_status_for_guard_selection(
get_guard_selection_info(), digest, succeeded, mark_relay_status, now);
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/** Called when the value of EntryNodes changes in our configuration. */
void
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
entry_nodes_should_be_added_for_guard_selection(guard_selection_t *gs)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_assert(gs != NULL);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
log_info(LD_CIRC, "EntryNodes config option set. Putting configured "
"relays at the front of the entry guard list.");
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
gs->should_add_entry_nodes = 1;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Called when the value of EntryNodes changes in our configuration. */
void
entry_nodes_should_be_added(void)
{
entry_nodes_should_be_added_for_guard_selection(
get_guard_selection_info());
Add some code to bluntly prevent duplicate guards from getting added Apparently something in the directory guard code made it possible for the same node to get added as a guard over and over when there were no actual running guard nodes.
2013-02-14 17:48:47 +01:00
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/** Adjust the entry guards list so that it only contains entries from
* EntryNodes, adding new entries from EntryNodes to the list as needed. */
Make a few entrynodes.c functions testable.
2014-06-16 03:38:52 +02:00
STATIC void
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
entry_guards_set_from_config(guard_selection_t *gs,
const or_options_t *options)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
smartlist_t *entry_nodes, *worse_entry_nodes, *entry_fps;
smartlist_t *old_entry_guards_on_list, *old_entry_guards_not_on_list;
Add and use a new NumEntryGuards consensus parameter. When specified, it overrides our default of 3 entry guards. (By default, it overrides the number of directory guards too.) Implements ticket 12688.
2014-07-23 18:23:49 +02:00
const int numentryguards = decide_num_guards(options, 0);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_assert(gs != NULL);
tor_assert(gs->chosen_entry_guards != NULL);
gs->should_add_entry_nodes = 0;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (!options->EntryNodes) {
/* It's possible that a controller set EntryNodes, thus making
* should_add_entry_nodes set, then cleared it again, all before the
* call to choose_random_entry() that triggered us. If so, just return.
*/
return;
}
{
char *string = routerset_to_string(options->EntryNodes);
log_info(LD_CIRC,"Adding configured EntryNodes '%s'.", string);
tor_free(string);
}
entry_nodes = smartlist_new();
worse_entry_nodes = smartlist_new();
entry_fps = smartlist_new();
old_entry_guards_on_list = smartlist_new();
old_entry_guards_not_on_list = smartlist_new();
/* Split entry guards into those on the list and those not. */
routerset_get_all_nodes(entry_nodes, options->EntryNodes,
options->ExcludeNodes, 0);
SMARTLIST_FOREACH(entry_nodes, const node_t *,node,
smartlist_add(entry_fps, (void*)node->identity));
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
SMARTLIST_FOREACH(gs->chosen_entry_guards, entry_guard_t *, e, {
Rename *_isin to *_contains This is an automatically generated commit, from the following perl script, run with the options "-w -i -p". s/smartlist_string_num_isin/smartlist_contains_int_as_string/g; s/smartlist_string_isin((?:_case)?)/smartlist_contains_string$1/g; s/smartlist_digest_isin/smartlist_contains_digest/g; s/smartlist_isin/smartlist_contains/g; s/digestset_isin/digestset_contains/g;
2012-04-11 18:50:50 +02:00
if (smartlist_contains_digest(entry_fps, e->identity))
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
smartlist_add(old_entry_guards_on_list, e);
else
smartlist_add(old_entry_guards_not_on_list, e);
});
/* Remove all currently configured guard nodes, excluded nodes, unreachable
* nodes, or non-Guard nodes from entry_nodes. */
SMARTLIST_FOREACH_BEGIN(entry_nodes, const node_t *, node) {
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
if (entry_guard_get_by_id_digest_for_guard_selection(gs,
node->identity)) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
SMARTLIST_DEL_CURRENT(entry_nodes, node);
continue;
} else if (routerset_contains_node(options->ExcludeNodes, node)) {
SMARTLIST_DEL_CURRENT(entry_nodes, node);
continue;
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
} else if (!fascist_firewall_allows_node(node, FIREWALL_OR_CONNECTION,
0)) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
SMARTLIST_DEL_CURRENT(entry_nodes, node);
continue;
} else if (! node->is_possible_guard) {
smartlist_add(worse_entry_nodes, (node_t*)node);
SMARTLIST_DEL_CURRENT(entry_nodes, node);
}
} SMARTLIST_FOREACH_END(node);
/* Now build the new entry_guards list. */
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
smartlist_clear(gs->chosen_entry_guards);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/* First, the previously configured guards that are in EntryNodes. */
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
smartlist_add_all(gs->chosen_entry_guards, old_entry_guards_on_list);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/* Next, scramble the rest of EntryNodes, putting the guards first. */
smartlist_shuffle(entry_nodes);
smartlist_shuffle(worse_entry_nodes);
smartlist_add_all(entry_nodes, worse_entry_nodes);
/* Next, the rest of EntryNodes */
SMARTLIST_FOREACH_BEGIN(entry_nodes, const node_t *, node) {
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
add_an_entry_guard(gs, node, 0, 0, 1, 0);
if (smartlist_len(gs->chosen_entry_guards) > numentryguards * 10)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
break;
} SMARTLIST_FOREACH_END(node);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
log_notice(LD_GENERAL, "%d entries in guards",
smartlist_len(gs->chosen_entry_guards));
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/* Finally, free the remaining previously configured guards that are not in
* EntryNodes. */
SMARTLIST_FOREACH(old_entry_guards_not_on_list, entry_guard_t *, e,
entry_guard_free(e));
smartlist_free(entry_nodes);
smartlist_free(worse_entry_nodes);
smartlist_free(entry_fps);
smartlist_free(old_entry_guards_on_list);
smartlist_free(old_entry_guards_not_on_list);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
entry_guards_changed_for_guard_selection(gs);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
/** Return 0 if we're fine adding arbitrary routers out of the
* directory to our entry guard list, or return 1 if we have a
* list already and we must stick to it.
*/
int
entry_list_is_constrained(const or_options_t *options)
{
if (options->EntryNodes)
return 1;
if (options->UseBridges)
return 1;
return 0;
}
/** Pick a live (up and listed) entry guard from entry_guards. If
* <b>state</b> is non-NULL, this is for a specific circuit --
* make sure not to pick this circuit's exit or any node in the
* exit's family. If <b>state</b> is NULL, we're looking for a random
Improve DIRINFO flags' usage comments Document usage of the NO_DIRINFO and ALL_DIRINFO flags clearly in functions which take them as arguments. Replace 0 with NO_DIRINFO in a function call for clarity. Seeks to prevent future issues like 13163.
2014-10-01 10:54:26 +02:00
* guard (likely a bridge). If <b>dirinfo</b> is not NO_DIRINFO (zero),
* then only select from nodes that know how to answer directory questions
generalize choose_random_entry()'s dirinfo parameter Now we can specify to skip bridges that wouldn't be able to answer the type of dir fetch we're launching. It's still the responsibility of the rest of the code to prevent us from launching a given dir fetch if we have no bridges that could handle it.
2012-01-26 02:49:32 +01:00
* of that type. */
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
const node_t *
Restore the entry/dirguard distinction. We shouldn't be calling choose_random_entry() for directory conncetions; that's what choose_random_dirguard() is for.
2013-02-12 22:23:12 +01:00
choose_random_entry(cpath_build_state_t *state)
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
{
Add an (as yet) unused UseDeprecatedGuardAlgorithm_ option. I expect we'll be ripping this out somewhere in 0.3.0, but let's keep it around for a little while in case it turns out to be the only way to avert disaster?
2016-11-21 23:02:51 +01:00
tor_assert(get_options()->UseDeprecatedGuardAlgorithm);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
return choose_random_entry_impl(get_guard_selection_info(),
state, 0, NO_DIRINFO, NULL);
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
}
/** Pick a live (up and listed) directory guard from entry_guards for
* downloading information of type <b>type</b>. */
const node_t *
choose_random_dirguard(dirinfo_type_t type)
{
Add an (as yet) unused UseDeprecatedGuardAlgorithm_ option. I expect we'll be ripping this out somewhere in 0.3.0, but let's keep it around for a little while in case it turns out to be the only way to avert disaster?
2016-11-21 23:02:51 +01:00
tor_assert(get_options()->UseDeprecatedGuardAlgorithm);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
return choose_random_entry_impl(get_guard_selection_info(),
NULL, 1, type, NULL);
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
}
Add accessors as needed to repair compilation The previous commit, in moving a bunch of functions to bridges.c, broke compilation because bridges.c required two entry points to entrynodes.c it didn't have.
2016-11-15 14:15:29 +01:00
/** Return the number of bridges that have descriptors that are marked with
* purpose 'bridge' and are running.
*/
int
num_bridges_usable(void)
{
Add an (as yet) unused UseDeprecatedGuardAlgorithm_ option. I expect we'll be ripping this out somewhere in 0.3.0, but let's keep it around for a little while in case it turns out to be the only way to avert disaster?
2016-11-21 23:02:51 +01:00
tor_assert(get_options()->UseDeprecatedGuardAlgorithm);
Add accessors as needed to repair compilation The previous commit, in moving a bunch of functions to bridges.c, broke compilation because bridges.c required two entry points to entrynodes.c it didn't have.
2016-11-15 14:15:29 +01:00
int n_options = 0;
tor_assert(get_options()->UseBridges);
(void) choose_random_entry_impl(get_guard_selection_info(),
NULL, 0, 0, &n_options);
return n_options;
}
Document choose_random_entry_impl() and populate_live_entry_guards().
2014-06-16 04:02:35 +02:00
/** Filter <b>all_entry_guards</b> for usable entry guards and put them
* in <b>live_entry_guards</b>. We filter based on whether the node is
* currently alive, and on whether it satisfies the restrictions
* imposed by the other arguments of this function.
*
* We don't place more guards than NumEntryGuards in <b>live_entry_guards</b>.
*
* If <b>chosen_exit</b> is set, it contains the exit node of this
* circuit. Make sure to not use it or its family as an entry guard.
*
* If <b>need_uptime</b> is set, we are looking for a stable entry guard.
* if <b>need_capacity</b> is set, we are looking for a fast entry guard.
*
* The rest of the arguments are the same as in choose_random_entry_impl().
*
* Return 1 if we should choose a guard right away. Return 0 if we
* should try to add more nodes to our list before deciding on a
* guard.
*/
Make a few entrynodes.c functions testable.
2014-06-16 03:38:52 +02:00
STATIC int
Fix the functionality of populate_live_entry_guards().
2014-06-09 19:23:07 +02:00
populate_live_entry_guards(smartlist_t *live_entry_guards,
Make populate_live_entry_guards() more smoothly testable.
2014-06-09 20:14:40 +02:00
const smartlist_t *all_entry_guards,
Create skeleton for populate_live_entry_guards(). Now we are ready to move code from choose_random_entry_impl() to it.
2014-06-09 19:03:09 +02:00
const node_t *chosen_exit,
dirinfo_type_t dirinfo_type,
Fix the functionality of populate_live_entry_guards().
2014-06-09 19:23:07 +02:00
int for_directory,
int need_uptime, int need_capacity)
Create skeleton for populate_live_entry_guards(). Now we are ready to move code from choose_random_entry_impl() to it.
2014-06-09 19:03:09 +02:00
{
Fix the functionality of populate_live_entry_guards().
2014-06-09 19:23:07 +02:00
const or_options_t *options = get_options();
const node_t *node = NULL;
const int num_needed = decide_num_guards(options, for_directory);
smartlist_t *exit_family = smartlist_new();
int retval = 0;
Change the interface of entry_is_live() to take a bitmap.
2014-06-25 21:44:36 +02:00
entry_is_live_flags_t entry_flags = 0;
mark dirinfo_type as unused in populate_live_entry_guards
2015-04-01 20:20:01 +02:00
(void) dirinfo_type;
Change the interface of entry_is_live() to take a bitmap.
2014-06-25 21:44:36 +02:00
{ /* Set the flags we want our entry node to have */
if (need_uptime) {
entry_flags |= ENTRY_NEED_UPTIME;
}
if (need_capacity) {
entry_flags |= ENTRY_NEED_CAPACITY;
}
if (!for_directory) {
entry_flags |= ENTRY_NEED_DESCRIPTOR;
}
}
Fix the functionality of populate_live_entry_guards().
2014-06-09 19:23:07 +02:00
Make populate_live_entry_guards() more smoothly testable.
2014-06-09 20:14:40 +02:00
tor_assert(all_entry_guards);
Fix the functionality of populate_live_entry_guards().
2014-06-09 19:23:07 +02:00
Move code from choose_random_entry_impl() to the new function. This commit only _moves_ code.
2014-06-09 19:04:39 +02:00
if (chosen_exit) {
nodelist_add_node_and_family(exit_family, chosen_exit);
}
Make populate_live_entry_guards() more smoothly testable.
2014-06-09 20:14:40 +02:00
SMARTLIST_FOREACH_BEGIN(all_entry_guards, const entry_guard_t *, entry) {
Move code from choose_random_entry_impl() to the new function. This commit only _moves_ code.
2014-06-09 19:04:39 +02:00
const char *msg;
Change the interface of entry_is_live() to take a bitmap.
2014-06-25 21:44:36 +02:00
node = entry_is_live(entry, entry_flags, &msg);
Move code from choose_random_entry_impl() to the new function. This commit only _moves_ code.
2014-06-09 19:04:39 +02:00
if (!node)
continue; /* down, no point */
if (for_directory) {
if (!entry->is_dir_cache)
continue; /* We need a directory and didn't get one. */
}
if (node == chosen_exit)
continue; /* don't pick the same node for entry and exit */
if (smartlist_contains(exit_family, node))
continue; /* avoid relays that are family members of our exit */
smartlist_add(live_entry_guards, (void*)node);
if (!entry->made_contact) {
/* Always start with the first not-yet-contacted entry
* guard. Otherwise we might add several new ones, pick
* the second new one, and now we've expanded our entry
* guard list without needing to. */
Fix the functionality of populate_live_entry_guards().
2014-06-09 19:23:07 +02:00
retval = 1;
goto done;
}
if (smartlist_len(live_entry_guards) >= num_needed) {
retval = 1;
goto done; /* We picked enough entry guards. Done! */
Move code from choose_random_entry_impl() to the new function. This commit only _moves_ code.
2014-06-09 19:04:39 +02:00
}
} SMARTLIST_FOREACH_END(entry);
Fix the functionality of populate_live_entry_guards().
2014-06-09 19:23:07 +02:00
done:
smartlist_free(exit_family);
return retval;
Create skeleton for populate_live_entry_guards(). Now we are ready to move code from choose_random_entry_impl() to it.
2014-06-09 19:03:09 +02:00
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Pick a node to be used as the entry guard of a circuit, relative to
* a supplied guard selection context.
Document choose_random_entry_impl() and populate_live_entry_guards().
2014-06-16 04:02:35 +02:00
*
* If <b>state</b> is set, it contains the information we know about
* the upcoming circuit.
*
* If <b>for_directory</b> is set, we are looking for a directory guard.
*
* <b>dirinfo_type</b> contains the kind of directory information we
Improve DIRINFO flags' usage comments Document usage of the NO_DIRINFO and ALL_DIRINFO flags clearly in functions which take them as arguments. Replace 0 with NO_DIRINFO in a function call for clarity. Seeks to prevent future issues like 13163.
2014-10-01 10:54:26 +02:00
* are looking for in our node, or NO_DIRINFO (zero) if we are not
* looking for any particular directory information (when set to
* NO_DIRINFO, the <b>dirinfo_type</b> filter is ignored).
Document choose_random_entry_impl() and populate_live_entry_guards().
2014-06-16 04:02:35 +02:00
*
* If <b>n_options_out</b> is set, we set it to the number of
* candidate guard nodes we had before picking a specific guard node.
*
* On success, return the node that should be used as the entry guard
* of the circuit. Return NULL if no such node could be found.
*
* Helper for choose_random{entry,dirguard}.
*/
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
static const node_t *
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
choose_random_entry_impl(guard_selection_t *gs,
cpath_build_state_t *state, int for_directory,
Fix our check for the "first" bridge descriptor. This is meant to be a better bug 9229 fix -- or at least, one more in tune with the intent of the original code, which calls router_retry_directory_downloads() only on the first bridge descriptor.
2014-03-10 20:11:21 +01:00
dirinfo_type_t dirinfo_type, int *n_options_out)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
const or_options_t *options = get_options();
smartlist_t *live_entry_guards = smartlist_new();
const node_t *chosen_exit =
state?build_state_get_exit_node(state) : NULL;
const node_t *node = NULL;
int need_uptime = state ? state->need_uptime : 0;
int need_capacity = state ? state->need_capacity : 0;
choose_random_entry_impl(): Remove useless consider_exit_family. The variable was useless since it was only toggled off in disabled code. If the 'exit_family' smartlist is empty, we don't consider exit family anyway.
2014-06-09 18:42:55 +02:00
int preferred_min = 0;
NumDirectoryGuards now tracks NumEntryGuards by default Now a user who changes only NumEntryGuards will get the behavior she expects. Fixes bug 9354; bugfix on 0.2.4.8-alpha.
2013-07-30 18:05:39 +02:00
const int num_needed = decide_num_guards(options, for_directory);
Fix the functionality of populate_live_entry_guards().
2014-06-09 19:23:07 +02:00
int retval = 0;
Directory guard implementation. Implements proposal 207; ticket 6526.
2012-12-11 18:44:18 +01:00
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_assert(gs != NULL);
Refactor to always allocate chosen_entry_guards in new guard_selection_new() function
2016-10-14 02:15:30 +02:00
tor_assert(gs->chosen_entry_guards != NULL);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
Fix our check for the "first" bridge descriptor. This is meant to be a better bug 9229 fix -- or at least, one more in tune with the intent of the original code, which calls router_retry_directory_downloads() only on the first bridge descriptor.
2014-03-10 20:11:21 +01:00
if (n_options_out)
Make num_bridges_usable work properly. My first implementation was broken, since it returned "whether there is one bridge" rather than "how many bridges." Also, the implementation for the n_options_out feature in choose_random_entry_impl was completely broken due to a missing *.
2014-04-08 21:49:49 +02:00
*n_options_out = 0;
Fix our check for the "first" bridge descriptor. This is meant to be a better bug 9229 fix -- or at least, one more in tune with the intent of the original code, which calls router_retry_directory_downloads() only on the first bridge descriptor.
2014-03-10 20:11:21 +01:00
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
if (gs->should_add_entry_nodes)
entry_guards_set_from_config(gs, options);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (!entry_list_is_constrained(options) &&
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
smartlist_len(gs->chosen_entry_guards) < num_needed)
pick_entry_guards(gs, options, for_directory);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
retry:
smartlist_clear(live_entry_guards);
Fix the functionality of populate_live_entry_guards().
2014-06-09 19:23:07 +02:00
/* Populate the list of live entry guards so that we pick one of
them. */
retval = populate_live_entry_guards(live_entry_guards,
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
gs->chosen_entry_guards,
Fix the functionality of populate_live_entry_guards().
2014-06-09 19:23:07 +02:00
chosen_exit,
dirinfo_type,
for_directory,
need_uptime, need_capacity);
if (retval == 1) { /* We should choose a guard right now. */
goto choose_and_finish;
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (entry_list_is_constrained(options)) {
/* If we prefer the entry nodes we've got, and we have at least
* one choice, that's great. Use it. */
preferred_min = 1;
} else {
/* Try to have at least 2 choices available. This way we don't
* get stuck with a single live-but-crummy entry and just keep
Correct grammatical errors in tor comments Avoid using gender for things that don't have it. Avoid assigning a gender to tor users.
2016-01-26 03:45:01 +01:00
* using it.
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
* (We might get 2 live-but-crummy entry guards, but so be it.) */
preferred_min = 2;
}
if (smartlist_len(live_entry_guards) < preferred_min) {
if (!entry_list_is_constrained(options)) {
/* still no? try adding a new entry then */
/* XXX if guard doesn't imply fast and stable, then we need
* to tell add_an_entry_guard below what we want, or it might
* be a long time til we get it. -RD */
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
node = add_an_entry_guard(gs, NULL, 0, 0, 1, for_directory);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (node) {
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
entry_guards_changed_for_guard_selection(gs);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/* XXX we start over here in case the new node we added shares
* a family with our exit node. There's a chance that we'll just
* load up on entry guards here, if the network we're using is
* one big family. Perhaps we should teach add_an_entry_guard()
* to understand nodes-to-avoid-if-possible? -RD */
goto retry;
}
}
if (!node && need_uptime) {
need_uptime = 0; /* try without that requirement */
goto retry;
}
if (!node && need_capacity) {
/* still no? last attempt, try without requiring capacity */
need_capacity = 0;
goto retry;
}
choose_random_entry_impl(): Remove useless consider_exit_family. The variable was useless since it was only toggled off in disabled code. If the 'exit_family' smartlist is empty, we don't consider exit family anyway.
2014-06-09 18:42:55 +02:00
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/* live_entry_guards may be empty below. Oh well, we tried. */
}
choose_and_finish:
if (entry_list_is_constrained(options)) {
/* We need to weight by bandwidth, because our bridges or entryguards
* were not already selected proportional to their bandwidth. */
node = node_sl_choose_by_bandwidth(live_entry_guards, WEIGHT_FOR_GUARD);
} else {
/* We choose uniformly at random here, because choose_good_entry_server()
* already weights its choices by bandwidth, so we don't want to
* *double*-weight our guard selection. */
node = smartlist_choose(live_entry_guards);
}
Fix our check for the "first" bridge descriptor. This is meant to be a better bug 9229 fix -- or at least, one more in tune with the intent of the original code, which calls router_retry_directory_downloads() only on the first bridge descriptor.
2014-03-10 20:11:21 +01:00
if (n_options_out)
*n_options_out = smartlist_len(live_entry_guards);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
smartlist_free(live_entry_guards);
return node;
}
/** Parse <b>state</b> and learn about the entry guards it describes.
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
* If <b>set</b> is true, and there are no errors, replace the guard
* list in the provided guard selection context with what we find.
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
* On success, return 0. On failure, alloc into *<b>msg</b> a string
* describing the error, and return -1.
*/
int
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
entry_guards_parse_state_for_guard_selection(
guard_selection_t *gs,
or_state_t *state, int set, char **msg)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
entry_guard_t *node = NULL;
smartlist_t *new_entry_guards = smartlist_new();
config_line_t *line;
time_t now = time(NULL);
const char *state_version = state->TorVersion;
digestmap_t *added_by = digestmap_new();
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_assert(gs != NULL);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*msg = NULL;
for (line = state->EntryGuards; line; line = line->next) {
if (!strcasecmp(line->key, "EntryGuard")) {
smartlist_t *args = smartlist_new();
node = tor_malloc_zero(sizeof(entry_guard_t));
/* all entry guards on disk have been contacted */
node->made_contact = 1;
smartlist_add(new_entry_guards, node);
smartlist_split_string(args, line->value, " ",
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
if (smartlist_len(args)<2) {
*msg = tor_strdup("Unable to parse entry nodes: "
"Too few arguments to EntryGuard");
} else if (!is_legal_nickname(smartlist_get(args,0))) {
*msg = tor_strdup("Unable to parse entry nodes: "
"Bad nickname for EntryGuard");
} else {
strlcpy(node->nickname, smartlist_get(args,0), MAX_NICKNAME_LEN+1);
if (base16_decode(node->identity, DIGEST_LEN, smartlist_get(args,1),
Make base16_decodes return number of decoded bytes base16_decodes() now returns the number of decoded bytes. It's interface changes from returning a "int" to a "ssize_t". Every callsite now checks the returned value. Fixes #14013 Signed-off-by: David Goulet <dgoulet@torproject.org>
2016-06-17 16:41:45 +02:00
strlen(smartlist_get(args,1))) != DIGEST_LEN) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*msg = tor_strdup("Unable to parse entry nodes: "
"Bad hex digest for EntryGuard");
}
}
Remember which of our guards are directory caches
2012-12-11 17:43:27 +01:00
if (smartlist_len(args) >= 3) {
const char *is_cache = smartlist_get(args, 2);
if (!strcasecmp(is_cache, "DirCache")) {
node->is_dir_cache = 1;
} else if (!strcasecmp(is_cache, "NoDirCache")) {
node->is_dir_cache = 0;
} else {
log_warn(LD_CONFIG, "Bogus third argument to EntryGuard line: %s",
escaped(is_cache));
}
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
SMARTLIST_FOREACH(args, char*, cp, tor_free(cp));
smartlist_free(args);
if (*msg)
break;
} else if (!strcasecmp(line->key, "EntryGuardDownSince") ||
!strcasecmp(line->key, "EntryGuardUnlistedSince")) {
time_t when;
time_t last_try = 0;
if (!node) {
*msg = tor_strdup("Unable to parse entry nodes: "
"EntryGuardDownSince/UnlistedSince without EntryGuard");
break;
}
Teach parse_iso_time about the spaceless variant. (We previously added support for generating the spaceless 2016-11-14T19:58:12 variant, but not for actually parsing it.)
2016-11-14 20:57:32 +01:00
if (parse_iso_time_(line->value, &when, 0, 0)<0) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*msg = tor_strdup("Unable to parse entry nodes: "
"Bad time in EntryGuardDownSince/UnlistedSince");
break;
}
if (when > now) {
/* It's a bad idea to believe info in the future: you can wind
* up with timeouts that aren't allowed to happen for years. */
continue;
}
if (strlen(line->value) >= ISO_TIME_LEN+ISO_TIME_LEN+1) {
/* ignore failure */
(void) parse_iso_time(line->value+ISO_TIME_LEN+1, &last_try);
}
if (!strcasecmp(line->key, "EntryGuardDownSince")) {
node->unreachable_since = when;
node->last_attempted = last_try;
} else {
node->bad_since = when;
}
} else if (!strcasecmp(line->key, "EntryGuardAddedBy")) {
char d[DIGEST_LEN];
/* format is digest version date */
if (strlen(line->value) < HEX_DIGEST_LEN+1+1+1+ISO_TIME_LEN) {
log_warn(LD_BUG, "EntryGuardAddedBy line is not long enough.");
continue;
}
Make base16_decodes return number of decoded bytes base16_decodes() now returns the number of decoded bytes. It's interface changes from returning a "int" to a "ssize_t". Every callsite now checks the returned value. Fixes #14013 Signed-off-by: David Goulet <dgoulet@torproject.org>
2016-06-17 16:41:45 +02:00
if (base16_decode(d, sizeof(d),
line->value, HEX_DIGEST_LEN) != sizeof(d) ||
line->value[HEX_DIGEST_LEN] != ' ') {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
log_warn(LD_BUG, "EntryGuardAddedBy line %s does not begin with "
"hex digest", escaped(line->value));
continue;
}
digestmap_set(added_by, d, tor_strdup(line->value+HEX_DIGEST_LEN+1));
Implement Path use bias accounting. Path use bias measures how often we can actually succeed using the circuits we actually try to use. It is a subset of path bias accounting, but it is computed as a separate statistic because the rate of client circuit use may vary depending on use case.
2013-01-19 04:37:16 +01:00
} else if (!strcasecmp(line->key, "EntryGuardPathUseBias")) {
const or_options_t *options = get_options();
double use_cnt, success_cnt;
if (!node) {
*msg = tor_strdup("Unable to parse entry nodes: "
"EntryGuardPathUseBias without EntryGuard");
break;
}
if (tor_sscanf(line->value, "%lf %lf",
&use_cnt, &success_cnt) != 2) {
log_info(LD_GENERAL, "Malformed path use bias line for node %s",
node->nickname);
continue;
}
Clip invalid path bias counts at startup. There was a bug in Tor prior to 0.2.4.10-alpha that allowed counts to become invalid. Clipping the counts at startup allows us to rule out log messages due to corruption from these prior Tor versions.
2013-03-26 00:04:30 +01:00
if (use_cnt < success_cnt) {
int severity = LOG_INFO;
/* If this state file was written by a Tor that would have
* already fixed it, then the overcounting bug is still there.. */
Increase the pathbias state file miscounting version check. We now know the bug is present in 0.2.4.12-alpha too. It should be fixed in 0.2.4.13-alpha, though.
2013-04-24 02:53:53 +02:00
if (tor_version_as_new_as(state_version, "0.2.4.13-alpha")) {
Clip invalid path bias counts at startup. There was a bug in Tor prior to 0.2.4.10-alpha that allowed counts to become invalid. Clipping the counts at startup allows us to rule out log messages due to corruption from these prior Tor versions.
2013-03-26 00:04:30 +01:00
severity = LOG_NOTICE;
}
log_fn(severity, LD_BUG,
"State file contains unexpectedly high usage success "
"counts %lf/%lf for Guard %s ($%s)",
success_cnt, use_cnt,
node->nickname, hex_str(node->identity, DIGEST_LEN));
success_cnt = use_cnt;
}
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
node->pb.use_attempts = use_cnt;
node->pb.use_successes = success_cnt;
Implement Path use bias accounting. Path use bias measures how often we can actually succeed using the circuits we actually try to use. It is a subset of path bias accounting, but it is computed as a separate statistic because the rate of client circuit use may vary depending on use case.
2013-01-19 04:37:16 +01:00
log_info(LD_GENERAL, "Read %f/%f path use bias for node %s",
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
node->pb.use_successes, node->pb.use_attempts, node->nickname);
Implement Path use bias accounting. Path use bias measures how often we can actually succeed using the circuits we actually try to use. It is a subset of path bias accounting, but it is computed as a separate statistic because the rate of client circuit use may vary depending on use case.
2013-01-19 04:37:16 +01:00
/* Note: We rely on the < comparison here to allow us to set a 0
* rate and disable the feature entirely. If refactoring, don't
* change to <= */
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
if (pathbias_get_use_success_count(node)/node->pb.use_attempts
Implement Path use bias accounting. Path use bias measures how often we can actually succeed using the circuits we actually try to use. It is a subset of path bias accounting, but it is computed as a separate statistic because the rate of client circuit use may vary depending on use case.
2013-01-19 04:37:16 +01:00
< pathbias_get_extreme_use_rate(options) &&
pathbias_get_dropguards(options)) {
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
node->pb.path_bias_disabled = 1;
Implement Path use bias accounting. Path use bias measures how often we can actually succeed using the circuits we actually try to use. It is a subset of path bias accounting, but it is computed as a separate statistic because the rate of client circuit use may vary depending on use case.
2013-01-19 04:37:16 +01:00
log_info(LD_GENERAL,
"Path use bias is too high (%f/%f); disabling node %s",
Whitespace fixes from previous mechanical search-and-replaces
2016-11-14 19:01:19 +01:00
node->pb.circ_successes, node->pb.circ_attempts,
node->nickname);
Implement Path use bias accounting. Path use bias measures how often we can actually succeed using the circuits we actually try to use. It is a subset of path bias accounting, but it is computed as a separate statistic because the rate of client circuit use may vary depending on use case.
2013-01-19 04:37:16 +01:00
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
} else if (!strcasecmp(line->key, "EntryGuardPathBias")) {
const or_options_t *options = get_options();
Convert to doubles for all pathbias state. Let's hope this solves the rounding error issue..
2012-12-10 05:53:22 +01:00
double hop_cnt, success_cnt, timeouts, collapsed, successful_closed,
Prop 209: Add path bias counts for timeouts and other mechanisms. Turns out there's more than one way to block a tagged circuit. This seems to successfully handle all of the normal exit circuits. Hidden services need additional tweaks, still.
2012-11-18 01:30:50 +01:00
unusable;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
if (!node) {
*msg = tor_strdup("Unable to parse entry nodes: "
"EntryGuardPathBias without EntryGuard");
break;
}
Add the ability to count circuit timeouts for guards. This is purely for informational reasons for debugging.
2012-10-25 02:34:18 +02:00
/* First try 3 params, then 2. */
Space fixes.
2012-12-10 08:47:04 +01:00
/* In the long run: circuit_success ~= successful_circuit_close +
Prop 209: Add path bias counts for timeouts and other mechanisms. Turns out there's more than one way to block a tagged circuit. This seems to successfully handle all of the normal exit circuits. Hidden services need additional tweaks, still.
2012-11-18 01:30:50 +01:00
* collapsed_circuits +
* unusable_circuits */
Convert to doubles for all pathbias state. Let's hope this solves the rounding error issue..
2012-12-10 05:53:22 +01:00
if (tor_sscanf(line->value, "%lf %lf %lf %lf %lf %lf",
Prop 209: Add path bias counts for timeouts and other mechanisms. Turns out there's more than one way to block a tagged circuit. This seems to successfully handle all of the normal exit circuits. Hidden services need additional tweaks, still.
2012-11-18 01:30:50 +01:00
&hop_cnt, &success_cnt, &successful_closed,
&collapsed, &unusable, &timeouts) != 6) {
Convert to doubles for all pathbias state. Let's hope this solves the rounding error issue..
2012-12-10 05:53:22 +01:00
int old_success, old_hops;
if (tor_sscanf(line->value, "%u %u", &old_success, &old_hops) != 2) {
Add the ability to count circuit timeouts for guards. This is purely for informational reasons for debugging.
2012-10-25 02:34:18 +02:00
continue;
}
Prop 209: Add path bias counts for timeouts and other mechanisms. Turns out there's more than one way to block a tagged circuit. This seems to successfully handle all of the normal exit circuits. Hidden services need additional tweaks, still.
2012-11-18 01:30:50 +01:00
log_info(LD_GENERAL, "Reading old-style EntryGuardPathBias %s",
escaped(line->value));
Convert to doubles for all pathbias state. Let's hope this solves the rounding error issue..
2012-12-10 05:53:22 +01:00
success_cnt = old_success;
successful_closed = old_success;
hop_cnt = old_hops;
Prop 209: Add path bias counts for timeouts and other mechanisms. Turns out there's more than one way to block a tagged circuit. This seems to successfully handle all of the normal exit circuits. Hidden services need additional tweaks, still.
2012-11-18 01:30:50 +01:00
timeouts = 0;
collapsed = 0;
unusable = 0;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
Clip invalid path bias counts at startup. There was a bug in Tor prior to 0.2.4.10-alpha that allowed counts to become invalid. Clipping the counts at startup allows us to rule out log messages due to corruption from these prior Tor versions.
2013-03-26 00:04:30 +01:00
if (hop_cnt < success_cnt) {
int severity = LOG_INFO;
/* If this state file was written by a Tor that would have
* already fixed it, then the overcounting bug is still there.. */
Increase the pathbias state file miscounting version check. We now know the bug is present in 0.2.4.12-alpha too. It should be fixed in 0.2.4.13-alpha, though.
2013-04-24 02:53:53 +02:00
if (tor_version_as_new_as(state_version, "0.2.4.13-alpha")) {
Clip invalid path bias counts at startup. There was a bug in Tor prior to 0.2.4.10-alpha that allowed counts to become invalid. Clipping the counts at startup allows us to rule out log messages due to corruption from these prior Tor versions.
2013-03-26 00:04:30 +01:00
severity = LOG_NOTICE;
}
log_fn(severity, LD_BUG,
"State file contains unexpectedly high success counts "
"%lf/%lf for Guard %s ($%s)",
success_cnt, hop_cnt,
node->nickname, hex_str(node->identity, DIGEST_LEN));
success_cnt = hop_cnt;
}
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
node->pb.circ_attempts = hop_cnt;
node->pb.circ_successes = success_cnt;
Prop 209: Add path bias counts for timeouts and other mechanisms. Turns out there's more than one way to block a tagged circuit. This seems to successfully handle all of the normal exit circuits. Hidden services need additional tweaks, still.
2012-11-18 01:30:50 +01:00
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
node->pb.successful_circuits_closed = successful_closed;
node->pb.timeouts = timeouts;
node->pb.collapsed_circuits = collapsed;
node->pb.unusable_circuits = unusable;
Prop 209: Add path bias counts for timeouts and other mechanisms. Turns out there's more than one way to block a tagged circuit. This seems to successfully handle all of the normal exit circuits. Hidden services need additional tweaks, still.
2012-11-18 01:30:50 +01:00
Nick's Code review #3 part 2.
2012-12-18 23:16:01 +01:00
log_info(LD_GENERAL, "Read %f/%f path bias for node %s",
Whitespace fixes from previous mechanical search-and-replaces
2016-11-14 19:01:19 +01:00
node->pb.circ_successes, node->pb.circ_attempts,
node->nickname);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/* Note: We rely on the < comparison here to allow us to set a 0
* rate and disable the feature entirely. If refactoring, don't
* change to <= */
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
if (pathbias_get_close_success_count(node)/node->pb.circ_attempts
Fix a rather serious use-count state bug. We need to use the success count or the use count depending on the consensus parameter.
2012-12-10 05:56:48 +01:00
< pathbias_get_extreme_rate(options) &&
Update pathbias parameters to match Proposal 209. Needs manpage update and testing still..
2012-10-25 03:03:09 +02:00
pathbias_get_dropguards(options)) {
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
node->pb.path_bias_disabled = 1;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
log_info(LD_GENERAL,
Nick's Code review #3 part 2.
2012-12-18 23:16:01 +01:00
"Path bias is too high (%f/%f); disabling node %s",
Whitespace fixes from previous mechanical search-and-replaces
2016-11-14 19:01:19 +01:00
node->pb.circ_successes, node->pb.circ_attempts,
node->nickname);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
} else {
log_warn(LD_BUG, "Unexpected key %s", line->key);
}
}
SMARTLIST_FOREACH_BEGIN(new_entry_guards, entry_guard_t *, e) {
char *sp;
char *val = digestmap_get(added_by, e->identity);
if (val && (sp = strchr(val, ' '))) {
time_t when;
*sp++ = '\0';
if (parse_iso_time(sp, &when)<0) {
log_warn(LD_BUG, "Can't read time %s in EntryGuardAddedBy", sp);
} else {
e->chosen_by_version = tor_strdup(val);
e->chosen_on_date = when;
}
} else {
if (state_version) {
Fix some conversion problems
2015-04-23 15:16:42 +02:00
e->chosen_on_date = crypto_rand_time_range(now - 3600*24*30, now);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
e->chosen_by_version = tor_strdup(state_version);
}
}
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
if (e->pb.path_bias_disabled && !e->bad_since)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
e->bad_since = time(NULL);
}
SMARTLIST_FOREACH_END(e);
if (*msg || !set) {
SMARTLIST_FOREACH(new_entry_guards, entry_guard_t *, e,
entry_guard_free(e));
smartlist_free(new_entry_guards);
} else { /* !err && set */
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
if (gs->chosen_entry_guards) {
SMARTLIST_FOREACH(gs->chosen_entry_guards, entry_guard_t *, e,
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
entry_guard_free(e));
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
smartlist_free(gs->chosen_entry_guards);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
gs->chosen_entry_guards = new_entry_guards;
gs->dirty = 0;
Replace nearly all XXX0vv comments with smarter ones So, back long ago, XXX012 meant, "before Tor 0.1.2 is released, we had better revisit this comment and fix it!" But we have a huge pile of such comments accumulated for a large number of released versions! Not cool. So, here's what I tried to do: * 0.2.9 and 0.2.8 are retained, since those are not yet released. * XXX+ or XXX++ or XXX++++ or whatever means, "This one looks quite important!" * The others, after one-by-one examination, are downgraded to plain old XXX. Which doesn't mean they aren't a problem -- just that they cannot possibly be a release-blocking problem.
2016-05-30 22:18:16 +02:00
/* XXX hand new_entry_guards to this func, and move it up a
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
* few lines, so we don't have to re-dirty it */
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
if (remove_obsolete_entry_guards(gs, now))
gs->dirty = 1;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
digestmap_free(added_by, tor_free_);
return *msg ? -1 : 0;
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Parse <b>state</b> and learn about the entry guards it describes.
* If <b>set</b> is true, and there are no errors, replace the guard
* list in the default guard selection context with what we find.
* On success, return 0. On failure, alloc into *<b>msg</b> a string
* describing the error, and return -1.
*/
int
entry_guards_parse_state(or_state_t *state, int set, char **msg)
{
return entry_guards_parse_state_for_guard_selection(
get_guard_selection_info(),
state, set, msg);
}
Turn entry_guards_changed constants into symbolic constants
2015-01-07 16:37:33 +01:00
/** How long will we let a change in our guard nodes stay un-saved
* when we are trying to avoid disk writes? */
Lower the delay before saving guard status to disk "Maybe this time should be reduced, since we are considering guard-related changes as quite important? It would be a pity to settle on a guard node, then close the Tor client fast and lose that information." Closes 12485.
2015-01-07 16:39:44 +01:00
#define SLOW_GUARD_STATE_FLUSH_TIME 600
Turn entry_guards_changed constants into symbolic constants
2015-01-07 16:37:33 +01:00
/** How long will we let a change in our guard nodes stay un-saved
* when we are not trying to avoid disk writes? */
Lower the delay before saving guard status to disk "Maybe this time should be reduced, since we are considering guard-related changes as quite important? It would be a pity to settle on a guard node, then close the Tor client fast and lose that information." Closes 12485.
2015-01-07 16:39:44 +01:00
#define FAST_GUARD_STATE_FLUSH_TIME 30
Turn entry_guards_changed constants into symbolic constants
2015-01-07 16:37:33 +01:00
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Our list of entry guards has changed for a particular guard selection
* context, or some element of one of our entry guards has changed for one.
* Write the changes to disk within the next few minutes.
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*/
void
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
entry_guards_changed_for_guard_selection(guard_selection_t *gs)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
{
time_t when;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_assert(gs != NULL);
gs->dirty = 1;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
Turn entry_guards_changed constants into symbolic constants
2015-01-07 16:37:33 +01:00
if (get_options()->AvoidDiskWrites)
when = time(NULL) + SLOW_GUARD_STATE_FLUSH_TIME;
else
when = time(NULL) + FAST_GUARD_STATE_FLUSH_TIME;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/* or_state_save() will call entry_guards_update_state(). */
or_state_mark_dirty(get_or_state(), when);
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Our list of entry guards has changed for the default guard selection
* context, or some element of one of our entry guards has changed. Write
* the changes to disk within the next few minutes.
*/
void
entry_guards_changed(void)
{
entry_guards_changed_for_guard_selection(get_guard_selection_info());
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/** If the entry guard info has not changed, do nothing and return.
* Otherwise, free the EntryGuards piece of <b>state</b> and create
* a new one out of the global entry_guards list, and then mark
* <b>state</b> dirty so it will get saved to disk.
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
*
* XXX this should get totally redesigned around storing multiple
* entry guard contexts. For the initial refactor we'll just
* always use the current default. Fix it as soon as we actually
* have any way that default can change.
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*/
void
entry_guards_update_state(or_state_t *state)
{
config_line_t **next, *line;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
guard_selection_t *gs = get_guard_selection_info();
Refactor to always allocate chosen_entry_guards in new guard_selection_new() function
2016-10-14 02:15:30 +02:00
tor_assert(gs != NULL);
tor_assert(gs->chosen_entry_guards != NULL);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
if (!gs->dirty)
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
return;
config_free_lines(state->EntryGuards);
next = &state->EntryGuards;
*next = NULL;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
char dbuf[HEX_DIGEST_LEN+1];
if (!e->made_contact)
continue; /* don't write this one to disk */
*next = line = tor_malloc_zero(sizeof(config_line_t));
line->key = tor_strdup("EntryGuard");
base16_encode(dbuf, sizeof(dbuf), e->identity, DIGEST_LEN);
Remember which of our guards are directory caches
2012-12-11 17:43:27 +01:00
tor_asprintf(&line->value, "%s %s %sDirCache", e->nickname, dbuf,
e->is_dir_cache ? "" : "No");
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
next = &(line->next);
if (e->unreachable_since) {
*next = line = tor_malloc_zero(sizeof(config_line_t));
line->key = tor_strdup("EntryGuardDownSince");
line->value = tor_malloc(ISO_TIME_LEN+1+ISO_TIME_LEN+1);
format_iso_time(line->value, e->unreachable_since);
if (e->last_attempted) {
line->value[ISO_TIME_LEN] = ' ';
format_iso_time(line->value+ISO_TIME_LEN+1, e->last_attempted);
}
next = &(line->next);
}
if (e->bad_since) {
*next = line = tor_malloc_zero(sizeof(config_line_t));
line->key = tor_strdup("EntryGuardUnlistedSince");
line->value = tor_malloc(ISO_TIME_LEN+1);
format_iso_time(line->value, e->bad_since);
next = &(line->next);
}
if (e->chosen_on_date && e->chosen_by_version &&
!strchr(e->chosen_by_version, ' ')) {
char d[HEX_DIGEST_LEN+1];
char t[ISO_TIME_LEN+1];
*next = line = tor_malloc_zero(sizeof(config_line_t));
line->key = tor_strdup("EntryGuardAddedBy");
base16_encode(d, sizeof(d), e->identity, DIGEST_LEN);
format_iso_time(t, e->chosen_on_date);
tor_asprintf(&line->value, "%s %s %s",
d, e->chosen_by_version, t);
next = &(line->next);
}
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
if (e->pb.circ_attempts > 0) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
*next = line = tor_malloc_zero(sizeof(config_line_t));
line->key = tor_strdup("EntryGuardPathBias");
Space fixes.
2012-12-10 08:47:04 +01:00
/* In the long run: circuit_success ~= successful_circuit_close +
Prop 209: Add path bias counts for timeouts and other mechanisms. Turns out there's more than one way to block a tagged circuit. This seems to successfully handle all of the normal exit circuits. Hidden services need additional tweaks, still.
2012-11-18 01:30:50 +01:00
* collapsed_circuits +
* unusable_circuits */
Nick's Code review #3 part 2.
2012-12-18 23:16:01 +01:00
tor_asprintf(&line->value, "%f %f %f %f %f %f",
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
e->pb.circ_attempts, e->pb.circ_successes,
Implement Path use bias accounting. Path use bias measures how often we can actually succeed using the circuits we actually try to use. It is a subset of path bias accounting, but it is computed as a separate statistic because the rate of client circuit use may vary depending on use case.
2013-01-19 04:37:16 +01:00
pathbias_get_close_success_count(e),
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
e->pb.collapsed_circuits,
e->pb.unusable_circuits, e->pb.timeouts);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
next = &(line->next);
}
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
if (e->pb.use_attempts > 0) {
Implement Path use bias accounting. Path use bias measures how often we can actually succeed using the circuits we actually try to use. It is a subset of path bias accounting, but it is computed as a separate statistic because the rate of client circuit use may vary depending on use case.
2013-01-19 04:37:16 +01:00
*next = line = tor_malloc_zero(sizeof(config_line_t));
line->key = tor_strdup("EntryGuardPathUseBias");
tor_asprintf(&line->value, "%f %f",
Move path-bias fields into a separate structure (Other than the field movement, the code changes here are just search-and-replace)
2016-11-14 17:51:38 +01:00
e->pb.use_attempts,
Implement Path use bias accounting. Path use bias measures how often we can actually succeed using the circuits we actually try to use. It is a subset of path bias accounting, but it is computed as a separate statistic because the rate of client circuit use may vary depending on use case.
2013-01-19 04:37:16 +01:00
pathbias_get_use_success_count(e));
next = &(line->next);
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
} SMARTLIST_FOREACH_END(e);
if (!get_options()->AvoidDiskWrites)
or_state_mark_dirty(get_or_state(), 0);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
gs->dirty = 0;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
/** If <b>question</b> is the string "entry-guards", then dump
* to *<b>answer</b> a newly allocated string describing all of
* the nodes in the global entry_guards list. See control-spec.txt
* for details.
* For backward compatibility, we also handle the string "helper-nodes".
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
*
* XXX this should be totally redesigned after prop 271 too, and that's
* going to take some control spec work.
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
* */
int
getinfo_helper_entry_guards(control_connection_t *conn,
const char *question, char **answer,
const char **errmsg)
{
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
guard_selection_t *gs = get_guard_selection_info();
Refactor to always allocate chosen_entry_guards in new guard_selection_new() function
2016-10-14 02:15:30 +02:00
tor_assert(gs != NULL);
tor_assert(gs->chosen_entry_guards != NULL);
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
(void) conn;
(void) errmsg;
if (!strcmp(question,"entry-guards") ||
!strcmp(question,"helper-nodes")) {
smartlist_t *sl = smartlist_new();
char tbuf[ISO_TIME_LEN+1];
char nbuf[MAX_VERBOSE_NICKNAME_LEN+1];
Refactor to always allocate chosen_entry_guards in new guard_selection_new() function
2016-10-14 02:15:30 +02:00
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
const char *status = NULL;
time_t when = 0;
const node_t *node;
if (!e->made_contact) {
status = "never-connected";
} else if (e->bad_since) {
when = e->bad_since;
status = "unusable";
Control: getinfo entry-guards report down-since If the guard unreachable_since variable was set, the status "up" was reported which is wrong. This adds the "down" status followed by the unreachable_since time value. Fixes #14184 Signed-off-by: David Goulet <dgoulet@ev0ke.net>
2015-01-28 16:52:14 +01:00
} else if (e->unreachable_since) {
when = e->unreachable_since;
status = "down";
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
} else {
status = "up";
}
node = node_get_by_id(e->identity);
if (node) {
node_get_verbose_nickname(node, nbuf);
} else {
nbuf[0] = '$';
base16_encode(nbuf+1, sizeof(nbuf)-1, e->identity, DIGEST_LEN);
/* e->nickname field is not very reliable if we don't know about
* this router any longer; don't include it. */
}
if (when) {
format_iso_time(tbuf, when);
smartlist_add_asprintf(sl, "%s %s %s\n", nbuf, status, tbuf);
} else {
smartlist_add_asprintf(sl, "%s %s\n", nbuf, status);
}
} SMARTLIST_FOREACH_END(e);
*answer = smartlist_join_strings(sl, "", 0, NULL);
SMARTLIST_FOREACH(sl, char *, c, tor_free(c));
smartlist_free(sl);
}
return 0;
}
Calculate the guardfraction bandwidth of a guard.
2015-01-29 16:05:30 +01:00
/* Given the original bandwidth of a guard and its guardfraction,
* calculate how much bandwidth the guard should have as a guard and
* as a non-guard.
*
* Quoting from proposal236:
*
* Let Wpf denote the weight from the 'bandwidth-weights' line a
* client would apply to N for position p if it had the guard
* flag, Wpn the weight if it did not have the guard flag, and B the
* measured bandwidth of N in the consensus. Then instead of choosing
* N for position p proportionally to Wpf*B or Wpn*B, clients should
* choose N proportionally to F*Wpf*B + (1-F)*Wpn*B.
*
* This function fills the <b>guardfraction_bw</b> structure. It sets
* <b>guard_bw</b> to F*B and <b>non_guard_bw</b> to (1-F)*B.
*/
void
guard_get_guardfraction_bandwidth(guardfraction_bandwidth_t *guardfraction_bw,
int orig_bandwidth,
uint32_t guardfraction_percentage)
{
double guardfraction_fraction;
/* Turn the percentage into a fraction. */
tor_assert(guardfraction_percentage <= 100);
guardfraction_fraction = guardfraction_percentage / 100.0;
long guard_bw = tor_lround(guardfraction_fraction * orig_bandwidth);
tor_assert(guard_bw <= INT_MAX);
guardfraction_bw->guard_bw = (int) guard_bw;
Fix an implicit-narrowing warning
2015-02-18 15:34:15 +01:00
guardfraction_bw->non_guard_bw = orig_bandwidth - (int) guard_bw;
Calculate the guardfraction bandwidth of a guard.
2015-01-29 16:05:30 +01:00
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Returns true iff the node is used as a guard in the specified guard
* context */
int
is_node_used_as_guard_for_guard_selection(guard_selection_t *gs,
const node_t *node)
{
int res = 0;
/*
* We used to have a using_as_guard flag in node_t, but it had to go away
* to allow for multiple guard selection contexts. Instead, search the
* guard list for a matching digest.
*/
tor_assert(gs != NULL);
tor_assert(node != NULL);
SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e) {
Use tor_memeq() instead of tor_memcmp() per code review
2016-10-14 01:48:49 +02:00
if (tor_memeq(e->identity, node->identity, DIGEST_LEN)) {
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
res = 1;
break;
}
} SMARTLIST_FOREACH_END(e);
return res;
}
/** Returns true iff the node is used as a guard in the default guard
* context */
MOCK_IMPL(int,
is_node_used_as_guard, (const node_t *node))
{
return is_node_used_as_guard_for_guard_selection(
get_guard_selection_info(), node);
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/** Return 1 if we have at least one descriptor for an entry guard
* (bridge or member of EntryNodes) and all descriptors we know are
* down. Else return 0. If <b>act</b> is 1, then mark the down guards
* up; else just observe and report. */
static int
entries_retry_helper(const or_options_t *options, int act)
{
const node_t *node;
int any_known = 0;
int any_running = 0;
int need_bridges = options->UseBridges != 0;
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
guard_selection_t *gs = get_guard_selection_info();
Refactor to always allocate chosen_entry_guards in new guard_selection_new() function
2016-10-14 02:15:30 +02:00
tor_assert(gs != NULL);
tor_assert(gs->chosen_entry_guards != NULL);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
SMARTLIST_FOREACH_BEGIN(gs->chosen_entry_guards, entry_guard_t *, e) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
node = node_get_by_id(e->identity);
if (node && node_has_descriptor(node) &&
Only retry connecting to configured bridges After connectivity problems, only try connecting to bridges which are currently configured; don't mark bridges which we previously used but are no longer configured. Fixes 14216. Reported by and fix provided by arma.
2015-01-31 10:34:24 +01:00
node_is_bridge(node) == need_bridges &&
(!need_bridges || (!e->bad_since &&
node_is_a_configured_bridge(node)))) {
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
any_known = 1;
if (node->is_running)
any_running = 1; /* some entry is both known and running */
else if (act) {
/* Mark all current connections to this OR as unhealthy, since
* otherwise there could be one that started 30 seconds
* ago, and in 30 seconds it will time out, causing us to mark
* the node down and undermine the retry attempt. We mark even
* the established conns, since if the network just came back
* we'll want to attach circuits to fresh conns. */
connection_or_set_bad_connections(node->identity, 1);
/* mark this entry node for retry */
router_set_status(node->identity, 1);
e->can_retry = 1;
e->bad_since = 0;
}
}
} SMARTLIST_FOREACH_END(e);
log_debug(LD_DIR, "%d: any_known %d, any_running %d",
act, any_known, any_running);
return any_known && !any_running;
}
/** Do we know any descriptors for our bridges / entrynodes, and are
* all the ones we have descriptors for down? */
int
entries_known_but_down(const or_options_t *options)
{
tor_assert(entry_list_is_constrained(options));
return entries_retry_helper(options, 0);
}
/** Mark all down known bridges / entrynodes up. */
void
entries_retry_all(const or_options_t *options)
{
tor_assert(entry_list_is_constrained(options));
entries_retry_helper(options, 1);
}
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/** Free one guard selection context */
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
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
guard_selection_free(guard_selection_t *gs)
{
if (!gs) return;
if (gs->chosen_entry_guards) {
SMARTLIST_FOREACH(gs->chosen_entry_guards, entry_guard_t *, e,
entry_guard_free(e));
smartlist_free(gs->chosen_entry_guards);
gs->chosen_entry_guards = NULL;
}
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
if (gs->sampled_entry_guards) {
SMARTLIST_FOREACH(gs->sampled_entry_guards, entry_guard_t *, e,
entry_guard_free(e));
smartlist_free(gs->sampled_entry_guards);
gs->sampled_entry_guards = 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
smartlist_free(gs->confirmed_entry_guards);
smartlist_free(gs->primary_entry_guards);
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
tor_free(gs);
}
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
/** Release all storage held by the list of entry guards and related
* memory structs. */
void
entry_guards_free_all(void)
{
Abolish globals in entrynodes.c; relativize guard context to new guard_selection_t structure
2016-09-25 04:11:44 +02:00
/* Null out the default */
curr_guard_context = NULL;
/* Free all the guard contexts */
if (guard_contexts != NULL) {
SMARTLIST_FOREACH_BEGIN(guard_contexts, guard_selection_t *, gs) {
guard_selection_free(gs);
} SMARTLIST_FOREACH_END(gs);
smartlist_free(guard_contexts);
guard_contexts = NULL;
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
Separate mutable/const accessors for circuit_build_times (These have proved invaluable for other global accessors.)
2013-08-21 18:10:05 +02:00
circuit_build_times_free_timeouts(get_circuit_build_times_mutable());
Split code for entry guards and bridges into a new module.
2012-10-15 20:28:23 +02:00
}
Reference in New Issue Copy Permalink