config.h 13.3 KB
Newer Older
Sebastian Hahn's avatar
Sebastian Hahn committed
1
2
3
/* Copyright (c) 2001 Matej Pfajfar.
 * Copyright (c) 2001-2004, Roger Dingledine.
 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
4
 * Copyright (c) 2007-2020, The Tor Project, Inc. */
Sebastian Hahn's avatar
Sebastian Hahn committed
5
6
7
8
9
10
11
/* See LICENSE for licensing information */

/**
 * \file config.h
 * \brief Header file for config.c.
 **/

12
13
#ifndef TOR_CONFIG_H
#define TOR_CONFIG_H
Sebastian Hahn's avatar
Sebastian Hahn committed
14

15
#include "app/config/or_options_st.h"
16
#include "lib/testsupport/testsupport.h"
Nick Mathewson's avatar
Nick Mathewson committed
17
#include "app/config/quiet_level.h"
18

19
20
21
22
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(DARWIN)
#define KERNEL_MAY_SUPPORT_IPFW
#endif

23
24
25
26
/** Lowest allowable value for HeartbeatPeriod; if this is too low, we might
 * expose more information than we're comfortable with. */
#define MIN_HEARTBEAT_PERIOD (30*60)

27
28
/** Maximum default value for MaxMemInQueues, in bytes. */
#if SIZEOF_VOID_P >= 8
29
#define MAX_DEFAULT_MEMORY_QUEUE_SIZE (UINT64_C(8) << 30)
30
#else
31
#define MAX_DEFAULT_MEMORY_QUEUE_SIZE (UINT64_C(2) << 30)
32
33
#endif

34
MOCK_DECL(const or_options_t *, get_options, (void));
Ola Bini's avatar
Ola Bini committed
35
MOCK_DECL(or_options_t *, get_options_mutable, (void));
Sebastian Hahn's avatar
Sebastian Hahn committed
36
37
38
39
40
41
int set_options(or_options_t *new_val, char **msg);
void config_free_all(void);
const char *safe_str_client(const char *address);
const char *safe_str(const char *address);
const char *escaped_safe_str_client(const char *address);
const char *escaped_safe_str(const char *address);
42
void init_protocol_warning_severity_level(void);
43
int get_protocol_warning_severity_level(void);
44

teor's avatar
teor committed
45
46
#define LOG_PROTOCOL_WARN (get_protocol_warning_severity_level())

47
48
49
50
51
52
53
54
/** An error from options_trial_assign() or options_init_from_string(). */
typedef enum setopt_err_t {
  SETOPT_OK = 0,
  SETOPT_ERR_MISC = -1,
  SETOPT_ERR_PARSE = -2,
  SETOPT_ERR_TRANSITION = -3,
  SETOPT_ERR_SETTING = -4,
} setopt_err_t;
55
setopt_err_t options_trial_assign(struct config_line_t *list, unsigned flags,
56
                                  char **msg);
57

Sebastian Hahn's avatar
Sebastian Hahn committed
58
void options_init(or_options_t *options);
59
60
61
62
63

#define OPTIONS_DUMP_MINIMAL 1
#define OPTIONS_DUMP_DEFAULTS 2
#define OPTIONS_DUMP_ALL 3
char *options_dump(const or_options_t *options, int how_to_dump);
Sebastian Hahn's avatar
Sebastian Hahn committed
64
int options_init_from_torrc(int argc, char **argv);
65
setopt_err_t options_init_from_string(const char *cf_defaults, const char *cf,
Sebastian Hahn's avatar
Sebastian Hahn committed
66
67
68
                            int command, const char *command_arg, char **msg);
int option_is_recognized(const char *key);
const char *option_get_canonical_name(const char *key);
69
struct config_line_t *option_get_assignment(const or_options_t *options,
Sebastian Hahn's avatar
Sebastian Hahn committed
70
71
                                     const char *key);
int options_save_current(void);
72
const char *get_torrc_fname(int defaults_fname);
73
74
75
76
77
78
typedef enum {
  DIRROOT_DATADIR,
  DIRROOT_CACHEDIR,
  DIRROOT_KEYDIR
} directory_root_t;

79
MOCK_DECL(char *,
80
          options_get_dir_fname2_suffix,
81
          (const or_options_t *options,
82
           directory_root_t roottype,
83
84
           const char *sub1, const char *sub2,
           const char *suffix));
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

/* These macros wrap options_get_dir_fname2_suffix to provide a more
 * convenient API for finding filenames that Tor uses inside its storage
 * They are named according to a pattern:
 *    (options_)?get_(cache|key|data)dir_fname(2)?(_suffix)?
 *
 * Macros that begin with options_ take an options argument; the others
 * work with respect to the global options.
 *
 * Each macro works relative to the data directory, the key directory,
 * or the cache directory, as determined by which one is mentioned.
 *
 * Macro variants with "2" in their name take two path components; others
 * take one.
 *
 * Macro variants with "_suffix" at the end take an additional suffix
 * that gets appended to the end of the file
 */
#define options_get_datadir_fname2_suffix(options, sub1, sub2, suffix) \
  options_get_dir_fname2_suffix((options), DIRROOT_DATADIR, \
                                (sub1), (sub2), (suffix))
#define options_get_cachedir_fname2_suffix(options, sub1, sub2, suffix) \
  options_get_dir_fname2_suffix((options), DIRROOT_CACHEDIR, \
                                (sub1), (sub2), (suffix))
#define options_get_keydir_fname2_suffix(options, sub1, sub2, suffix) \
  options_get_dir_fname2_suffix((options), DIRROOT_KEYDIR, \
                                (sub1), (sub2), (suffix))

#define options_get_datadir_fname(opts,sub1)                    \
  options_get_datadir_fname2_suffix((opts),(sub1), NULL, NULL)
#define options_get_datadir_fname2(opts,sub1,sub2)                      \
  options_get_datadir_fname2_suffix((opts),(sub1), (sub2), NULL)

Sebastian Hahn's avatar
Sebastian Hahn committed
118
119
#define get_datadir_fname2_suffix(sub1, sub2, suffix) \
  options_get_datadir_fname2_suffix(get_options(), (sub1), (sub2), (suffix))
120
121
#define get_datadir_fname(sub1)                 \
  get_datadir_fname2_suffix((sub1), NULL, NULL)
Sebastian Hahn's avatar
Sebastian Hahn committed
122
123
#define get_datadir_fname2(sub1,sub2) \
  get_datadir_fname2_suffix((sub1), (sub2), NULL)
124
125
126
127
128
#define get_datadir_fname_suffix(sub1, suffix) \
  get_datadir_fname2_suffix((sub1), NULL, (suffix))

/** DOCDOC */
#define options_get_keydir_fname(options, sub1)  \
129
  options_get_keydir_fname2_suffix((options), (sub1), NULL, NULL)
130
#define get_keydir_fname_suffix(sub1, suffix)   \
131
132
133
  options_get_keydir_fname2_suffix(get_options(), (sub1), NULL, suffix)
#define get_keydir_fname(sub1)                  \
  options_get_keydir_fname2_suffix(get_options(), (sub1), NULL, NULL)
134

135
136
#define get_cachedir_fname(sub1) \
  options_get_cachedir_fname2_suffix(get_options(), (sub1), NULL, NULL)
137
#define get_cachedir_fname_suffix(sub1, suffix) \
138
  options_get_cachedir_fname2_suffix(get_options(), (sub1), NULL, (suffix))
Sebastian Hahn's avatar
Sebastian Hahn committed
139

140
141
142
143
144
145
146
147
148
149
#define safe_str_client(address) \
  safe_str_client_opts(NULL, address)
#define safe_str(address) \
  safe_str_opts(NULL, address)

const char * safe_str_client_opts(const or_options_t *options,
                                  const char *address);
const char * safe_str_opts(const or_options_t *options,
                           const char *address);

Nick Mathewson's avatar
Nick Mathewson committed
150
int using_default_dir_authorities(const or_options_t *options);
151

152
153
int create_keys_directory(const or_options_t *options);

154
155
156
157
int check_or_create_data_subdir(const char *subdir);
int write_to_data_subdir(const char* subdir, const char* fname,
                         const char* str, const char* descr);

158
159
int get_num_cpus(const or_options_t *options);

160
MOCK_DECL(const smartlist_t *,get_configured_ports,(void));
161
162
int port_binds_ipv4(const port_cfg_t *port);
int port_binds_ipv6(const port_cfg_t *port);
Linus Nordberg's avatar
Linus Nordberg committed
163
164
int get_first_advertised_port_by_type_af(int listener_type,
                                         int address_family);
165
#define get_primary_or_port() \
166
  (get_first_advertised_port_by_type_af(CONN_TYPE_OR_LISTENER, AF_INET))
167
#define get_primary_dir_port() \
168
  (get_first_advertised_port_by_type_af(CONN_TYPE_DIR_LISTENER, AF_INET))
169
170
171
172
173
174
const tor_addr_t *get_first_advertised_addr_by_type_af(int listener_type,
                                                       int address_family);
int port_exists_by_type_addr_port(int listener_type, const tor_addr_t *addr,
                                  int port, int check_wildcard);
int port_exists_by_type_addr32h_port(int listener_type, uint32_t addr_ipv4h,
                                     int port, int check_wildcard);
175

George Kadianakis's avatar
George Kadianakis committed
176
char *get_first_listener_addrport_string(int listener_type);
177

178
179
int options_need_geoip_info(const or_options_t *options,
                            const char **reason_out);
180

Sebastian Hahn's avatar
Sebastian Hahn committed
181
182
183
184
int getinfo_helper_config(control_connection_t *conn,
                          const char *question, char **answer,
                          const char **errmsg);

185
int init_cookie_authentication(const char *fname, const char *header,
186
                               int cookie_len, int group_readable,
187
188
                               uint8_t **cookie_out, int *cookie_is_set_out);

Sebastian Hahn's avatar
Sebastian Hahn committed
189
190
or_options_t *options_new(void);

191
192
193
194
195
196
197
/** Options settings parsed from the command-line. */
typedef struct {
  /** List of options that can only be set from the command-line */
  struct config_line_t *cmdline_opts;
  /** List of other options, to be handled by the general Tor configuration
      system. */
  struct config_line_t *other_opts;
198
199
200
201
  /** Subcommand that Tor has been told to run */
  tor_cmdline_mode_t command;
  /** Argument for the command mode, if any. */
  const char *command_arg;
Nick Mathewson's avatar
Nick Mathewson committed
202
203
  /** How quiet have we been told to be? */
  quiet_level_t quiet_level;
204
205
206
207
208
209
210
} parsed_cmdline_t;

parsed_cmdline_t *config_parse_commandline(int argc, char **argv,
                                           int ignore_errors);
void parsed_cmdline_free_(parsed_cmdline_t *cmdline);
#define parsed_cmdline_free(c) \
  FREE_AND_NULL(parsed_cmdline_t, parsed_cmdline_free_, (c))
211

212
void config_register_addressmaps(const or_options_t *options);
213
/* XXXX move to connection_edge.h */
214
215
216
217
int addressmap_register_auto(const char *from, const char *to,
                             time_t expires,
                             addressmap_entry_source_t addrmap_source,
                             const char **msg);
218
219
220
221
222

int port_cfg_line_extract_addrport(const char *line,
                                   char **addrport_out,
                                   int *is_unix_out,
                                   const char **rest_out);
223

224
225
226
227
228
229
230
/** Represents the information stored in a torrc Bridge line. */
typedef struct bridge_line_t {
  tor_addr_t addr; /* The IP address of the bridge. */
  uint16_t port; /* The TCP port of the bridge. */
  char *transport_name; /* The name of the pluggable transport that
                           should be used to connect to the bridge. */
  char digest[DIGEST_LEN]; /* The bridge's identity key digest. */
231
  smartlist_t *socks_args; /* SOCKS arguments for the pluggable
232
233
234
                               transport proxy. */
} bridge_line_t;

235
void bridge_line_free_(bridge_line_t *bridge_line);
236
237
#define bridge_line_free(line) \
  FREE_AND_NULL(bridge_line_t, bridge_line_free_, (line))
238
239
bridge_line_t *parse_bridge_line(const char *line);

240
241
/* Port helper functions. */
int options_any_client_port_set(const or_options_t *options);
242
int port_parse_config(smartlist_t *out,
243
244
245
246
247
248
                      const struct config_line_t *ports,
                      const char *portname,
                      int listener_type,
                      const char *defaultaddr,
                      int defaultport,
                      const unsigned flags);
249
250
251

#define CL_PORT_NO_STREAM_OPTIONS (1u<<0)
#define CL_PORT_WARN_NONLOCAL (1u<<1)
252
/* Was CL_PORT_ALLOW_EXTRA_LISTENADDR (1u<<2) */
253
254
255
256
257
258
#define CL_PORT_SERVER_OPTIONS (1u<<3)
#define CL_PORT_FORBID_NONLOCAL (1u<<4)
#define CL_PORT_TAKES_HOSTNAMES (1u<<5)
#define CL_PORT_IS_UNIXSOCKET (1u<<6)
#define CL_PORT_DFLT_GROUP_WRITABLE (1u<<7)

259
260
261
262
263
port_cfg_t *port_cfg_new(size_t namelen);
#define port_cfg_free(port) \
  FREE_AND_NULL(port_cfg_t, port_cfg_free_, (port))
void port_cfg_free_(port_cfg_t *port);

264
int port_count_real_listeners(const smartlist_t *ports,
265
266
                         int listenertype,
                         int count_sockets);
267
int pt_parse_transport_line(const or_options_t *options,
268
269
                         const char *line, int validate_only,
                         int server);
270
int config_ensure_bandwidth_cap(uint64_t *value, const char *desc, char **msg);
271
272
273

#ifdef CONFIG_PRIVATE

274
275
276
MOCK_DECL(STATIC int, options_act,(const or_options_t *old_options));
MOCK_DECL(STATIC int, options_act_reversible,(const or_options_t *old_options,
                                             char **msg));
277
278
struct config_mgr_t;
STATIC const struct config_mgr_t *get_options_mgr(void);
279

280
281
282
#define or_options_free(opt) \
  FREE_AND_NULL(or_options_t, or_options_free_, (opt))
STATIC void or_options_free_(or_options_t *options);
283
284
STATIC int options_validate_single_onion(or_options_t *options,
                                         char **msg);
285
286
STATIC int parse_tcp_proxy_line(const char *line, or_options_t *options,
                                char **msg);
287
288
STATIC int consider_adding_dir_servers(const or_options_t *options,
                                       const or_options_t *old_options);
289
STATIC void add_default_trusted_dir_authorities(dirinfo_type_t type);
290
MOCK_DECL(STATIC void, add_default_fallback_dir_servers, (void));
291
292
293
294
STATIC int parse_dir_authority_line(const char *line,
                                    dirinfo_type_t required_type,
                                    int validate_only);
STATIC int parse_dir_fallback_line(const char *line, int validate_only);
295
296

STATIC uint64_t compute_real_max_mem_in_queues(const uint64_t val,
297
                                               bool is_server);
298
299
300
STATIC int open_and_add_file_log(const log_severity_list_t *severity,
                                 const char *fname,
                                 int truncate_log);
301
STATIC int options_init_logs(const or_options_t *old_options,
302
                             const or_options_t *options, int validate_only);
303

304
STATIC int options_create_directories(char **msg_out);
305
306
307
308
309
310
struct log_transaction_t;
STATIC struct log_transaction_t *options_start_log_transaction(
                              const or_options_t *old_options,
                              char **msg_out);
STATIC void options_commit_log_transaction(struct log_transaction_t *xn);
STATIC void options_rollback_log_transaction(struct log_transaction_t *xn);
311

312
313
314
315
316
317
#ifdef TOR_UNIT_TESTS
int options_validate(const or_options_t *old_options,
                     or_options_t *options,
                     char **msg);
#endif

318
319
320
321
STATIC int parse_ports(or_options_t *options, int validate_only,
                       char **msg, int *n_ports_out,
                       int *world_writable_control_socket);

322
#endif /* defined(CONFIG_PRIVATE) */
323

324
#endif /* !defined(TOR_CONFIG_H) */