src/or/directory.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-2017, The Tor Project, Inc. */
   5 /* See LICENSE for licensing information */
   6
   7 /**
   8  * \file directory.h
   9  * \brief Header file for directory.c.
  10  **/
  11
  12 #ifndef TOR_DIRECTORY_H
  13 #define TOR_DIRECTORY_H
  14
  15 int directories_have_accepted_server_descriptor(void);
  16 void directory_post_to_dirservers(uint8_t dir_purpose, uint8_t router_purpose,
  17                                   dirinfo_type_t type, const char *payload,
  18                                   size_t payload_len, size_t extrainfo_len);
  19 MOCK_DECL(void, directory_get_from_dirserver, (
  20                           uint8_t dir_purpose,
  21                           uint8_t router_purpose,
  22                           const char *resource,
  23                           int pds_flags,
  24                           download_want_authority_t want_authority));
  25 void directory_get_from_all_authorities(uint8_t dir_purpose,
  26                                         uint8_t router_purpose,
  27                                         const char *resource);
  28
  29 /** Enumeration of ways to connect to a directory server */
  30 typedef enum {
  31   /** Default: connect over a one-hop Tor circuit. Relays fall back to direct
  32    * DirPort connections, clients, onion services, and bridges do not */
  33   DIRIND_ONEHOP=0,
  34   /** Connect over a multi-hop anonymizing Tor circuit */
  35   DIRIND_ANONYMOUS=1,
  36   /** Connect to the DirPort directly */
  37   DIRIND_DIRECT_CONN,
  38   /** Connect over a multi-hop anonymizing Tor circuit to our dirport */
  39   DIRIND_ANON_DIRPORT,
  40 } dir_indirection_t;
  41
  42 int directory_must_use_begindir(const or_options_t *options);
  43
  44 /**
  45  * A directory_request_t describes the information about a directory request
  46  * at the client side.  It describes what we're going to ask for, which
  47  * directory we're going to ask for it, how we're going to contact that
  48  * directory, and (in some cases) what to do with it when we're done.
  49  */
  50 typedef struct directory_request_t directory_request_t;
  51 directory_request_t *directory_request_new(uint8_t dir_purpose);
  52 void directory_request_free(directory_request_t *req);
  53 void directory_request_set_or_addr_port(directory_request_t *req,
  54                                         const tor_addr_port_t *p);
  55 void directory_request_set_dir_addr_port(directory_request_t *req,
  56                                          const tor_addr_port_t *p);
  57 void directory_request_set_directory_id_digest(directory_request_t *req,
  58                                                const char *digest);
  59 void directory_request_set_guard_state(directory_request_t *req,
  60                                        struct circuit_guard_state_t *state);
  61 void directory_request_set_router_purpose(directory_request_t *req,
  62                                           uint8_t router_purpose);
  63 void directory_request_set_indirection(directory_request_t *req,
  64                                        dir_indirection_t indirection);
  65 void directory_request_set_resource(directory_request_t *req,
  66                                     const char *resource);
  67 void directory_request_set_payload(directory_request_t *req,
  68                                    const char *payload,
  69                                    size_t payload_len);
  70 void directory_request_set_if_modified_since(directory_request_t *req,
  71                                              time_t if_modified_since);
  72 void directory_request_set_rend_query(directory_request_t *req,
  73                                       const rend_data_t *query);
  74
  75 void directory_request_set_routerstatus(directory_request_t *req,
  76                                         const routerstatus_t *rs);
  77 void directory_request_add_header(directory_request_t *req,
  78                                   const char *key,
  79                                   const char *val);
  80 MOCK_DECL(void, directory_initiate_request, (directory_request_t *request));
  81
  82 int parse_http_response(const char *headers, int *code, time_t *date,
  83                         compress_method_t *compression, char **response);
  84
  85 int connection_dir_is_encrypted(const dir_connection_t *conn);
  86 int connection_dir_reached_eof(dir_connection_t *conn);
  87 int connection_dir_process_inbuf(dir_connection_t *conn);
  88 int connection_dir_finished_flushing(dir_connection_t *conn);
  89 int connection_dir_finished_connecting(dir_connection_t *conn);
  90 void connection_dir_about_to_close(dir_connection_t *dir_conn);
  91
  92 #define DSR_HEX       (1<<0)
  93 #define DSR_BASE64    (1<<1)
  94 #define DSR_DIGEST256 (1<<2)
  95 #define DSR_SORT_UNIQ (1<<3)
  96 int dir_split_resource_into_fingerprints(const char *resource,
  97                                      smartlist_t *fp_out, int *compressed_out,
  98                                      int flags);
  99 enum dir_spool_source_t;
 100 int dir_split_resource_into_spoolable(const char *resource,
 101                                       enum dir_spool_source_t source,
 102                                       smartlist_t *spool_out,
 103                                       int *compressed_out,
 104                                       int flags);
 105 int dir_split_resource_into_fingerprint_pairs(const char *res,
 106                                               smartlist_t *pairs_out);
 107 char *directory_dump_request_log(void);
 108 void note_request(const char *key, size_t bytes);
 109 int router_supports_extrainfo(const char *identity_digest, int is_authority);
 110
 111 time_t download_status_increment_failure(download_status_t *dls,
 112                                          int status_code, const char *item,
 113                                          int server, time_t now);
 114 time_t download_status_increment_attempt(download_status_t *dls,
 115                                          const char *item,  time_t now);
 116 /** Increment the failure count of the download_status_t <b>dls</b>, with
 117  * the optional status code <b>sc</b>. */
 118 #define download_status_failed(dls, sc)                                 \
 119   download_status_increment_failure((dls), (sc), NULL,                  \
 120                                     dir_server_mode(get_options()), \
 121                                     time(NULL))
 122
 123 void download_status_reset(download_status_t *dls);
 124 static int download_status_is_ready(download_status_t *dls, time_t now,
 125                                     int max_failures);
 126 /** Return true iff, as of <b>now</b>, the resource tracked by <b>dls</b> is
 127  * ready to get its download reattempted. */
 128 static inline int
 129 download_status_is_ready(download_status_t *dls, time_t now,
 130                          int max_failures)
 131 {
 132   if (dls->backoff == DL_SCHED_DETERMINISTIC) {
 133     /* Deterministic schedules can hit an endpoint; exponential backoff
 134      * schedules just wait longer and longer. */
 135     int under_failure_limit = (dls->n_download_failures <= max_failures
 136                                && dls->n_download_attempts <= max_failures);
 137     if (!under_failure_limit)
 138       return 0;
 139   }
 140   return dls->next_attempt_at <= now;
 141 }
 142
 143 static void download_status_mark_impossible(download_status_t *dl);
 144 /** Mark <b>dl</b> as never downloadable. */
 145 static inline void
 146 download_status_mark_impossible(download_status_t *dl)
 147 {
 148   dl->n_download_failures = IMPOSSIBLE_TO_DOWNLOAD;
 149   dl->n_download_attempts = IMPOSSIBLE_TO_DOWNLOAD;
 150 }
 151
 152 int download_status_get_n_failures(const download_status_t *dls);
 153 int download_status_get_n_attempts(const download_status_t *dls);
 154 time_t download_status_get_next_attempt_at(const download_status_t *dls);
 155
 156 int purpose_needs_anonymity(uint8_t dir_purpose, uint8_t router_purpose,
 157                             const char *resource);
 158
 159 #ifdef DIRECTORY_PRIVATE
 160
 161 struct get_handler_args_t;
 162 STATIC int handle_get_hs_descriptor_v3(dir_connection_t *conn,
 163                                        const struct get_handler_args_t *args);
 164 STATIC int directory_handle_command(dir_connection_t *conn);
 165 STATIC char *accept_encoding_header(void);
 166 STATIC int allowed_anonymous_connection_compression_method(compress_method_t);
 167 STATIC void warn_disallowed_anonymous_compression_method(compress_method_t);
 168
 169 #endif
 170
 171 #ifdef TOR_UNIT_TESTS
 172 /* Used only by test_dir.c */
 173
 174 STATIC int parse_http_url(const char *headers, char **url);
 175 STATIC dirinfo_type_t dir_fetch_type(int dir_purpose, int router_purpose,
 176                                      const char *resource);
 177 MOCK_DECL(STATIC int, directory_handle_command_get,(dir_connection_t *conn,
 178                                                     const char *headers,
 179                                                     const char *req_body,
 180                                                     size_t req_body_len));
 181 MOCK_DECL(STATIC int, directory_handle_command_post,(dir_connection_t *conn,
 182                                                      const char *headers,
 183                                                      const char *body,
 184                                                      size_t body_len));
 185 STATIC int download_status_schedule_get_delay(download_status_t *dls,
 186                                               const smartlist_t *schedule,
 187                                               int min_delay, int max_delay,
 188                                               time_t now);
 189
 190 STATIC int handle_post_hs_descriptor(const char *url, const char *body);
 191
 192 STATIC char* authdir_type_to_string(dirinfo_type_t auth);
 193 STATIC const char * dir_conn_purpose_to_string(int purpose);
 194 STATIC int should_use_directory_guards(const or_options_t *options);
 195 STATIC compression_level_t choose_compression_level(ssize_t n_bytes);
 196 STATIC const smartlist_t *find_dl_schedule(download_status_t *dls,
 197                                            const or_options_t *options);
 198 STATIC void find_dl_min_and_max_delay(download_status_t *dls,
 199                                       const or_options_t *options,
 200                                       int *min, int *max);
 201 STATIC int next_random_exponential_delay(int delay, int max_delay);
 202
 203 STATIC int parse_hs_version_from_post(const char *url, const char *prefix,
 204                                       const char **end_pos);
 205
 206 STATIC unsigned parse_accept_encoding_header(const char *h);
 207 #endif
 208
 209 #endif
 210