config.c 33.7 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
static char *get_default_conf_file(void)
{
#ifdef MS_WINDOWS
489
490
491
  LPITEMIDLIST idl;
  IMalloc *m;
  HRESULT result;
492
  char *path = tor_malloc(MAX_PATH);
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
  /* Find X:\documents and settings\username\applicatation data\ .
   * We would use SHGetSpecialFolder path, but that wasn't added until IE4.
   */
  if (!SUCCEEDED(SHGetSpecialFolderLocation(NULL, CSIDL_APPDATA,
                                            &idl))) {
    tor_free(path);
    return NULL;
  }
  /* Convert the path from an "ID List" (whatever that is!) to a path. */
  result = SHGetPathFromIDList(idl, path);
  /* Now we need to free the */
  SHGetMalloc(&m);
  if (m) {
    m->lpVtbl->Free(m, idl);
    m->lpVtbl->Release(m);
  }
  if (!SUCCEEDED(result)) {
510
    tor_free(path);
Nick Mathewson's avatar
Nick Mathewson committed
511
    return NULL;
512
513
514
515
  }
  strlcat(path,"\\tor\\torrc",MAX_PATH);
  return path;
#else
516
  return tor_strdup(CONFDIR "/torrc");
517
518
519
#endif
}

Nick Mathewson's avatar
Nick Mathewson committed
520
521
522
/** 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. */
523
int getconfig(int argc, char **argv, or_options_t *options) {
524
  struct config_line_t *cl;
525
526
527
528
  FILE *cf;
  char *fname;
  int i;
  int result = 0;
529
530
531
532
533
  static int first_load = 1;
  static char **backup_argv;
  static int backup_argc;
  char *previous_pidfile = NULL;
  int previous_runasdaemon = 0;
534
  int previous_orport = -1;
535
  int using_default_torrc;
536
537
538
539
540
541
542
543
544
545

  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 */
546
547
    if(options->PidFile)
      previous_pidfile = tor_strdup(options->PidFile);
548
    previous_runasdaemon = options->RunAsDaemon;
549
    previous_orport = options->ORPort;
550
551
    free_options(options);
  }
Roger Dingledine's avatar
Roger Dingledine committed
552
  init_options(options);
553

554
555
556
557
558
  if(argc > 1 && (!strcmp(argv[1], "-h") || !strcmp(argv[1],"--help"))) {
    print_usage();
    exit(0);
  }

559
560
561
562
563
  if(argc > 1 && (!strcmp(argv[1],"--version"))) {
    printf("Tor version %s.\n",VERSION);
    exit(0);
  }

564
565
566
567
568
569
/* 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 */
570
    fname = tor_strdup(argv[i+1]);
571
    using_default_torrc = 0;
572
  } else {
573
    /* didn't find one, try CONFDIR */
Nick Mathewson's avatar
Nick Mathewson committed
574
575
576
    char *fn;
    using_default_torrc = 1;
    fn = get_default_conf_file();
577
    if (fn && file_status(fn)==FN_FILE) {
Nick Mathewson's avatar
Nick Mathewson committed
578
579
580
581
582
583
584
585
586
587
588
      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();
      }
    }
589
  }
590
  tor_assert(fname);
591
592
  log(LOG_DEBUG,"Opening config file '%s'",fname);

593
594
595
  if(config_assign_defaults(options) < 0) {
    return -1;
  }
596
  cf = fopen(fname, "r");
597
  if(!cf) {
598
    if(using_default_torrc == 1) {
599
      log(LOG_NOTICE, "Configuration file '%s' not present, using reasonable defaults.",fname);
600
      tor_free(fname);
601
602
    } else {
      log(LOG_WARN, "Unable to open configuration file '%s'.",fname);
603
      tor_free(fname);
604
605
606
      return -1;
    }
  } else { /* it opened successfully. use it. */
607
    tor_free(fname);
608
609
    if (config_get_lines(cf, &cl)<0)
      return -1;
610
611
    if(config_assign(options,cl) < 0)
      return -1;
612
    config_free_lines(cl);
613
    fclose(cf);
614
  }
615

616
617
/* go through command-line variables too */
  cl = config_get_commandlines(argc,argv);
618
619
  if(config_assign(options,cl) < 0)
    return -1;
620
621
622
623
  config_free_lines(cl);

/* Validate options */

624
  /* first check if any of the previous options have changed but aren't allowed to */
625
626
627
628
629
630
631
632
633
634
635
636
  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;
  }

637
  if(previous_orport == 0 && options->ORPort > 0) {
Roger Dingledine's avatar
Roger Dingledine committed
638
    log_fn(LOG_WARN,"During reload, change from ORPort=0 to >0 not allowed. Failing.");
639
640
641
    return -1;
  }

642
643
  if(options->ORPort < 0 || options->ORPort > 65535) {
    log(LOG_WARN,"ORPort option out of bounds.");
644
645
646
    result = -1;
  }

647
  if (options->Nickname == NULL) {
648
649
650
651
652
    if(server_mode()) {
      if (!(options->Nickname = get_default_nickname()))
        return -1;
      log_fn(LOG_NOTICE, "Choosing default nickname %s", options->Nickname);
    }
653
654
655
656
657
658
  } else {
    if (strspn(options->Nickname, LEGAL_NICKNAME_CHARACTERS) !=
        strlen(options->Nickname)) {
      log_fn(LOG_WARN, "Nickname '%s' contains illegal characters.", options->Nickname);
      result = -1;
    }
659
660
661
662
    if (strlen(options->Nickname) == 0) {
      log_fn(LOG_WARN, "Nickname must have at least one character");
      result = -1;
    }
663
664
665
666
    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;
667
    }
668
669
  }

670
671
672
673
  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)
674
      result = -1;
675
676
  }

677
678
  if(options->SocksPort < 0 || options->SocksPort > 65535) {
    log(LOG_WARN,"SocksPort option out of bounds.");
679
680
681
    result = -1;
  }

682
683
684
  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
685
  }
686

687
688
  if(options->DirPort < 0 || options->DirPort > 65535) {
    log(LOG_WARN,"DirPort option out of bounds.");
689
690
691
    result = -1;
  }

692
693
694
695
696
697
698
699
  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
700
  if(options->AuthoritativeDir && options->RecommendedVersions == NULL) {
701
702
703
704
    log(LOG_WARN,"Directory servers must configure RecommendedVersions.");
    result = -1;
  }

705
706
707
708
709
  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
710
711
712
713
  if(options->AuthoritativeDir && !options->ORPort) {
    log(LOG_WARN,"Running as authoritative directory, but no ORPort set.");
    result = -1;
  }
714

Roger Dingledine's avatar
Roger Dingledine committed
715
716
717
718
  if(options->AuthoritativeDir && options->ClientOnly) {
    log(LOG_WARN,"Running as authoritative directory, but ClientOnly also set.");
    result = -1;
  }
719

720
721
  if(options->FascistFirewall && !options->FirewallPorts) {
    options->FirewallPorts = smartlist_create();
722
723
    smartlist_add(options->FirewallPorts, tor_strdup("80"));
    smartlist_add(options->FirewallPorts, tor_strdup("443"));
724
725
726
  }
  if(options->FirewallPorts) {
    SMARTLIST_FOREACH(options->FirewallPorts, const char *, cp,
727
    { i = atoi(cp);
728
      if (i < 1 || i > 65535) {
729
730
731
732
733
734
735
736
737
738
739
740
741
742
        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;
743
744
745
746
      else if (!strcasecmp(cp, "introduction"))
        options->_AllowUnverified |= ALLOW_UNVERIFIED_INTRODUCTION;
      else if (!strcasecmp(cp, "rendezvous"))
        options->_AllowUnverified |= ALLOW_UNVERIFIED_RENDEZVOUS;
747
748
749
      else {
        log(LOG_WARN, "Unrecognized value '%s' in AllowUnverifiedNodes",
            cp);
750
751
752
753
754
        result=-1;
      }
    });
  }

755
  if(options->SocksPort >= 1 &&
756
757
     (options->PathlenCoinWeight < 0.0 || options->PathlenCoinWeight >= 1.0)) {
    log(LOG_WARN,"PathlenCoinWeight option must be >=0.0 and <1.0.");
758
759
760
    result = -1;
  }

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

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

771
772
773
#define MIN_DIRFETCHPOSTPERIOD 60
  if(options->DirFetchPostPeriod < MIN_DIRFETCHPOSTPERIOD) {
    log(LOG_WARN,"DirFetchPostPeriod option must be at least %d.", MIN_DIRFETCHPOSTPERIOD);
774
775
    result = -1;
  }
776
777
778
779
  if(options->DirFetchPostPeriod > MIN_ONION_KEY_LIFETIME/2) {
    log(LOG_WARN,"DirFetchPostPeriod is too large; clipping.");
    options->DirFetchPostPeriod = MIN_ONION_KEY_LIFETIME/2;
  }
780
781

  if(options->KeepalivePeriod < 1) {
Roger Dingledine's avatar
Roger Dingledine committed
782
    log(LOG_WARN,"KeepalivePeriod option must be positive.");
783
784
785
    result = -1;
  }

786
787
788
789
790
791
792
793
794
795
796
797
  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
798
799
800
801
802
803
804
805
  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;
    }
806
807
  }

808
809
810
811
  /* XXX look at the various nicknamelists and make sure they're
   * valid and don't have hostnames that are too long.
   */

812
813
814
815
  if (rend_config_services(options) < 0) {
    result = -1;
  }

816
  return result;
817
818
}

819
static int add_single_log(struct config_line_t *level_opt,
820
821
822
823
824
825
826
827
828
829
830
831
                           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) {
832
833
        log_fn(LOG_WARN, "Unrecognized log severity '%s': must be one of err|warn|notice|info|debug", tmp_sev);
        return -1;
834
835
836
837
      }
      tor_free(tmp_sev);
      levelMax = parse_log_level(cp+1);
      if (levelMax<0) {
838
839
        log_fn(LOG_WARN, "Unrecognized log severity '%s': must be one of err|warn|notice|info|debug", cp+1);
        return -1;
840
841
842
843
      }
    } else {
      levelMin = parse_log_level(level_opt->value);
      if (levelMin<0) {
844
845
846
        log_fn(LOG_WARN, "Unrecognized log severity '%s': must be one of err|warn|notice|info|debug", level_opt->value);
        return -1;

847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
      }
    }
  }
  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));
862
      return -1;
863
864
865
866
    }
    log_fn(LOG_NOTICE, "Successfully opened LogFile '%s', redirecting output.",
           file_opt->value);
  } else if (!isDaemon) {
867
    add_stream_log(levelMin, levelMax, "<stdout>", stdout);
868
    close_temp_logs();
869
  }
870
  return 0;
871
872
873
874
875
}

/**
 * Initialize the logs based on the configuration file.
 */
876
int config_init_logs(or_options_t *options)
877
878
879
880
881
{
  /* The order of options is:  Level? (File Level?)+
   */
  struct config_line_t *opt = options->LogOptions;

882
883
884
885
  /* 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
886
887
    /* don't return yet, in case we want to do a debuglogfile below */
  }
888

889
890
891
  /* Special case for if first option is LogLevel. */
  if (opt && !strcasecmp(opt->key, "LogLevel")) {
    if (opt->next && !strcasecmp(opt->next->key, "LogFile")) {
892
893
      if (add_single_log(opt, opt->next, options->RunAsDaemon)<0)
        return -1;
894
895
      opt = opt->next->next;
    } else if (!opt->next) {
896
897
      if (add_single_log(opt, NULL, options->RunAsDaemon)<0)
        return -1;
898
      opt = opt->next;
899
900
    } else {
      ; /* give warning below */
901
902
903
904
905
906
907
908
    }
  }

  while (opt) {
    if (!strcasecmp(opt->key, "LogLevel")) {
      log_fn(LOG_WARN, "Two LogLevel options in a row without intervening LogFile");
      opt = opt->next;
    } else {
909
      tor_assert(!strcasecmp(opt->key, "LogFile"));
910
911
      if (opt->next && !strcasecmp(opt->next->key, "LogLevel")) {
        /* LogFile followed by LogLevel */
912
913
        if (add_single_log(opt->next, opt, options->RunAsDaemon)<0)
          return -1;
914
915
916
        opt = opt->next->next;
      } else {
        /* LogFile followed by LogFile or end of list. */
917
918
        if (add_single_log(NULL, opt, options->RunAsDaemon)<0)
          return -1;
919
920
921
922
923
924
925
        opt = opt->next;
      }
    }
  }

  if (options->DebugLogFile) {
    log_fn(LOG_WARN, "DebugLogFile is deprecated; use LogFile and LogLevel instead");
926
927
    if (add_file_log(LOG_DEBUG, LOG_ERR, options->DebugLogFile)<0)
      return -1;
928
  }
929
  return 0;
930
931
}

Nick Mathewson's avatar
Nick Mathewson committed
932
933
934
935
/**
 * 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.
 */
936
937
938
939
940
void
config_parse_exit_policy(struct config_line_t *cfg,
                         struct exit_policy_t **dest)
{
  struct exit_policy_t **nextp;
941
  smartlist_t *entries;
942
943
944
945
946
947
948

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

949
  entries = smartlist_create();
950
  for (; cfg; cfg = cfg->next) {
951
    smartlist_split_string(entries,cfg->value,",",SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK,0);
952
953
954
    SMARTLIST_FOREACH(entries, const char *, ent, {
      log_fn(LOG_DEBUG,"Adding new entry '%s'",ent);
      *nextp = router_parse_exit_policy_from_string(ent);
955
956
957
      if(*nextp) {
        nextp = &((*nextp)->next);
      } else {
958
        log_fn(LOG_WARN,"Malformed exit policy %s; skipping.", ent);
959
      }
960
961
962
    });
    SMARTLIST_FOREACH(entries, char *, ent, tor_free(ent));
    smartlist_clear(entries);
963
  }
964
  smartlist_free(entries);
965
966
967
968
969
970
971
972
973
974
975
976
}

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);
  }
}

977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
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;