config.c 33.2 KB
Newer Older
1
/* Copyright 2001,2002,2003 Roger Dingledine, Matej Pfajfar. */
2
3
4
/* See LICENSE for licensing information */
/* $Id$ */

Nick Mathewson's avatar
Nick Mathewson committed
5
6
7
8
9
10
11
/**
 * /file config.c
 *
 * /brief Code to parse and interpret configuration files.
 *
 **/

Roger Dingledine's avatar
Roger Dingledine committed
12
#include "or.h"
13
14
15
#ifdef MS_WINDOWS
#include <shlobj.h>
#endif
Roger Dingledine's avatar
Roger Dingledine committed
16

Nick Mathewson's avatar
Nick Mathewson committed
17
18
19
/** Enumeration of types which option values can take */
typedef enum config_type_t {
  CONFIG_TYPE_STRING = 0, /**< An arbitrary string. */
20
  CONFIG_TYPE_UINT, /**< A non-negative integer less than MAX_INT */
Nick Mathewson's avatar
Nick Mathewson committed
21
22
  CONFIG_TYPE_DOUBLE, /**< A floating-point value */
  CONFIG_TYPE_BOOL, /**< A boolean value, expressed as 0 or 1. */
23
24
  CONFIG_TYPE_CSV, /**< A list of strings, separated by commas and optional
                    * whitespace. */
Nick Mathewson's avatar
Nick Mathewson committed
25
  CONFIG_TYPE_LINELIST, /**< Uninterpreted config lines */
26
  CONFIG_TYPE_OBSOLETE, /**< Obsolete (ignored) option. */
Nick Mathewson's avatar
Nick Mathewson committed
27
} config_type_t;
28

Nick Mathewson's avatar
Nick Mathewson committed
29
/** Largest allowed config line */
30
#define CONFIG_LINE_T_MAXLEN 4096
31

32
static struct config_line_t *config_get_commandlines(int argc, char **argv);
33
static int config_get_lines(FILE *f, struct config_line_t **result);
34
static void config_free_lines(struct config_line_t *front);
35
static int config_compare(struct config_line_t *c, const char *key, config_type_t type, void *arg);
36
static int config_assign(or_options_t *options, struct config_line_t *list);
37
static int parse_dir_server_line(const char *line);
38

Nick Mathewson's avatar
Nick Mathewson committed
39
/** Helper: Read a list of configuration options from the command line. */
40
41
42
static struct config_line_t *config_get_commandlines(int argc, char **argv) {
  struct config_line_t *new;
  struct config_line_t *front = NULL;
43
44
45
  char *s;
  int i = 1;

Roger Dingledine's avatar
Roger Dingledine committed
46
  while(i < argc-1) {
47
48
49
50
51
52
    if(!strcmp(argv[i],"-f")) {
//      log(LOG_DEBUG,"Commandline: skipping over -f.");
      i+=2; /* this is the config file option. ignore it. */
      continue;
    }

53
    new = tor_malloc(sizeof(struct config_line_t));
54
55
56
    s = argv[i];
    while(*s == '-')
      s++;
57
58
    new->key = tor_strdup(s);
    new->value = tor_strdup(argv[i+1]);
59
60
61
62
63
64
65
66
67
68

    log(LOG_DEBUG,"Commandline: parsed keyword '%s', value '%s'",
      new->key, new->value);
    new->next = front;
    front = new;
    i += 2;
  }
  return front;
}

Nick Mathewson's avatar
Nick Mathewson committed
69
70
/** Helper: allocate a new configuration option mapping 'key' to 'val',
 * prepend it to 'front', and return the newly allocated config_line_t */
71
72
73
74
75
76
77
78
79
80
81
82
83
static struct config_line_t *
config_line_prepend(struct config_line_t *front,
                    const char *key,
                    const char *val)
{
  struct config_line_t *newline;
  newline = tor_malloc(sizeof(struct config_line_t));
  newline->key = tor_strdup(key);
  newline->value = tor_strdup(val);
  newline->next = front;
  return newline;
}

84
/** Helper: parse the config file and strdup into key/value
85
86
87
88
89
 * strings. Set *result to the list, or NULL if parsing the file
 * failed.  Return 0 on success, -1 on failure. Warn and ignore any
 * misformatted lines. */
static int config_get_lines(FILE *f,
                            struct config_line_t **result) {
90
91
92

  struct config_line_t *front = NULL;
  char line[CONFIG_LINE_T_MAXLEN];
93
  int r;
94
  char *key, *value;
95

96
  while( (r=parse_line_from_file(line,sizeof(line),f,&key,&value)) > 0) {
97
    front = config_line_prepend(front, key, value);
Roger Dingledine's avatar
Roger Dingledine committed
98
  }
99
100
101
102
103
104
105
  if(r < 0) {
    *result = NULL;
    return -1;
  } else {
    *result = front;
    return 0;
  }
Roger Dingledine's avatar
Roger Dingledine committed
106
107
}

Nick Mathewson's avatar
Nick Mathewson committed
108
109
110
/**
 * Free all the configuration lines on the linked list <b>front</b>.
 */
111
112
static void config_free_lines(struct config_line_t *front) {
  struct config_line_t *tmp;
113
114
115
116
117

  while(front) {
    tmp = front;
    front = tmp->next;

Roger Dingledine's avatar
Roger Dingledine committed
118
119
120
    tor_free(tmp->key);
    tor_free(tmp->value);
    tor_free(tmp);
121
122
123
  }
}

Nick Mathewson's avatar
Nick Mathewson committed
124
125
126
127
128
/** Search the linked list <b>c</b> for any option whose key is <b>key</b>.
 * If such an option is found, interpret it as of type <b>type</b>, and store
 * the result in <b>arg</b>.  If the option is misformatted, log a warning and
 * skip it.
 */
129
static int config_compare(struct config_line_t *c, const char *key, config_type_t type, void *arg) {
130
  int i, ok;
131
132
133
134

  if(strncasecmp(c->key,key,strlen(c->key)))
    return 0;

135
136
137
138
139
  if(strcasecmp(c->key,key)) {
    tor_free(c->key);
    c->key = tor_strdup(key);
  }

140
  /* it's a match. cast and assign. */
141
  log_fn(LOG_DEBUG,"Recognized keyword '%s' as %s, using value '%s'.",c->key,key,c->value);
142
143

  switch(type) {
144
145
146
147
148
149
150
151
    case CONFIG_TYPE_UINT:
      i = tor_parse_long(c->value,10,0,INT_MAX,&ok,NULL);
      if(!ok) {
        log(LOG_WARN, "Int keyword '%s %s' is malformed or out of bounds. Skipping.",
            c->key,c->value);
        return 0;
      }
      *(int *)arg = i;
152
      break;
153
    case CONFIG_TYPE_BOOL:
154
155
156
      i = tor_parse_long(c->value,10,0,1,&ok,NULL);
      if (!ok) {
        log(LOG_WARN, "Boolean keyword '%s' expects 0 or 1. Skipping.", c->key);
157
        return 0;
158
159
160
      }
      *(int *)arg = i;
      break;
161
    case CONFIG_TYPE_STRING:
162
      tor_free(*(char **)arg);
163
      *(char **)arg = tor_strdup(c->value);
164
      break;
165
166
    case CONFIG_TYPE_DOUBLE:
      *(double *)arg = atof(c->value);
167
      break;
168
    case CONFIG_TYPE_CSV:
169
170
      if(*(smartlist_t**)arg == NULL)
        *(smartlist_t**)arg = smartlist_create();
171
172
      smartlist_split_string(*(smartlist_t**)arg, c->value, ",",
                             SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
173
      break;
174
175
176
177
178
179
180
    case CONFIG_TYPE_LINELIST:
      /* Note: this reverses the order that the lines appear in.  That's
       * just fine, since we build up the list of lines reversed in the
       * first place. */
      *(struct config_line_t**)arg =
        config_line_prepend(*(struct config_line_t**)arg, c->key, c->value);
      break;
181
182
183
    case CONFIG_TYPE_OBSOLETE:
      log_fn(LOG_WARN, "Skipping obsolete configuration option '%s'", c->key);
      break;
184
185
186
187
  }
  return 1;
}

Nick Mathewson's avatar
Nick Mathewson committed
188
189
/** Iterate through the linked list of options <b>list</b>.
 * For each item, convert as appropriate and assign to <b>options</b>.
190
191
 * If an item is unrecognized, return -1 immediately,
 * else return 0 for success. */
192
static int config_assign(or_options_t *options, struct config_line_t *list) {
193
194
195
196
197
198
199

  while(list) {
    if(

    /* order matters here! abbreviated arguments use the first match. */

    /* string options */
200
    config_compare(list, "Address",        CONFIG_TYPE_STRING, &options->Address) ||
201
    config_compare(list, "AllowUnverifiedNodes", CONFIG_TYPE_CSV, &options->AllowUnverifiedNodes) ||
202
    config_compare(list, "AuthoritativeDirectory",CONFIG_TYPE_BOOL, &options->AuthoritativeDir) ||
203

204
205
    config_compare(list, "BandwidthRate",  CONFIG_TYPE_UINT, &options->BandwidthRate) ||
    config_compare(list, "BandwidthBurst", CONFIG_TYPE_UINT, &options->BandwidthBurst) ||
206

207
    config_compare(list, "ClientOnly",     CONFIG_TYPE_BOOL, &options->ClientOnly) ||
208
    config_compare(list, "ContactInfo",    CONFIG_TYPE_STRING, &options->ContactInfo) ||
209

210
    config_compare(list, "DebugLogFile",   CONFIG_TYPE_STRING, &options->DebugLogFile) ||
211
    config_compare(list, "DataDirectory",  CONFIG_TYPE_STRING, &options->DataDirectory) ||
212
    config_compare(list, "DirPort",        CONFIG_TYPE_UINT, &options->DirPort) ||
213
    config_compare(list, "DirBindAddress", CONFIG_TYPE_LINELIST, &options->DirBindAddress) ||
214
    config_compare(list, "DirFetchPostPeriod",CONFIG_TYPE_UINT, &options->DirFetchPostPeriod) ||
215
    config_compare(list, "DirServer",      CONFIG_TYPE_LINELIST, &options->DirServers) ||
216

217
218
    config_compare(list, "ExitNodes",      CONFIG_TYPE_STRING, &options->ExitNodes) ||
    config_compare(list, "EntryNodes",     CONFIG_TYPE_STRING, &options->EntryNodes) ||
219
220
    config_compare(list, "StrictExitNodes", CONFIG_TYPE_BOOL, &options->StrictExitNodes) ||
    config_compare(list, "StrictEntryNodes", CONFIG_TYPE_BOOL, &options->StrictEntryNodes) ||
221
    config_compare(list, "ExitPolicy",     CONFIG_TYPE_LINELIST, &options->ExitPolicy) ||
222
    config_compare(list, "ExcludeNodes",   CONFIG_TYPE_STRING, &options->ExcludeNodes) ||
223

224
    config_compare(list, "FascistFirewall",CONFIG_TYPE_BOOL, &options->FascistFirewall) ||
225
    config_compare(list, "FirewallPorts",CONFIG_TYPE_CSV, &options->FirewallPorts) ||
226

227
    config_compare(list, "Group",          CONFIG_TYPE_STRING, &options->Group) ||
228

229
    config_compare(list, "HttpProxy",      CONFIG_TYPE_STRING, &options->HttpProxy) ||
230
231
232
233
234
    config_compare(list, "HiddenServiceDir", CONFIG_TYPE_LINELIST, &options->RendConfigLines)||
    config_compare(list, "HiddenServicePort", CONFIG_TYPE_LINELIST, &options->RendConfigLines)||
    config_compare(list, "HiddenServiceNodes", CONFIG_TYPE_LINELIST, &options->RendConfigLines)||
    config_compare(list, "HiddenServiceExcludeNodes", CONFIG_TYPE_LINELIST, &options->RendConfigLines)||

235
236
    config_compare(list, "IgnoreVersion",  CONFIG_TYPE_BOOL, &options->IgnoreVersion) ||

237
    config_compare(list, "KeepalivePeriod",CONFIG_TYPE_UINT, &options->KeepalivePeriod) ||
238

239
240
    config_compare(list, "LogLevel",       CONFIG_TYPE_LINELIST, &options->LogOptions) ||
    config_compare(list, "LogFile",        CONFIG_TYPE_LINELIST, &options->LogOptions) ||
241
    config_compare(list, "LinkPadding",    CONFIG_TYPE_OBSOLETE, NULL) ||
242

243
244
    config_compare(list, "MaxConn",        CONFIG_TYPE_UINT, &options->MaxConn) ||
    config_compare(list, "MaxOnionsPending",CONFIG_TYPE_UINT, &options->MaxOnionsPending) ||
245
246

    config_compare(list, "Nickname",       CONFIG_TYPE_STRING, &options->Nickname) ||
247
248
    config_compare(list, "NewCircuitPeriod",CONFIG_TYPE_UINT, &options->NewCircuitPeriod) ||
    config_compare(list, "NumCpus",        CONFIG_TYPE_UINT, &options->NumCpus) ||
249

250
    config_compare(list, "ORPort",         CONFIG_TYPE_UINT, &options->ORPort) ||
251
    config_compare(list, "ORBindAddress",  CONFIG_TYPE_LINELIST, &options->ORBindAddress) ||
252
    config_compare(list, "OutboundBindAddress",CONFIG_TYPE_STRING, &options->OutboundBindAddress) ||
253

254
    config_compare(list, "PidFile",        CONFIG_TYPE_STRING, &options->PidFile) ||
255
    config_compare(list, "PathlenCoinWeight",CONFIG_TYPE_DOUBLE, &options->PathlenCoinWeight) ||
256
257
258

    config_compare(list, "RouterFile",     CONFIG_TYPE_STRING, &options->RouterFile) ||
    config_compare(list, "RunAsDaemon",    CONFIG_TYPE_BOOL, &options->RunAsDaemon) ||
259
    config_compare(list, "RunTesting",     CONFIG_TYPE_BOOL, &options->RunTesting) ||
260
    config_compare(list, "RecommendedVersions",CONFIG_TYPE_STRING, &options->RecommendedVersions) ||
261
262
    config_compare(list, "RendNodes",      CONFIG_TYPE_STRING, &options->RendNodes) ||
    config_compare(list, "RendExcludeNodes",CONFIG_TYPE_STRING, &options->RendExcludeNodes) ||
263

264
    config_compare(list, "SocksPort",      CONFIG_TYPE_UINT, &options->SocksPort) ||
265
266
    config_compare(list, "SocksBindAddress",CONFIG_TYPE_LINELIST,&options->SocksBindAddress) ||
    config_compare(list, "SocksPolicy",     CONFIG_TYPE_LINELIST,&options->SocksPolicy) ||
267

268
    config_compare(list, "TrafficShaping", CONFIG_TYPE_OBSOLETE, NULL) ||
269

270
271
272
    config_compare(list, "User",           CONFIG_TYPE_STRING, &options->User)


273
274
275
    ) {
      /* then we're ok. it matched something. */
    } else {
276
277
      log_fn(LOG_WARN,"Unknown keyword '%s'. Failing.",list->key);
      return -1;
278
279
280
    }

    list = list->next;
Roger Dingledine's avatar
Roger Dingledine committed
281
  }
282
  return 0;
283
284
}

Nick Mathewson's avatar
Nick Mathewson committed
285
static void add_default_trusted_dirservers(void) {
Nick Mathewson's avatar
Nick Mathewson committed
286
287
288
289
290
291
292
293
294
  /* moria1 */
  parse_dir_server_line("18.244.0.188:9031 "
                        "FFCB 46DB 1339 DA84 674C 70D7 CB58 6434 C437 0441");
  /* moria2 */
  parse_dir_server_line("18.244.0.188:9032 "
                        "719B E45D E224 B607 C537 07D0 E214 3E2D 423E 74CF");
  /* tor26 */
  parse_dir_server_line("62.116.124.106:9030 "
                        "847B 1F85 0344 D787 6491 A548 92F9 0493 4E4E B85D");
295
296
}

Nick Mathewson's avatar
Nick Mathewson committed
297
298
/** Set <b>options</b> to a reasonable default.
 *
Roger Dingledine's avatar
Roger Dingledine committed
299
 * Call this function when we can't find any torrc config file.
300
 */
Roger Dingledine's avatar
Roger Dingledine committed
301
static int config_assign_defaults(or_options_t *options) {
302
303
304
305

  /* set them up as a client only */
  options->SocksPort = 9050;

306
307
308
309
  options->AllowUnverifiedNodes = smartlist_create();
  smartlist_add(options->AllowUnverifiedNodes, "middle");
  smartlist_add(options->AllowUnverifiedNodes, "rendezvous");

Roger Dingledine's avatar
Roger Dingledine committed
310
311
312
  config_free_lines(options->ExitPolicy);
  options->ExitPolicy = config_line_prepend(NULL, "ExitPolicy", "reject *:*");

313
314
315
  return 0;
}

Nick Mathewson's avatar
Nick Mathewson committed
316
/** Print a usage message for tor. */
317
static void print_usage(void) {
318
  printf("tor -f <torrc> [args]\n"
319
         "See man page for more options. This -h is probably obsolete.\n\n"
320
         "-b <bandwidth>\t\tbytes/second rate limiting\n"
321
         "-d <file>\t\tDebug file\n"
322
//         "-m <max>\t\tMax number of connections\n"
323
324
325
326
         "-l <level>\t\tLog level\n"
         "-r <file>\t\tList of known routers\n");
  printf("\nClient options:\n"
         "-e \"nick1 nick2 ...\"\t\tExit nodes\n"
327
         "-s <IP>\t\t\tPort to bind to for Socks\n"
328
         );
329
330
  printf("\nServer options:\n"
         "-n <nick>\t\tNickname of router\n"
331
332
333
         "-o <port>\t\tOR port to bind to\n"
         "-p <file>\t\tPID file\n"
         );
334
335
}

Nick Mathewson's avatar
Nick Mathewson committed
336
/**
337
338
 * Based on <b>address</b>, guess our public IP address and put it
 * in <b>addr</b>.
Nick Mathewson's avatar
Nick Mathewson committed
339
 */
340
int resolve_my_address(const char *address, uint32_t *addr) {
341
342
  struct in_addr in;
  struct hostent *rent;
343
  char hostname[256];
344
  int explicit_ip=1;
345

346
347
348
349
350
  tor_assert(addr);

  if(address) {
    strlcpy(hostname,address,sizeof(hostname));
  } else { /* then we need to guess our address */
351
    explicit_ip = 0; /* it's implicit */
352

353
    if(gethostname(hostname,sizeof(hostname)) < 0) {
354
355
356
      log_fn(LOG_WARN,"Error obtaining local hostname");
      return -1;
    }
357
    log_fn(LOG_DEBUG,"Guessed local host name as '%s'",hostname);
358
359
  }

360
  /* now we know hostname. resolve it and keep only the IP */
361

362
  if(tor_inet_aton(hostname, &in) == 0) {
363
364
    /* then we have to resolve it */
    explicit_ip = 0;
365
    rent = (struct hostent *)gethostbyname(hostname);
366
    if (!rent) {
367
      log_fn(LOG_WARN,"Could not resolve local Address %s. Failing.", hostname);
368
369
      return -1;
    }
Roger Dingledine's avatar
Roger Dingledine committed
370
    tor_assert(rent->h_length == 4);
371
    memcpy(&in.s_addr, rent->h_addr,rent->h_length);
372
  }
373
  if(!explicit_ip && is_internal_IP(htonl(in.s_addr))) {
374
    log_fn(LOG_WARN,"Address '%s' resolves to private IP '%s'. "
375
           "Please set the Address config option to be the IP you want to use.",
376
           hostname, inet_ntoa(in));
377
378
    return -1;
  }
379
380
  log_fn(LOG_DEBUG,"Resolved Address to %s.", inet_ntoa(in));
  *addr = ntohl(in.s_addr);
381
382
383
  return 0;
}

384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
static char *get_default_nickname(void)
{
  char localhostname[256];
  char *cp, *out, *outp;

  if(gethostname(localhostname,sizeof(localhostname)) < 0) {
    log_fn(LOG_WARN,"Error obtaining local hostname");
    return NULL;
  }
  /* Put it in lowercase; stop at the first dot. */
  for(cp = localhostname; *cp; ++cp) {
    if (*cp == '.') {
      *cp = '\0';
      break;
    }
    *cp = tolower(*cp);
  }
  /* Strip invalid characters. */
  cp = localhostname;
  out = outp = tor_malloc(strlen(localhostname)+1);
  while (*cp) {
    if (strchr(LEGAL_NICKNAME_CHARACTERS, *cp))
      *outp++ = *cp++;
    else
      cp++;
  }
  *outp = '\0';
  /* Enforce length. */
  if (strlen(out) > MAX_NICKNAME_LEN)
    out[MAX_NICKNAME_LEN]='\0';

  return out;
}

Nick Mathewson's avatar
Nick Mathewson committed
418
/** Release storage held by <b>options</b> */
419
static void free_options(or_options_t *options) {
420
  config_free_lines(options->LogOptions);
421
  tor_free(options->ContactInfo);
422
423
424
425
426
427
  tor_free(options->DebugLogFile);
  tor_free(options->DataDirectory);
  tor_free(options->RouterFile);
  tor_free(options->Nickname);
  tor_free(options->Address);
  tor_free(options->PidFile);
428
429
  tor_free(options->ExitNodes);
  tor_free(options->EntryNodes);
430
  tor_free(options->ExcludeNodes);
431
432
  tor_free(options->RendNodes);
  tor_free(options->RendExcludeNodes);
433
  tor_free(options->OutboundBindAddress);
434
  tor_free(options->RecommendedVersions);
435
436
  tor_free(options->User);
  tor_free(options->Group);
437
  tor_free(options->HttpProxy);
438
  config_free_lines(options->RendConfigLines);
439
440
441
442
443
  config_free_lines(options->SocksBindAddress);
  config_free_lines(options->ORBindAddress);
  config_free_lines(options->DirBindAddress);
  config_free_lines(options->ExitPolicy);
  config_free_lines(options->SocksPolicy);
444
  config_free_lines(options->DirServers);
445
446
447
  if (options->FirewallPorts) {
    SMARTLIST_FOREACH(options->FirewallPorts, char *, cp, tor_free(cp));
    smartlist_free(options->FirewallPorts);
448
    options->FirewallPorts = NULL;
449
  }
450
}
451

Nick Mathewson's avatar
Nick Mathewson committed
452
/** Set <b>options</b> to hold reasonable defaults for most options. */
453
static void init_options(or_options_t *options) {
454
/* give reasonable values for each option. Defaults to zero. */
455
  memset(options,0,sizeof(or_options_t));
456
  options->LogOptions = NULL;
457
458
  options->ExitNodes = tor_strdup("");
  options->EntryNodes = tor_strdup("");
459
  options->StrictEntryNodes = options->StrictExitNodes = 0;
460
  options->ExcludeNodes = tor_strdup("");
461
462
  options->RendNodes = tor_strdup("");
  options->RendExcludeNodes = tor_strdup("");
463
464
465
466
467
  options->ExitPolicy = NULL;
  options->SocksPolicy = NULL;
  options->SocksBindAddress = NULL;
  options->ORBindAddress = NULL;
  options->DirBindAddress = NULL;
468
  options->OutboundBindAddress = NULL;
469
  options->RecommendedVersions = NULL;
470
  options->PidFile = NULL; // tor_strdup("tor.pid");
471
  options->DataDirectory = NULL;
472
  options->PathlenCoinWeight = 0.3;
473
  options->MaxConn = 900;
474
  options->DirFetchPostPeriod = 600;
475
  options->KeepalivePeriod = 300;
476
  options->MaxOnionsPending = 100;
477
  options->NewCircuitPeriod = 30; /* twice a minute */
478
479
  options->BandwidthRate = 800000; /* at most 800kB/s total sustained incoming */
  options->BandwidthBurst = 10000000; /* max burst on the token bucket */
480
  options->NumCpus = 1;
481
  options->RendConfigLines = NULL;
482
  options->FirewallPorts = NULL;
483
  options->DirServers = NULL;
484
485
}

486
487
488
489
490
491
static char *get_default_conf_file(void)
{
#ifdef MS_WINDOWS
  char *path = tor_malloc(MAX_PATH);
  if (!SUCCEEDED(SHGetSpecialFolderPath(NULL, path, CSIDL_APPDATA, 1))) {
    tor_free(path);
Nick Mathewson's avatar
Nick Mathewson committed
492
    return NULL;
493
494
495
496
  }
  strlcat(path,"\\tor\\torrc",MAX_PATH);
  return path;
#else
497
  return tor_strdup(CONFDIR "/torrc");
498
499
500
#endif
}

Nick Mathewson's avatar
Nick Mathewson committed
501
502
503
/** Read a configuration file into <b>options</b>, finding the configuration
 * file location based on the command line.  After loading the options,
 * validate them for consistency. Return 0 if success, <0 if failure. */
504
int getconfig(int argc, char **argv, or_options_t *options) {
505
  struct config_line_t *cl;
506
507
508
509
  FILE *cf;
  char *fname;
  int i;
  int result = 0;
510
511
512
513
514
  static int first_load = 1;
  static char **backup_argv;
  static int backup_argc;
  char *previous_pidfile = NULL;
  int previous_runasdaemon = 0;
515
  int previous_orport = -1;
516
  int using_default_torrc;
517
518
519
520
521
522
523
524
525
526

  if(first_load) { /* first time we're called. save commandline args */
    backup_argv = argv;
    backup_argc = argc;
    first_load = 0;
  } else { /* we're reloading. need to clean up old ones first. */
    argv = backup_argv;
    argc = backup_argc;

    /* record some previous values, so we can fail if they change */
527
528
    if(options->PidFile)
      previous_pidfile = tor_strdup(options->PidFile);
529
    previous_runasdaemon = options->RunAsDaemon;
530
    previous_orport = options->ORPort;
531
532
    free_options(options);
  }
Roger Dingledine's avatar
Roger Dingledine committed
533
  init_options(options);
534

535
536
537
538
539
  if(argc > 1 && (!strcmp(argv[1], "-h") || !strcmp(argv[1],"--help"))) {
    print_usage();
    exit(0);
  }

540
541
542
543
544
  if(argc > 1 && (!strcmp(argv[1],"--version"))) {
    printf("Tor version %s.\n",VERSION);
    exit(0);
  }

545
546
547
548
549
550
/* learn config file name, get config lines, assign them */
  i = 1;
  while(i < argc-1 && strcmp(argv[i],"-f")) {
    i++;
  }
  if(i < argc-1) { /* we found one */
551
    fname = tor_strdup(argv[i+1]);
552
    using_default_torrc = 0;
553
  } else {
554
    /* didn't find one, try CONFDIR */
Nick Mathewson's avatar
Nick Mathewson committed
555
556
557
    char *fn;
    using_default_torrc = 1;
    fn = get_default_conf_file();
558
    if (fn && file_status(fn)==FN_FILE) {
Nick Mathewson's avatar
Nick Mathewson committed
559
560
561
562
563
564
565
566
567
568
569
      fname = fn;
    } else {
      tor_free(fn);
      fn = expand_filename("~/.torrc");
      if (fn && file_status(fn)==FN_FILE) {
        fname = fn;
      } else {
        tor_free(fn);
        fname = get_default_conf_file();
      }
    }
570
  }
571
  tor_assert(fname);
572
573
  log(LOG_DEBUG,"Opening config file '%s'",fname);

574
575
576
  if(config_assign_defaults(options) < 0) {
    return -1;
  }
577
  cf = fopen(fname, "r");
578
  if(!cf) {
579
    if(using_default_torrc == 1) {
580
      log(LOG_NOTICE, "Configuration file '%s' not present, using reasonable defaults.",fname);
581
      tor_free(fname);
582
583
    } else {
      log(LOG_WARN, "Unable to open configuration file '%s'.",fname);
584
      tor_free(fname);
585
586
587
      return -1;
    }
  } else { /* it opened successfully. use it. */
588
    tor_free(fname);
589
590
    if (config_get_lines(cf, &cl)<0)
      return -1;
591
592
    if(config_assign(options,cl) < 0)
      return -1;
593
    config_free_lines(cl);
594
    fclose(cf);
595
  }
596

597
598
/* go through command-line variables too */
  cl = config_get_commandlines(argc,argv);
599
600
  if(config_assign(options,cl) < 0)
    return -1;
601
602
603
604
  config_free_lines(cl);

/* Validate options */

605
  /* first check if any of the previous options have changed but aren't allowed to */
606
607
608
609
610
611
612
613
614
615
616
617
  if(previous_pidfile && strcmp(previous_pidfile,options->PidFile)) {
    log_fn(LOG_WARN,"During reload, PidFile changed from %s to %s. Failing.",
           previous_pidfile, options->PidFile);
    return -1;
  }
  tor_free(previous_pidfile);

  if(previous_runasdaemon && !options->RunAsDaemon) {
    log_fn(LOG_WARN,"During reload, change from RunAsDaemon=1 to =0 not allowed. Failing.");
    return -1;
  }

618
  if(previous_orport == 0 && options->ORPort > 0) {
Roger Dingledine's avatar
Roger Dingledine committed
619
    log_fn(LOG_WARN,"During reload, change from ORPort=0 to >0 not allowed. Failing.");
620
621
622
    return -1;
  }

623
624
  if(options->ORPort < 0 || options->ORPort > 65535) {
    log(LOG_WARN,"ORPort option out of bounds.");
625
626
627
    result = -1;
  }

628
  if (options->Nickname == NULL) {
629
630
631
632
633
    if(server_mode()) {
      if (!(options->Nickname = get_default_nickname()))
        return -1;
      log_fn(LOG_NOTICE, "Choosing default nickname %s", options->Nickname);
    }
634
635
636
637
638
639
  } else {
    if (strspn(options->Nickname, LEGAL_NICKNAME_CHARACTERS) !=
        strlen(options->Nickname)) {
      log_fn(LOG_WARN, "Nickname '%s' contains illegal characters.", options->Nickname);
      result = -1;
    }
640
641
642
643
    if (strlen(options->Nickname) == 0) {
      log_fn(LOG_WARN, "Nickname must have at least one character");
      result = -1;
    }
644
645
646
647
    if (strlen(options->Nickname) > MAX_NICKNAME_LEN) {
      log_fn(LOG_WARN, "Nickname '%s' has more than %d characters.",
             options->Nickname, MAX_NICKNAME_LEN);
      result = -1;
648
    }
649
650
  }

651
652
653
654
  if(server_mode()) {
    /* confirm that our address isn't broken, so we can complain now */
    uint32_t tmp;
    if(resolve_my_address(options->Address, &tmp) < 0)
655
      result = -1;
656
657
  }

658
659
  if(options->SocksPort < 0 || options->SocksPort > 65535) {
    log(LOG_WARN,"SocksPort option out of bounds.");
660
661
662
    result = -1;
  }

663
664
665
  if(options->SocksPort == 0 && options->ORPort == 0) {
    log(LOG_WARN,"SocksPort and ORPort are both undefined? Quitting.");
    result = -1;
Roger Dingledine's avatar
Roger Dingledine committed
666
  }
667

668
669
  if(options->DirPort < 0 || options->DirPort > 65535) {
    log(LOG_WARN,"DirPort option out of bounds.");
670
671
672
    result = -1;
  }

673
674
675
676
677
678
679
680
  if(options->StrictExitNodes && !strlen(options->ExitNodes)) {
    log(LOG_WARN,"StrictExitNodes set, but no ExitNodes listed.");
  }

  if(options->StrictEntryNodes && !strlen(options->EntryNodes)) {
    log(LOG_WARN,"StrictEntryNodes set, but no EntryNodes listed.");
  }

Roger Dingledine's avatar
Roger Dingledine committed
681
  if(options->AuthoritativeDir && options->RecommendedVersions == NULL) {
682
683
684
685
    log(LOG_WARN,"Directory servers must configure RecommendedVersions.");
    result = -1;
  }

686
687
688
689
690
  if(options->AuthoritativeDir && !options->DirPort) {
    log(LOG_WARN,"Running as authoritative directory, but no DirPort set.");
    result = -1;
  }

Roger Dingledine's avatar
Roger Dingledine committed
691
692
693
694
  if(options->AuthoritativeDir && !options->ORPort) {
    log(LOG_WARN,"Running as authoritative directory, but no ORPort set.");
    result = -1;
  }
695

Roger Dingledine's avatar
Roger Dingledine committed
696
697
698
699
  if(options->AuthoritativeDir && options->ClientOnly) {
    log(LOG_WARN,"Running as authoritative directory, but ClientOnly also set.");
    result = -1;
  }
700

701
702
  if(options->FascistFirewall && !options->FirewallPorts) {
    options->FirewallPorts = smartlist_create();
703
704
    smartlist_add(options->FirewallPorts, tor_strdup("80"));
    smartlist_add(options->FirewallPorts, tor_strdup("443"));
705
706
707
  }
  if(options->FirewallPorts) {
    SMARTLIST_FOREACH(options->FirewallPorts, const char *, cp,
708
    { i = atoi(cp);
709
      if (i < 1 || i > 65535) {
710
711
712
713
714
715
716
717
718
719
720
721
722
723
        log(LOG_WARN, "Port '%s' out of range in FirewallPorts", cp);
        result=-1;
      }
    });
  }
  options->_AllowUnverified = 0;
  if(options->AllowUnverifiedNodes) {
    SMARTLIST_FOREACH(options->AllowUnverifiedNodes, const char *, cp,
    { if (!strcasecmp(cp, "entry"))
        options->_AllowUnverified |= ALLOW_UNVERIFIED_ENTRY;
      else if (!strcasecmp(cp, "exit"))
        options->_AllowUnverified |= ALLOW_UNVERIFIED_EXIT;
      else if (!strcasecmp(cp, "middle"))
        options->_AllowUnverified |= ALLOW_UNVERIFIED_MIDDLE;
724
725
726
727
      else if (!strcasecmp(cp, "introduction"))
        options->_AllowUnverified |= ALLOW_UNVERIFIED_INTRODUCTION;
      else if (!strcasecmp(cp, "rendezvous"))
        options->_AllowUnverified |= ALLOW_UNVERIFIED_RENDEZVOUS;
728
729
730
      else {
        log(LOG_WARN, "Unrecognized value '%s' in AllowUnverifiedNodes",
            cp);
731
732
733
734
735
        result=-1;
      }
    });
  }

736
  if(options->SocksPort >= 1 &&
737
738
     (options->PathlenCoinWeight < 0.0 || options->PathlenCoinWeight >= 1.0)) {
    log(LOG_WARN,"PathlenCoinWeight option must be >=0.0 and <1.0.");
739
740
741
    result = -1;
  }

742
  if(options->MaxConn < 1) {
Roger Dingledine's avatar
Roger Dingledine committed
743
    log(LOG_WARN,"MaxConn option must be a non-zero positive integer.");
744
745
746
747
    result = -1;
  }

  if(options->MaxConn >= MAXCONNECTIONS) {
Roger Dingledine's avatar
Roger Dingledine committed
748
    log(LOG_WARN,"MaxConn option must be less than %d.", MAXCONNECTIONS);
749
750
751
    result = -1;
  }

752
753
754
#define MIN_DIRFETCHPOSTPERIOD 60
  if(options->DirFetchPostPeriod < MIN_DIRFETCHPOSTPERIOD) {
    log(LOG_WARN,"DirFetchPostPeriod option must be at least %d.", MIN_DIRFETCHPOSTPERIOD);
755
756
    result = -1;
  }
757
758
759
760
  if(options->DirFetchPostPeriod > MIN_ONION_KEY_LIFETIME/2) {
    log(LOG_WARN,"DirFetchPostPeriod is too large; clipping.");
    options->DirFetchPostPeriod = MIN_ONION_KEY_LIFETIME/2;
  }
761
762

  if(options->KeepalivePeriod < 1) {
Roger Dingledine's avatar
Roger Dingledine committed
763
    log(LOG_WARN,"KeepalivePeriod option must be positive.");
764
765
766
    result = -1;
  }

767
768
769
770
771
772
773
774
775
776
777
778
  if(options->HttpProxy) { /* parse it now */
    if(parse_addr_port(options->HttpProxy, NULL,
                       &options->HttpProxyAddr, &options->HttpProxyPort) < 0) {
      log(LOG_WARN,"HttpProxy failed to parse or resolve. Please fix.");
      result = -1;
    }
    options->HttpProxyAddr = ntohl(options->HttpProxyAddr); /* switch to host-order */
    if(options->HttpProxyPort == 0) { /* give it a default */
      options->HttpProxyPort = 80;
    }
  }

Nick Mathewson's avatar
Nick Mathewson committed
779
780
781
782
783
784
785
786
  clear_trusted_dir_servers();
  if (!options->DirServers) {
    add_default_trusted_dirservers();
  } else {
    for (cl = options->DirServers; cl; cl = cl->next) {
      if (parse_dir_server_line(cl->value)<0)
        return -1;
    }
787
788
  }

789
790
791
792
  /* XXX look at the various nicknamelists and make sure they're
   * valid and don't have hostnames that are too long.
   */

793
794
795
796
  if (rend_config_services(options) < 0) {
    result = -1;
  }

797
  return result;
798
799
}

800
static int add_single_log(struct config_line_t *level_opt,
801
802
803
804
805
806
807
808
809
810
811
812
                           struct config_line_t *file_opt,
                           int isDaemon)
{
  int levelMin=-1, levelMax=-1;
  char *cp, *tmp_sev;

  if (level_opt) {
    cp = strchr(level_opt->value, '-');
    if (cp) {
      tmp_sev = tor_strndup(level_opt->value, cp - level_opt->value);
      levelMin = parse_log_level(tmp_sev);
      if (levelMin<0) {
813
814
        log_fn(LOG_WARN, "Unrecognized log severity '%s': must be one of err|warn|notice|info|debug", tmp_sev);
        return -1;
815
816
817
818
      }
      tor_free(tmp_sev);
      levelMax = parse_log_level(cp+1);
      if (levelMax<0) {
819
820
        log_fn(LOG_WARN, "Unrecognized log severity '%s': must be one of err|warn|notice|info|debug", cp+1);
        return -1;
821
822
823
824
      }
    } else {
      levelMin = parse_log_level(level_opt->value);
      if (levelMin<0) {
825
826
827
        log_fn(LOG_WARN, "Unrecognized log severity '%s': must be one of err|warn|notice|info|debug", level_opt->value);
        return -1;

828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
      }
    }
  }
  if (levelMin < 0 && levelMax < 0) {
    levelMin = LOG_NOTICE;
    levelMax = LOG_ERR;
  } else if (levelMin < 0) {
    levelMin = levelMax;
  } else {
    levelMax = LOG_ERR;
  }
  if (file_opt) {
    if (add_file_log(levelMin, levelMax, file_opt->value) < 0) {
      log_fn(LOG_WARN, "Cannot write to LogFile '%s': %s.", file_opt->value,
             strerror(errno));
843
      return -1;
844
845
846
847
    }
    log_fn(LOG_NOTICE, "Successfully opened LogFile '%s', redirecting output.",
           file_opt->value);
  } else if (!isDaemon) {
848
    add_stream_log(levelMin, levelMax, "<stdout>", stdout);
849
    close_temp_logs();
850
  }
851
  return 0;
852
853
854
855
856
}

/**
 * Initialize the logs based on the configuration file.
 */
857
int config_init_logs(or_options_t *options)
858
859
860
861
862
{
  /* The order of options is:  Level? (File Level?)+
   */
  struct config_line_t *opt = options->LogOptions;

863
864
865
866
  /* Special case if no options are given. */
  if (!opt) {
    add_stream_log(LOG_NOTICE, LOG_ERR, "<stdout>", stdout);
    close_temp_logs();
Roger Dingledine's avatar
Roger Dingledine committed
867
868
    /* don't return yet, in case we want to do a debuglogfile below */
  }
869

870
871
872
  /* Special case for if first option is LogLevel. */
  if (opt && !strcasecmp(opt->key, "LogLevel")) {
    if (opt->next && !strcasecmp(opt->next->key, "LogFile")) {
873
874
      if (add_single_log(opt, opt->next, options->RunAsDaemon)<0)
        return -1;
875
876
      opt = opt->next->next;
    } else if (!opt->next) {
877
878
      if (add_single_log(opt, NULL, options->RunAsDaemon)<0)
        return -1;
879
      opt = opt->next;
880
881
    } else {
      ; /* give warning below */
882
883
884
885
886
887
888
889
    }
  }

  while (opt) {
    if (!strcasecmp(opt->key, "LogLevel")) {
      log_fn(LOG_WARN, "Two LogLevel options in a row without intervening LogFile");
      opt = opt->next;
    } else {
890
      tor_assert(!strcasecmp(opt->key, "LogFile"));
891
892
      if (opt->next && !strcasecmp(opt->next->key, "LogLevel")) {
        /* LogFile followed by LogLevel */
893
894
        if (add_single_log(opt->next, opt, options->RunAsDaemon)<0)
          return -1;
895
896
897
        opt = opt->next->next;
      } else {
        /* LogFile followed by LogFile or end of list. */
898
899
        if (add_single_log(NULL, opt, options->RunAsDaemon)<0)
          return -1;
900
901
902
903
904
905
906
        opt = opt->next;
      }
    }
  }

  if (options->DebugLogFile) {
    log_fn(LOG_WARN, "DebugLogFile is deprecated; use LogFile and LogLevel instead");
907
908
    if (add_file_log(LOG_DEBUG, LOG_ERR, options->DebugLogFile)<0)
      return -1;
909
  }
910
  return 0;
911
912
}

Nick Mathewson's avatar
Nick Mathewson committed
913
914
915
916
/**
 * Given a linked list of config lines containing "allow" and "deny" tokens,
 * parse them and place the result in <b>dest</b>.  Skip malformed lines.
 */
917
918
919
920
921
void
config_parse_exit_policy(struct config_line_t *cfg,
                         struct exit_policy_t **dest)
{
  struct exit_policy_t **nextp;
922
  smartlist_t *entries;
923
924
925
926
927
928
929

  if (!cfg)
    return;
  nextp = dest;
  while (*nextp)
    nextp = &((*nextp)->next);

930
  entries = smartlist_create();
931
  for (; cfg; cfg = cfg->next) {
932
    smartlist_split_string(entries,cfg->value,",",SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK,0);
933
934
935
    SMARTLIST_FOREACH(entries, const char *, ent, {
      log_fn(LOG_DEBUG,"Adding new entry '%s'",ent);
      *nextp = router_parse_exit_policy_from_string(ent);
936
937
938
      if(*nextp) {
        nextp = &((*nextp)->next);
      } else {
939
        log_fn(LOG_WARN,"Malformed exit policy %s; skipping.", ent);
940
      }
941
942
943
    });
    SMARTLIST_FOREACH(entries, char *, ent, tor_free(ent));
    smartlist_clear(entries);
944
  }
945
  smartlist_free(entries);
946
947
948
949
950
951
952
953
954
955
956
957
}

void exit_policy_free(struct exit_policy_t *p) {
  struct exit_policy_t *e;
  while (p) {
    e = p;
    p = p->next;
    tor_free(e->string);
    tor_free(e);
  }
}

958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
static int parse_dir_server_line(const char *line)
{
  smartlist_t *items = NULL;
  int r;
  char *addrport, *address=NULL;
  uint16_t port;
  char digest[DIGEST_LEN];
  items = smartlist_create();
  smartlist_split_string(items, line, " ",
                         SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 2);
  if (smartlist_len(items) < 2) {
    log_fn(LOG_WARN, "Too few arguments to DirServer line."); goto err;
  }
  addrport = smartlist_get(items, 0);
  if (parse_addr_port(addrport, &address, NULL, &port)<0) {
    log_fn(LOG_WARN, "Error parsing DirServer address '%s'", addrport);goto err;
  }
  if (!port) {
    log_fn(LOG_WARN, "Missing port in DirServe address '%s'",addrport);goto err;
  }

  tor_strstrip(smartlist_get(items, 1), " ");
  if (strlen(smartlist_get(items, 1)) != HEX_DIGEST_LEN) {
    log_fn(LOG_WARN, "Key digest for DirServer is wrong length."); goto err;
  }
  if (base16_decode(digest, DIGEST_LEN,
                    smartlist_get(items,1), HEX_DIGEST_LEN)<0) {
    log_fn(LOG_WARN, "Unable to decode DirServer key digest."); goto err;
  }

988
989
  log_fn(LOG_DEBUG, "Trusted dirserver at %s:%d (%s)", address,(int)port,
         (char*)smartlist_get(items,1));
990
991
992
993
994
995
996
997
998
999
1000
  add_trusted_dir_server(address, port, digest);

  r = 0;
  goto done;
 err:
  r = -1;
 done:
  SMARTLIST_FOREACH(items, char*, s, tor_free(s));
  smartlist_free(items);
  if (address) tor_free(address);
  return r;
For faster browsing, not all history is shown. View entire blame