src/or/entrynodes.h

   1 /* Copyright (c) 2001 Matej Pfajfar.
   2  * Copyright (c) 2001-2004, Roger Dingledine.
   3  * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
   4  * Copyright (c) 2007-2016, The Tor Project, Inc. */
   5 /* See LICENSE for licensing information */
   6
   7 /**
   8  * \file entrynodes.h
   9  * \brief Header file for circuitbuild.c.
  10  **/
  11
  12 #ifndef TOR_ENTRYNODES_H
  13 #define TOR_ENTRYNODES_H
  14
  15 #if 1
  16 /* XXXX NM I would prefer that all of this stuff be private to
  17  * entrynodes.c. */
  18
  19 /** An entry_guard_t represents our information about a chosen long-term
  20  * first hop, known as a "helper" node in the literature. We can't just
  21  * use a node_t, since we want to remember these even when we
  22  * don't have any directory info. */
  23 typedef struct entry_guard_t {
  24   char nickname[MAX_NICKNAME_LEN+1];
  25   char identity[DIGEST_LEN];
  26   time_t chosen_on_date; /**< Approximately when was this guard added?
  27                           * "0" if we don't know. */
  28   char *chosen_by_version; /**< What tor version added this guard? NULL
  29                             * if we don't know. */
  30   unsigned int made_contact : 1; /**< 0 if we have never connected to this
  31                                   * router, 1 if we have. */
  32   unsigned int can_retry : 1; /**< Should we retry connecting to this entry,
  33                                * in spite of having it marked as unreachable?*/
  34   unsigned int path_bias_noticed : 1; /**< Did we alert the user about path
  35                                        * bias for this node already? */
  36   unsigned int path_bias_warned : 1; /**< Did we alert the user about path bias
  37                                       * for this node already? */
  38   unsigned int path_bias_extreme : 1; /**< Did we alert the user about path
  39                                        * bias for this node already? */
  40   unsigned int path_bias_disabled : 1; /**< Have we disabled this node because
  41                                         * of path bias issues? */
  42   unsigned int path_bias_use_noticed : 1; /**< Did we alert the user about path
  43                                        * use bias for this node already? */
  44   unsigned int path_bias_use_extreme : 1; /**< Did we alert the user about path
  45                                        * use bias for this node already? */
  46   unsigned int is_dir_cache : 1; /**< Is this node a directory cache? */
  47   time_t bad_since; /**< 0 if this guard is currently usable, or the time at
  48                       * which it was observed to become (according to the
  49                       * directory or the user configuration) unusable. */
  50   time_t unreachable_since; /**< 0 if we can connect to this guard, or the
  51                              * time at which we first noticed we couldn't
  52                              * connect to it. */
  53   time_t last_attempted; /**< 0 if we can connect to this guard, or the time
  54                           * at which we last failed to connect to it. */
  55
  56   double circ_attempts; /**< Number of circuits this guard has "attempted" */
  57   double circ_successes; /**< Number of successfully built circuits using
  58                                * this guard as first hop. */
  59   double successful_circuits_closed; /**< Number of circuits that carried
  60                                         * streams successfully. */
  61   double collapsed_circuits; /**< Number of fully built circuits that were
  62                                  * remotely closed before any streams were
  63                                  * attempted. */
  64   double unusable_circuits; /**< Number of circuits for which streams were
  65                                 *  attempted, but none succeeded. */
  66   double timeouts; /**< Number of 'right-censored' circuit timeouts for this
  67                        * guard. */
  68   double use_attempts; /**< Number of circuits we tried to use with streams */
  69   double use_successes; /**< Number of successfully used circuits using
  70                                * this guard as first hop. */
  71 } entry_guard_t;
  72
  73 entry_guard_t *entry_guard_get_by_id_digest(const char *digest);
  74 void entry_guards_changed(void);
  75 const smartlist_t *get_entry_guards(void);
  76 int num_live_entry_guards(int for_directory);
  77
  78 #endif
  79
  80 #ifdef ENTRYNODES_PRIVATE
  81 STATIC const node_t *add_an_entry_guard(const node_t *chosen,
  82                                         int reset_status, int prepend,
  83                                         int for_discovery, int for_directory);
  84
  85 STATIC int populate_live_entry_guards(smartlist_t *live_entry_guards,
  86                                       const smartlist_t *all_entry_guards,
  87                                       const node_t *chosen_exit,
  88                                       dirinfo_type_t dirinfo_type,
  89                                       int for_directory,
  90                                       int need_uptime, int need_capacity);
  91 STATIC int decide_num_guards(const or_options_t *options, int for_directory);
  92
  93 STATIC void entry_guards_set_from_config(const or_options_t *options);
  94
  95 /** Flags to be passed to entry_is_live() to indicate what kind of
  96  * entry nodes we are looking for. */
  97 typedef enum {
  98   ENTRY_NEED_UPTIME = 1<<0,
  99   ENTRY_NEED_CAPACITY = 1<<1,
 100   ENTRY_ASSUME_REACHABLE = 1<<2,
 101   ENTRY_NEED_DESCRIPTOR = 1<<3,
 102 } entry_is_live_flags_t;
 103
 104 STATIC const node_t *entry_is_live(const entry_guard_t *e,
 105                                    entry_is_live_flags_t flags,
 106                                    const char **msg);
 107
 108 STATIC int entry_is_time_to_retry(const entry_guard_t *e, time_t now);
 109
 110 #endif
 111
 112 void remove_all_entry_guards(void);
 113
 114 void entry_guards_compute_status(const or_options_t *options, time_t now);
 115 int entry_guard_register_connect_status(const char *digest, int succeeded,
 116                                         int mark_relay_status, time_t now);
 117 void entry_nodes_should_be_added(void);
 118 int entry_list_is_constrained(const or_options_t *options);
 119 const node_t *choose_random_entry(cpath_build_state_t *state);
 120 const node_t *choose_random_dirguard(dirinfo_type_t t);
 121 int entry_guards_parse_state(or_state_t *state, int set, char **msg);
 122 void entry_guards_update_state(or_state_t *state);
 123 int getinfo_helper_entry_guards(control_connection_t *conn,
 124                                 const char *question, char **answer,
 125                                 const char **errmsg);
 126
 127 void mark_bridge_list(void);
 128 void sweep_bridge_list(void);
 129
 130 int addr_is_a_configured_bridge(const tor_addr_t *addr, uint16_t port,
 131                                 const char *digest);
 132 int extend_info_is_a_configured_bridge(const extend_info_t *ei);
 133 int routerinfo_is_a_configured_bridge(const routerinfo_t *ri);
 134 int node_is_a_configured_bridge(const node_t *node);
 135 void learned_router_identity(const tor_addr_t *addr, uint16_t port,
 136                              const char *digest);
 137 struct bridge_line_t;
 138 void bridge_add_from_config(struct bridge_line_t *bridge_line);
 139 void retry_bridge_descriptor_fetch_directly(const char *digest);
 140 void fetch_bridge_descriptors(const or_options_t *options, time_t now);
 141 void learned_bridge_descriptor(routerinfo_t *ri, int from_cache);
 142 int any_bridge_descriptors_known(void);
 143 int entries_known_but_down(const or_options_t *options);
 144 void entries_retry_all(const or_options_t *options);
 145
 146 int any_bridge_supports_microdescriptors(void);
 147 const smartlist_t *get_socks_args_by_bridge_addrport(const tor_addr_t *addr,
 148                                                      uint16_t port);
 149
 150 int any_bridges_dont_support_microdescriptors(void);
 151
 152 void entry_guards_free_all(void);
 153
 154 const char *find_transport_name_by_bridge_addrport(const tor_addr_t *addr,
 155                                                    uint16_t port);
 156 struct transport_t;
 157 int get_transport_by_bridge_addrport(const tor_addr_t *addr, uint16_t port,
 158                                       const struct transport_t **transport);
 159
 160 MOCK_DECL(int, transport_is_needed, (const char *transport_name));
 161 int validate_pluggable_transports_config(void);
 162
 163 double pathbias_get_close_success_count(entry_guard_t *guard);
 164 double pathbias_get_use_success_count(entry_guard_t *guard);
 165
 166 /** Contains the bandwidth of a relay as a guard and as a non-guard
 167  *  after the guardfraction has been considered. */
 168 typedef struct guardfraction_bandwidth_t {
 169   /** Bandwidth as a guard after guardfraction has been considered. */
 170   int guard_bw;
 171   /** Bandwidth as a non-guard after guardfraction has been considered. */
 172   int non_guard_bw;
 173 } guardfraction_bandwidth_t;
 174
 175 int should_apply_guardfraction(const networkstatus_t *ns);
 176
 177 void
 178 guard_get_guardfraction_bandwidth(guardfraction_bandwidth_t *guardfraction_bw,
 179                                   int orig_bandwidth,
 180                                   uint32_t guardfraction_percentage);
 181
 182 MOCK_DECL(smartlist_t *, list_bridge_identities, (void));
 183 MOCK_DECL(download_status_t *, get_bridge_dl_status_by_id,
 184           (const char *digest));
 185
 186 #endif
 187