Tor  0.4.8.0-alpha-dev
main.c
Go to the documentation of this file.
1 /* Copyright (c) 2001 Matej Pfajfar.
2  * Copyright (c) 2001-2004, Roger Dingledine.
3  * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
4  * Copyright (c) 2007-2021, The Tor Project, Inc. */
5 /* See LICENSE for licensing information */
6 
7 /**
8  * \file main.c
9  * \brief Invocation module. Initializes subsystems and runs the main loop.
10  **/
11 
12 #include "core/or/or.h"
13 
14 #include "app/config/config.h"
15 #include "app/config/statefile.h"
16 #include "app/config/quiet_level.h"
17 #include "app/main/main.h"
18 #include "app/main/ntmain.h"
19 #include "app/main/risky_options.h"
20 #include "app/main/shutdown.h"
21 #include "app/main/subsysmgr.h"
24 #include "core/mainloop/mainloop.h"
27 #include "core/or/channel.h"
28 #include "core/or/channelpadding.h"
29 #include "core/or/circuitpadding.h"
32 #include "core/or/circuitlist.h"
33 #include "core/or/command.h"
34 #include "core/or/connection_or.h"
35 #include "core/or/relay.h"
36 #include "core/or/status.h"
37 #include "feature/api/tor_api.h"
43 #include "feature/dirauth/keypin.h"
48 #include "feature/hs/hs_dos.h"
49 #include "feature/hs/hs_service.h"
53 #include "feature/relay/dns.h"
58 #include "feature/stats/bwhist.h"
59 #include "feature/stats/rephist.h"
60 #include "lib/compress/compress.h"
61 #include "lib/buf/buffers.h"
65 #include "lib/net/resolve.h"
66 #include "lib/trace/trace.h"
67 
68 #include "lib/process/waitpid.h"
70 
71 #include "lib/meminfo/meminfo.h"
72 #include "lib/osinfo/uname.h"
73 #include "lib/osinfo/libc.h"
74 #include "lib/sandbox/sandbox.h"
75 #include "lib/fs/lockfile.h"
76 #include "lib/tls/tortls.h"
78 #include "lib/encoding/confline.h"
79 #include "lib/evloop/timers.h"
81 #include "lib/version/torversion.h"
82 
83 #include <event2/event.h>
84 
87 
89 #include "core/or/port_cfg_st.h"
90 
91 #ifdef HAVE_UNISTD_H
92 #include <unistd.h>
93 #endif
94 
95 #ifdef HAVE_SYSTEMD
96 # if defined(__COVERITY__) && !defined(__INCLUDE_LEVEL__)
97 /* Systemd's use of gcc's __INCLUDE_LEVEL__ extension macro appears to confuse
98  * Coverity. Here's a kludge to unconfuse it.
99  */
100 # define __INCLUDE_LEVEL__ 2
101 #endif /* defined(__COVERITY__) && !defined(__INCLUDE_LEVEL__) */
102 #include <systemd/sd-daemon.h>
103 #endif /* defined(HAVE_SYSTEMD) */
104 
105 /********* PROTOTYPES **********/
106 
107 static void dumpmemusage(int severity);
108 static void dumpstats(int severity); /* log stats */
109 static void process_signal(int sig);
110 
111 /** Called when we get a SIGHUP: reload configuration files and keys,
112  * retry all connections, and so on. */
113 static int
114 do_hup(void)
115 {
116  const or_options_t *options = get_options();
117 
118  log_notice(LD_GENERAL,"Received reload signal (hup). Reloading config and "
119  "resetting internal state.");
120  if (accounting_is_enabled(options))
122 
125  /* first, reload config variables, in case they've changed */
126  if (options->ReloadTorrcOnSIGHUP) {
127  /* no need to provide argc/v, they've been cached in init_from_config */
128  int init_rv = options_init_from_torrc(0, NULL);
129  if (init_rv < 0) {
130  log_err(LD_CONFIG,"Reading config failed--see warnings above. "
131  "For usage, try -h.");
132  return -1;
133  } else if (BUG(init_rv > 0)) {
134  // LCOV_EXCL_START
135  /* This should be impossible: the only "return 1" cases in
136  * options_init_from_torrc are ones caused by command-line arguments;
137  * but they can't change while Tor is running. */
138  return -1;
139  // LCOV_EXCL_STOP
140  }
141  options = get_options(); /* they have changed now */
142  /* Logs are only truncated the first time they are opened, but were
143  probably intended to be cleaned up on signal. */
144  if (options->TruncateLogFile)
145  truncate_logs();
146  } else {
147  char *msg = NULL;
148  log_notice(LD_GENERAL, "Not reloading config file: the controller told "
149  "us not to.");
150  /* Make stuff get rescanned, reloaded, etc. */
151  if (set_options((or_options_t*)options, &msg) < 0) {
152  if (!msg)
153  msg = tor_strdup("Unknown error");
154  log_warn(LD_GENERAL, "Unable to re-set previous options: %s", msg);
155  tor_free(msg);
156  }
157  }
158  if (authdir_mode(options)) {
159  /* reload the approved-routers file */
160  if (dirserv_load_fingerprint_file() < 0) {
161  /* warnings are logged from dirserv_load_fingerprint_file() directly */
162  log_info(LD_GENERAL, "Error reloading fingerprints. "
163  "Continuing with old list.");
164  }
165  }
166 
167  /* Rotate away from the old dirty circuits. This has to be done
168  * after we've read the new options, but before we start using
169  * circuits for directory fetches. */
171 
172  /* retry appropriate downloads */
175  if (!net_is_disabled())
176  update_networkstatus_downloads(time(NULL));
177 
178  /* We'll retry routerstatus downloads in about 10 seconds; no need to
179  * force a retry there. */
180 
181  if (server_mode(options)) {
182  /* Maybe we've been given a new ed25519 key or certificate?
183  */
184  time_t now = approx_time();
185  int new_signing_key = load_ed_keys(options, now);
186  if (new_signing_key < 0 ||
187  generate_ed_link_cert(options, now, new_signing_key > 0)) {
188  log_warn(LD_OR, "Problem reloading Ed25519 keys; still using old keys.");
189  }
190 
191  /* Update cpuworker and dnsworker processes, so they get up-to-date
192  * configuration options. */
194  dns_reset();
195  }
196  return 0;
197 }
198 
199 /** Libevent callback: invoked when we get a signal.
200  */
201 static void
202 signal_callback(evutil_socket_t fd, short events, void *arg)
203 {
204  const int *sigptr = arg;
205  const int sig = *sigptr;
206  (void)fd;
207  (void)events;
208 
209  update_current_time(time(NULL));
210  process_signal(sig);
211 }
212 
213 /** Do the work of acting on a signal received in <b>sig</b> */
214 static void
216 {
217  switch (sig)
218  {
219  case SIGTERM:
220  log_notice(LD_GENERAL,"Catching signal TERM, exiting cleanly.");
222  break;
223  case SIGINT:
224  if (!server_mode(get_options())) { /* do it now */
225  log_notice(LD_GENERAL,"Interrupt: exiting cleanly.");
227  return;
228  }
229 #ifdef HAVE_SYSTEMD
230  sd_notify(0, "STOPPING=1");
231 #endif
233  break;
234 #ifdef SIGPIPE
235  case SIGPIPE:
236  log_debug(LD_GENERAL,"Caught SIGPIPE. Ignoring.");
237  break;
238 #endif
239  case SIGUSR1:
240  /* prefer to log it at INFO, but make sure we always see it */
243  break;
244  case SIGUSR2:
246  log_debug(LD_GENERAL,"Caught USR2, going to loglevel debug. "
247  "Send HUP to change back.");
249  break;
250  case SIGHUP:
251 #ifdef HAVE_SYSTEMD
252  sd_notify(0, "RELOADING=1");
253 #endif
254  if (do_hup() < 0) {
255  log_warn(LD_CONFIG,"Restart failed (config error?). Exiting.");
257  return;
258  }
259 #ifdef HAVE_SYSTEMD
260  sd_notify(0, "READY=1");
261 #endif
263  break;
264 #ifdef SIGCHLD
265  case SIGCHLD:
267  break;
268 #endif
269  case SIGNEWNYM: {
270  do_signewnym(time(NULL));
271  break;
272  }
273  case SIGCLEARDNSCACHE:
276  break;
277  case SIGHEARTBEAT:
278  log_heartbeat(time(NULL));
280  break;
281  case SIGACTIVE:
282  /* "SIGACTIVE" counts as ersatz user activity. */
285  break;
286  case SIGDORMANT:
287  /* "SIGDORMANT" means to ignore past user activity */
288  log_notice(LD_GENERAL, "Going dormant because of controller request.");
293  break;
294  }
295 }
296 
297 #ifdef _WIN32
298 /** Activate SIGINT on receiving a control signal in console. */
299 static BOOL WINAPI
300 process_win32_console_ctrl(DWORD ctrl_type)
301 {
302  /* Ignore type of the ctrl signal */
303  (void) ctrl_type;
304 
305  activate_signal(SIGINT);
306  return TRUE;
307 }
308 #endif /* defined(_WIN32) */
309 
310 /**
311  * Write current memory usage information to the log.
312  */
313 static void
314 dumpmemusage(int severity)
315 {
317  tor_log(severity, LD_GENERAL, "In rephist: %"PRIu64" used by %d Tors.",
319  dump_routerlist_mem_usage(severity);
320  dump_cell_pool_usage(severity);
321  dump_dns_mem_usage(severity);
322 }
323 
324 /** Write all statistics to the log, with log level <b>severity</b>. Called
325  * in response to a SIGUSR1. */
326 static void
327 dumpstats(int severity)
328 {
329  time_t now = time(NULL);
330  time_t elapsed;
331  size_t rbuf_cap, wbuf_cap, rbuf_len, wbuf_len;
332 
333  tor_log(severity, LD_GENERAL, "Dumping stats:");
334 
336  int i = conn_sl_idx;
337  tor_log(severity, LD_GENERAL,
338  "Conn %d (socket %d) is a %s, created %d secs ago",
339  i, (int)conn->s,
340  connection_describe(conn),
341  (int)(now - conn->timestamp_created));
342  if (!connection_is_listener(conn)) {
343  tor_log(severity,LD_GENERAL,
344  "Conn %d: %d bytes waiting on inbuf (len %d, last read %d secs ago)",
345  i,
346  (int)connection_get_inbuf_len(conn),
347  (int)buf_allocation(conn->inbuf),
348  (int)(now - conn->timestamp_last_read_allowed));
349  tor_log(severity,LD_GENERAL,
350  "Conn %d: %d bytes waiting on outbuf "
351  "(len %d, last written %d secs ago)",i,
352  (int)connection_get_outbuf_len(conn),
353  (int)buf_allocation(conn->outbuf),
354  (int)(now - conn->timestamp_last_write_allowed));
355  if (conn->type == CONN_TYPE_OR) {
356  or_connection_t *or_conn = TO_OR_CONN(conn);
357  if (or_conn->tls) {
358  if (tor_tls_get_buffer_sizes(or_conn->tls, &rbuf_cap, &rbuf_len,
359  &wbuf_cap, &wbuf_len) == 0) {
360  tor_log(severity, LD_GENERAL,
361  "Conn %d: %d/%d bytes used on OpenSSL read buffer; "
362  "%d/%d bytes used on write buffer.",
363  i, (int)rbuf_len, (int)rbuf_cap, (int)wbuf_len, (int)wbuf_cap);
364  }
365  }
366  }
367  }
368  circuit_dump_by_conn(conn, severity); /* dump info about all the circuits
369  * using this conn */
370  } SMARTLIST_FOREACH_END(conn);
371 
372  channel_dumpstats(severity);
373  channel_listener_dumpstats(severity);
374 
375  tor_log(severity, LD_NET,
376  "Cells processed: %"PRIu64" padding\n"
377  " %"PRIu64" create\n"
378  " %"PRIu64" created\n"
379  " %"PRIu64" relay\n"
380  " (%"PRIu64" relayed)\n"
381  " (%"PRIu64" delivered)\n"
382  " %"PRIu64" destroy",
391  tor_log(severity,LD_NET,"Average packaged cell fullness: %2.3f%%",
392  100*(((double)stats_n_data_bytes_packaged) /
395  tor_log(severity,LD_NET,"Average delivered cell fullness: %2.3f%%",
396  100*(((double)stats_n_data_bytes_received) /
398 
399  cpuworker_log_onionskin_overhead(severity, ONION_HANDSHAKE_TYPE_TAP, "TAP");
400  cpuworker_log_onionskin_overhead(severity, ONION_HANDSHAKE_TYPE_NTOR,"ntor");
401 
402  if (now - time_of_process_start >= 0)
403  elapsed = now - time_of_process_start;
404  else
405  elapsed = 0;
406 
407  if (elapsed) {
408  tor_log(severity, LD_NET,
409  "Average bandwidth: %"PRIu64"/%d = %d bytes/sec reading",
410  (get_bytes_read()),
411  (int)elapsed,
412  (int) (get_bytes_read()/elapsed));
413  tor_log(severity, LD_NET,
414  "Average bandwidth: %"PRIu64"/%d = %d bytes/sec writing",
415  (get_bytes_written()),
416  (int)elapsed,
417  (int) (get_bytes_written()/elapsed));
418  }
419 
420  tor_log(severity, LD_NET, "--------------- Dumping memory information:");
421  dumpmemusage(severity);
422 
423  rep_hist_dump_stats(now,severity);
424  hs_service_dump_stats(severity);
425 }
426 
427 #ifdef _WIN32
428 #define UNIX_ONLY 0
429 #else
430 #define UNIX_ONLY 1
431 #endif
432 
433 static struct {
434  /** A numeric code for this signal. Must match the signal value if
435  * try_to_register is true. */
437  /** True if we should try to register this signal with libevent and catch
438  * corresponding posix signals. False otherwise. */
440  /** Pointer to hold the event object constructed for this signal. */
441  struct event *signal_event;
442 } signal_handlers[] = {
443 #ifdef SIGINT
444  { SIGINT, UNIX_ONLY, NULL }, /* do a controlled slow shutdown */
445 #endif
446 #ifdef SIGTERM
447  { SIGTERM, UNIX_ONLY, NULL }, /* to terminate now */
448 #endif
449 #ifdef SIGPIPE
450  { SIGPIPE, UNIX_ONLY, NULL }, /* otherwise SIGPIPE kills us */
451 #endif
452 #ifdef SIGUSR1
453  { SIGUSR1, UNIX_ONLY, NULL }, /* dump stats */
454 #endif
455 #ifdef SIGUSR2
456  { SIGUSR2, UNIX_ONLY, NULL }, /* go to loglevel debug */
457 #endif
458 #ifdef SIGHUP
459  { SIGHUP, UNIX_ONLY, NULL }, /* to reload config, retry conns, etc */
460 #endif
461 #ifdef SIGXFSZ
462  { SIGXFSZ, UNIX_ONLY, NULL }, /* handle file-too-big resource exhaustion */
463 #endif
464 #ifdef SIGCHLD
465  { SIGCHLD, UNIX_ONLY, NULL }, /* handle dns/cpu workers that exit */
466 #endif
467  /* These are controller-only */
468  { SIGNEWNYM, 0, NULL },
469  { SIGCLEARDNSCACHE, 0, NULL },
470  { SIGHEARTBEAT, 0, NULL },
471  { SIGACTIVE, 0, NULL },
472  { SIGDORMANT, 0, NULL },
473  { -1, -1, NULL }
474 };
475 
476 /** Set up the signal handler events for this process, and register them
477  * with libevent if appropriate. */
478 void
480 {
481  int i;
482  const int enabled = !get_options()->DisableSignalHandlers;
483 
484  for (i = 0; signal_handlers[i].signal_value >= 0; ++i) {
485  /* Signal handlers are only registered with libevent if they need to catch
486  * real POSIX signals. We construct these signal handler events in either
487  * case, though, so that controllers can activate them with the SIGNAL
488  * command.
489  */
490  if (enabled && signal_handlers[i].try_to_register) {
491  signal_handlers[i].signal_event =
492  tor_evsignal_new(tor_libevent_get_base(),
493  signal_handlers[i].signal_value,
495  &signal_handlers[i].signal_value);
496  if (event_add(signal_handlers[i].signal_event, NULL))
497  log_warn(LD_BUG, "Error from libevent when adding "
498  "event for signal %d",
499  signal_handlers[i].signal_value);
500  } else {
501  signal_handlers[i].signal_event =
502  tor_event_new(tor_libevent_get_base(), -1,
503  EV_SIGNAL, signal_callback,
504  &signal_handlers[i].signal_value);
505  }
506  }
507 
508 #ifdef _WIN32
509  /* Windows lacks traditional POSIX signals but WinAPI provides a function
510  * to handle control signals like Ctrl+C in the console, we can use this to
511  * simulate the SIGINT signal */
512  if (enabled) SetConsoleCtrlHandler(process_win32_console_ctrl, TRUE);
513 #endif /* defined(_WIN32) */
514 }
515 
516 /* Cause the signal handler for signal_num to be called in the event loop. */
517 void
518 activate_signal(int signal_num)
519 {
520  int i;
521  for (i = 0; signal_handlers[i].signal_value >= 0; ++i) {
522  if (signal_handlers[i].signal_value == signal_num) {
523  event_active(signal_handlers[i].signal_event, EV_SIGNAL, 1);
524  return;
525  }
526  }
527 }
528 
529 /** Main entry point for the Tor command-line client. Return 0 on "success",
530  * negative on "failure", and positive on "success and exit".
531  */
532 int
533 tor_init(int argc, char *argv[])
534 {
535  char progname[256];
537  bool running_tor = false;
538 
539  time_of_process_start = time(NULL);
541  /* Have the log set up with our application name. */
542  tor_snprintf(progname, sizeof(progname), "Tor %s", get_version());
543  log_set_application_name(progname);
544 
545  /* Initialize the history structures. */
546  rep_hist_init();
547  bwhist_init();
548  /* Initialize the service cache. */
549  addressmap_init(); /* Init the client dns cache. Do it always, since it's
550  * cheap. */
551 
552  /* Initialize the HS subsystem. */
553  hs_init();
554 
555  {
556  /* We check for the "quiet"/"hush" settings first, since they decide
557  whether we log anything at all to stdout. */
558  parsed_cmdline_t *cmdline;
559  cmdline = config_parse_commandline(argc, argv, 1);
560  if (cmdline) {
561  quiet = cmdline->quiet_level;
562  running_tor = (cmdline->command == CMD_RUN_TOR);
563  }
564  parsed_cmdline_free(cmdline);
565  }
566 
567  /* give it somewhere to log to initially */
569  quiet_level = quiet;
570 
571  {
572  const char *version = get_version();
573 
574  log_notice(LD_GENERAL, "Tor %s running on %s with Libevent %s, "
575  "%s %s, Zlib %s, Liblzma %s, Libzstd %s and %s %s as libc.",
576  version,
577  get_uname(),
581  tor_compress_supports_method(ZLIB_METHOD) ?
582  tor_compress_version_str(ZLIB_METHOD) : "N/A",
583  tor_compress_supports_method(LZMA_METHOD) ?
584  tor_compress_version_str(LZMA_METHOD) : "N/A",
585  tor_compress_supports_method(ZSTD_METHOD) ?
586  tor_compress_version_str(ZSTD_METHOD) : "N/A",
588  tor_libc_get_name() : "Unknown",
590 
591  log_notice(LD_GENERAL, "Tor can't help you if you use it wrong! "
592  "Learn how to be safe at "
593  "https://support.torproject.org/faq/staying-anonymous/");
594 
595  if (strstr(version, "alpha") || strstr(version, "beta"))
596  log_notice(LD_GENERAL, "This version is not a stable Tor release. "
597  "Expect more bugs than usual.");
598 
599  if (strlen(risky_option_list) && running_tor) {
600  log_warn(LD_GENERAL, "This build of Tor has been compiled with one "
601  "or more options that might make it less reliable or secure! "
602  "They are:%s", risky_option_list);
603  }
604 
606  }
607 
608  /* Warn _if_ the tracing subsystem is built in. */
609  tracing_log_warning();
610 
611  int init_rv = options_init_from_torrc(argc,argv);
612  if (init_rv < 0) {
613  log_err(LD_CONFIG,"Reading config failed--see warnings above.");
614  return -1;
615  } else if (init_rv > 0) {
616  // We succeeded, and should exit anyway -- probably the user just said
617  // "--version" or something like that.
618  return 1;
619  }
620 
621  /* Initialize channelpadding and circpad parameters to defaults
622  * until we get a consensus */
627 
628  /* Initialize circuit padding to defaults+torrc until we get a consensus */
630 
631  /* Initialize hidden service DoS subsystem. We need to do this once the
632  * configuration object has been set because it can be accessed. */
633  hs_dos_init();
634 
635  /* Initialize predicted ports list after loading options */
636  predicted_ports_init();
637 
638 #ifndef _WIN32
639  if (geteuid()==0)
640  log_warn(LD_GENERAL,"You are running Tor as root. You don't need to, "
641  "and you probably shouldn't.");
642 #endif
643 
644  /* Scan/clean unparseable descriptors; after reading config */
646 
647  return 0;
648 }
649 
650 /** A lockfile structure, used to prevent two Tors from messing with the
651  * data directory at once. If this variable is non-NULL, we're holding
652  * the lockfile. */
653 static tor_lockfile_t *lockfile = NULL;
654 
655 /** Try to grab the lock file described in <b>options</b>, if we do not
656  * already have it. If <b>err_if_locked</b> is true, warn if somebody else is
657  * holding the lock, and exit if we can't get it after waiting. Otherwise,
658  * return -1 if we can't get the lockfile. Return 0 on success.
659  */
660 int
661 try_locking(const or_options_t *options, int err_if_locked)
662 {
663  if (lockfile)
664  return 0;
665  else {
666  char *fname = options_get_datadir_fname(options, "lock");
667  int already_locked = 0;
668  tor_lockfile_t *lf = tor_lockfile_lock(fname, 0, &already_locked);
669  tor_free(fname);
670  if (!lf) {
671  if (err_if_locked && already_locked) {
672  int r;
673  log_warn(LD_GENERAL, "It looks like another Tor process is running "
674  "with the same data directory. Waiting 5 seconds to see "
675  "if it goes away.");
676 #ifndef _WIN32
677  sleep(5);
678 #else
679  Sleep(5000);
680 #endif
681  r = try_locking(options, 0);
682  if (r<0) {
683  log_err(LD_GENERAL, "No, it's still there. Exiting.");
684  return -1;
685  }
686  return r;
687  }
688  return -1;
689  }
690  lockfile = lf;
691  return 0;
692  }
693 }
694 
695 /** Return true iff we've successfully acquired the lock file. */
696 int
698 {
699  return lockfile != NULL;
700 }
701 
702 /** If we have successfully acquired the lock file, release it. */
703 void
705 {
706  if (lockfile) {
708  lockfile = NULL;
709  }
710 }
711 
712 /**
713  * Remove the specified file, and log a warning if the operation fails for
714  * any reason other than the file not existing. Ignores NULL filenames.
715  */
716 void
717 tor_remove_file(const char *filename)
718 {
719  if (filename && tor_unlink(filename) != 0 && errno != ENOENT) {
720  log_warn(LD_FS, "Couldn't unlink %s: %s",
721  filename, strerror(errno));
722  }
723 }
724 
725 /** Read/create keys as needed, and echo our fingerprint to stdout. */
726 static int
728 {
729  const or_options_t *options = get_options();
730  const char *arg = options->command_arg;
731  char rsa[FINGERPRINT_LEN + 1];
732  crypto_pk_t *k;
733  const ed25519_public_key_t *edkey;
734  const char *nickname = options->Nickname;
735  sandbox_disable_getaddrinfo_cache();
736 
737  bool show_rsa = !strcmp(arg, "") || !strcmp(arg, "rsa");
738  bool show_ed25519 = !strcmp(arg, "ed25519");
739  if (!show_rsa && !show_ed25519) {
740  log_err(LD_GENERAL,
741  "If you give a key type, you must specify 'rsa' or 'ed25519'. Exiting.");
742  return -1;
743  }
744 
745  if (!server_mode(options)) {
746  log_err(LD_GENERAL,
747  "Clients don't have long-term identity keys. Exiting.");
748  return -1;
749  }
750  tor_assert(nickname);
751  if (init_keys() < 0) {
752  log_err(LD_GENERAL, "Error initializing keys; exiting.");
753  return -1;
754  }
755  if (!(k = get_server_identity_key())) {
756  log_err(LD_GENERAL, "Error: missing RSA identity key.");
757  return -1;
758  }
759  if (crypto_pk_get_fingerprint(k, rsa, 1) < 0) {
760  log_err(LD_BUG, "Error computing RSA fingerprint");
761  return -1;
762  }
763  if (!(edkey = get_master_identity_key())) {
764  log_err(LD_GENERAL,"Error: missing ed25519 identity key.");
765  return -1;
766  }
767  if (show_rsa) {
768  printf("%s %s\n", nickname, rsa);
769  }
770  if (show_ed25519) {
771  char ed25519[ED25519_BASE64_LEN + 1];
772  digest256_to_base64(ed25519, (const char *) edkey->pubkey);
773  printf("%s %s\n", nickname, ed25519);
774  }
775  return 0;
776 }
777 
778 /** Entry point for password hashing: take the desired password from
779  * the command line, and print its salted hash to stdout. **/
780 static void
782 {
783 
784  char output[256];
786 
788  key[S2K_RFC2440_SPECIFIER_LEN-1] = (uint8_t)96; /* Hash 64 K of data. */
790  get_options()->command_arg, strlen(get_options()->command_arg),
791  key);
792  base16_encode(output, sizeof(output), key, sizeof(key));
793  printf("16:%s\n",output);
794 }
795 
796 /** Entry point for configuration dumping: write the configuration to
797  * stdout. */
798 static int
800 {
801  const or_options_t *options = get_options();
802  const char *arg = options->command_arg;
803  int how;
804  char *opts;
805 
806  if (!strcmp(arg, "short")) {
807  how = OPTIONS_DUMP_MINIMAL;
808  } else if (!strcmp(arg, "non-builtin")) {
809  // Deprecated since 0.4.5.1-alpha.
810  fprintf(stderr, "'non-builtin' is deprecated; use 'short' instead.\n");
811  how = OPTIONS_DUMP_MINIMAL;
812  } else if (!strcmp(arg, "full")) {
813  how = OPTIONS_DUMP_ALL;
814  } else {
815  fprintf(stderr, "No valid argument to --dump-config found!\n");
816  fprintf(stderr, "Please select 'short' or 'full'.\n");
817 
818  return -1;
819  }
820 
821  opts = options_dump(options, how);
822  printf("%s", opts);
823  tor_free(opts);
824 
825  return 0;
826 }
827 
828 static void
829 init_addrinfo(void)
830 {
831  if (! server_mode(get_options()) || get_options()->Address) {
832  /* We don't need to seed our own hostname, because we won't be calling
833  * resolve_my_address on it.
834  */
835  return;
836  }
837  char hname[256];
838 
839  // host name to sandbox
840  gethostname(hname, sizeof(hname));
841  tor_add_addrinfo(hname);
842 }
843 
844 static sandbox_cfg_t*
845 sandbox_init_filter(void)
846 {
847  const or_options_t *options = get_options();
849 
851  get_cachedir_fname("cached-status"));
852 
853 #define OPEN(name) \
854  sandbox_cfg_allow_open_filename(&cfg, tor_strdup(name))
855 
856 #define OPENDIR(dir) \
857  sandbox_cfg_allow_opendir_dirname(&cfg, tor_strdup(dir))
858 
859 #define OPEN_DATADIR(name) \
860  sandbox_cfg_allow_open_filename(&cfg, get_datadir_fname(name))
861 
862 #define OPEN_DATADIR2(name, name2) \
863  sandbox_cfg_allow_open_filename(&cfg, get_datadir_fname2((name), (name2)))
864 
865 #define OPEN_DATADIR_SUFFIX(name, suffix) do { \
866  OPEN_DATADIR(name); \
867  OPEN_DATADIR(name suffix); \
868  } while (0)
869 
870 #define OPEN_DATADIR2_SUFFIX(name, name2, suffix) do { \
871  OPEN_DATADIR2(name, name2); \
872  OPEN_DATADIR2(name, name2 suffix); \
873  } while (0)
874 
875 // KeyDirectory is a directory, but it is only opened in check_private_dir
876 // which calls open instead of opendir
877 #define OPEN_KEY_DIRECTORY() \
878  OPEN(options->KeyDirectory)
879 #define OPEN_CACHEDIR(name) \
880  sandbox_cfg_allow_open_filename(&cfg, get_cachedir_fname(name))
881 #define OPEN_CACHEDIR_SUFFIX(name, suffix) do { \
882  OPEN_CACHEDIR(name); \
883  OPEN_CACHEDIR(name suffix); \
884  } while (0)
885 #define OPEN_KEYDIR(name) \
886  sandbox_cfg_allow_open_filename(&cfg, get_keydir_fname(name))
887 #define OPEN_KEYDIR_SUFFIX(name, suffix) do { \
888  OPEN_KEYDIR(name); \
889  OPEN_KEYDIR(name suffix); \
890  } while (0)
891 
892  // DataDirectory is a directory, but it is only opened in check_private_dir
893  // which calls open instead of opendir
894  OPEN(options->DataDirectory);
895  OPEN_KEY_DIRECTORY();
896 
897  OPEN_CACHEDIR_SUFFIX("cached-certs", ".tmp");
898  OPEN_CACHEDIR_SUFFIX("cached-consensus", ".tmp");
899  OPEN_CACHEDIR_SUFFIX("unverified-consensus", ".tmp");
900  OPEN_CACHEDIR_SUFFIX("unverified-microdesc-consensus", ".tmp");
901  OPEN_CACHEDIR_SUFFIX("cached-microdesc-consensus", ".tmp");
902  OPEN_CACHEDIR_SUFFIX("cached-microdescs", ".tmp");
903  OPEN_CACHEDIR_SUFFIX("cached-microdescs.new", ".tmp");
904  OPEN_CACHEDIR_SUFFIX("cached-descriptors", ".tmp");
905  OPEN_CACHEDIR_SUFFIX("cached-descriptors.new", ".tmp");
906  OPEN_CACHEDIR("cached-descriptors.tmp.tmp");
907  OPEN_CACHEDIR_SUFFIX("cached-extrainfo", ".tmp");
908  OPEN_CACHEDIR_SUFFIX("cached-extrainfo.new", ".tmp");
909  OPEN_CACHEDIR("cached-extrainfo.tmp.tmp");
910 
911  OPEN_DATADIR_SUFFIX("state", ".tmp");
912  OPEN_DATADIR_SUFFIX("sr-state", ".tmp");
913  OPEN_DATADIR_SUFFIX("unparseable-desc", ".tmp");
914  OPEN_DATADIR_SUFFIX("v3-status-votes", ".tmp");
915  OPEN_DATADIR("key-pinning-journal");
916  OPEN("/dev/srandom");
917  OPEN("/dev/urandom");
918  OPEN("/dev/random");
919  OPEN("/etc/hosts");
920  OPEN("/proc/meminfo");
921 
922  if (options->BridgeAuthoritativeDir)
923  OPEN_DATADIR_SUFFIX("networkstatus-bridges", ".tmp");
924 
925  if (authdir_mode(options)) {
926  OPEN_DATADIR("approved-routers");
927  OPEN_DATADIR_SUFFIX("my-consensus-microdesc", ".tmp");
928  OPEN_DATADIR_SUFFIX("my-consensus-ns", ".tmp");
929  }
930 
931  if (options->ServerDNSResolvConfFile)
933  tor_strdup(options->ServerDNSResolvConfFile));
934  else
935  sandbox_cfg_allow_open_filename(&cfg, tor_strdup("/etc/resolv.conf"));
936 
937  const char *torrc_defaults_fname = get_torrc_fname(1);
938  if (torrc_defaults_fname) {
940  }
941  const char *torrc_fname = get_torrc_fname(0);
942  if (torrc_fname) {
943  sandbox_cfg_allow_open_filename(&cfg, tor_strdup(torrc_fname));
944  // allow torrc backup and torrc.tmp to make SAVECONF work
945  char *torrc_bck = NULL;
947  sandbox_cfg_allow_rename(&cfg, tor_strdup(torrc_fname), torrc_bck);
948  char *torrc_tmp = NULL;
949  tor_asprintf(&torrc_tmp, "%s.tmp", torrc_fname);
950  sandbox_cfg_allow_rename(&cfg, torrc_tmp, tor_strdup(torrc_fname));
951  sandbox_cfg_allow_open_filename(&cfg, tor_strdup(torrc_tmp));
952  // we need to stat the existing backup file
953  sandbox_cfg_allow_stat_filename(&cfg, tor_strdup(torrc_bck));
954  }
955 
956  SMARTLIST_FOREACH(options->FilesOpenedByIncludes, char *, f, {
957  if (file_status(f) == FN_DIR) {
958  OPENDIR(f);
959  } else {
960  OPEN(f);
961  }
962  });
963 
964 #define RENAME_SUFFIX(name, suffix) \
965  sandbox_cfg_allow_rename(&cfg, \
966  get_datadir_fname(name suffix), \
967  get_datadir_fname(name))
968 
969 #define RENAME_SUFFIX2(prefix, name, suffix) \
970  sandbox_cfg_allow_rename(&cfg, \
971  get_datadir_fname2(prefix, name suffix), \
972  get_datadir_fname2(prefix, name))
973 
974 #define RENAME_CACHEDIR_SUFFIX(name, suffix) \
975  sandbox_cfg_allow_rename(&cfg, \
976  get_cachedir_fname(name suffix), \
977  get_cachedir_fname(name))
978 
979 #define RENAME_KEYDIR_SUFFIX(name, suffix) \
980  sandbox_cfg_allow_rename(&cfg, \
981  get_keydir_fname(name suffix), \
982  get_keydir_fname(name))
983 
984  RENAME_CACHEDIR_SUFFIX("cached-certs", ".tmp");
985  RENAME_CACHEDIR_SUFFIX("cached-consensus", ".tmp");
986  RENAME_CACHEDIR_SUFFIX("unverified-consensus", ".tmp");
987  RENAME_CACHEDIR_SUFFIX("unverified-microdesc-consensus", ".tmp");
988  RENAME_CACHEDIR_SUFFIX("cached-microdesc-consensus", ".tmp");
989  RENAME_CACHEDIR_SUFFIX("cached-microdescs", ".tmp");
990  RENAME_CACHEDIR_SUFFIX("cached-microdescs", ".new");
991  RENAME_CACHEDIR_SUFFIX("cached-microdescs.new", ".tmp");
992  RENAME_CACHEDIR_SUFFIX("cached-descriptors", ".tmp");
993  RENAME_CACHEDIR_SUFFIX("cached-descriptors", ".new");
994  RENAME_CACHEDIR_SUFFIX("cached-descriptors.new", ".tmp");
995  RENAME_CACHEDIR_SUFFIX("cached-extrainfo", ".tmp");
996  RENAME_CACHEDIR_SUFFIX("cached-extrainfo", ".new");
997  RENAME_CACHEDIR_SUFFIX("cached-extrainfo.new", ".tmp");
998 
999  RENAME_SUFFIX("state", ".tmp");
1000  RENAME_SUFFIX("sr-state", ".tmp");
1001  RENAME_SUFFIX("unparseable-desc", ".tmp");
1002  RENAME_SUFFIX("v3-status-votes", ".tmp");
1003 
1004  if (options->BridgeAuthoritativeDir)
1005  RENAME_SUFFIX("networkstatus-bridges", ".tmp");
1006 
1007  if (authdir_mode(options)) {
1008  RENAME_SUFFIX("my-consensus-microdesc", ".tmp");
1009  RENAME_SUFFIX("my-consensus-ns", ".tmp");
1010  }
1011 
1012 #define STAT_DATADIR(name) \
1013  sandbox_cfg_allow_stat_filename(&cfg, get_datadir_fname(name))
1014 
1015 #define STAT_CACHEDIR(name) \
1016  sandbox_cfg_allow_stat_filename(&cfg, get_cachedir_fname(name))
1017 
1018 #define STAT_DATADIR2(name, name2) \
1019  sandbox_cfg_allow_stat_filename(&cfg, get_datadir_fname2((name), (name2)))
1020 
1021 #define STAT_KEY_DIRECTORY() \
1022  sandbox_cfg_allow_stat_filename(&cfg, tor_strdup(options->KeyDirectory))
1023 
1024  STAT_DATADIR(NULL);
1025  STAT_DATADIR("lock");
1026  STAT_DATADIR("state");
1027  STAT_DATADIR("router-stability");
1028 
1029  STAT_CACHEDIR("cached-extrainfo.new");
1030 
1031  {
1032  smartlist_t *files = smartlist_new();
1034  SMARTLIST_FOREACH(files, char *, file_name, {
1035  /* steals reference */
1036  sandbox_cfg_allow_open_filename(&cfg, file_name);
1037  });
1038  smartlist_free(files);
1039  }
1040 
1041  {
1042  smartlist_t *files = smartlist_new();
1043  smartlist_t *dirs = smartlist_new();
1045  SMARTLIST_FOREACH(files, char *, file_name, {
1046  char *tmp_name = NULL;
1047  tor_asprintf(&tmp_name, "%s.tmp", file_name);
1048  sandbox_cfg_allow_rename(&cfg,
1049  tor_strdup(tmp_name), tor_strdup(file_name));
1050  /* steals references */
1051  sandbox_cfg_allow_open_filename(&cfg, file_name);
1052  sandbox_cfg_allow_open_filename(&cfg, tmp_name);
1053  });
1054  SMARTLIST_FOREACH(dirs, char *, dir, {
1055  /* steals reference */
1057  });
1058  smartlist_free(files);
1059  smartlist_free(dirs);
1060  }
1061 
1062  {
1063  char *fname;
1064  if ((fname = get_controller_cookie_file_name())) {
1065  sandbox_cfg_allow_open_filename(&cfg, fname);
1066  }
1067  if ((fname = get_ext_or_auth_cookie_file_name())) {
1068  sandbox_cfg_allow_open_filename(&cfg, fname);
1069  }
1070  }
1071 
1073  if (!port->is_unix_addr)
1074  continue;
1075  /* When we open an AF_UNIX address, we want permission to open the
1076  * directory that holds it. */
1077  char *dirname = tor_strdup(port->unix_addr);
1078  if (get_parent_directory(dirname) == 0) {
1079  OPENDIR(dirname);
1080  }
1081  tor_free(dirname);
1082  sandbox_cfg_allow_chmod_filename(&cfg, tor_strdup(port->unix_addr));
1083  sandbox_cfg_allow_chown_filename(&cfg, tor_strdup(port->unix_addr));
1084  } SMARTLIST_FOREACH_END(port);
1085 
1086  if (options->DirPortFrontPage) {
1088  tor_strdup(options->DirPortFrontPage));
1089  }
1090 
1091  // orport
1092  if (server_mode(get_options())) {
1093 
1094  OPEN_KEYDIR_SUFFIX("secret_id_key", ".tmp");
1095  OPEN_KEYDIR_SUFFIX("secret_onion_key", ".tmp");
1096  OPEN_KEYDIR_SUFFIX("secret_onion_key_ntor", ".tmp");
1097  OPEN_KEYDIR("secret_id_key.old");
1098  OPEN_KEYDIR("secret_onion_key.old");
1099  OPEN_KEYDIR("secret_onion_key_ntor.old");
1100 
1101  OPEN_KEYDIR_SUFFIX("ed25519_master_id_secret_key", ".tmp");
1102  OPEN_KEYDIR_SUFFIX("ed25519_master_id_secret_key_encrypted", ".tmp");
1103  OPEN_KEYDIR_SUFFIX("ed25519_master_id_public_key", ".tmp");
1104  OPEN_KEYDIR_SUFFIX("ed25519_signing_secret_key", ".tmp");
1105  OPEN_KEYDIR_SUFFIX("ed25519_signing_secret_key_encrypted", ".tmp");
1106  OPEN_KEYDIR_SUFFIX("ed25519_signing_public_key", ".tmp");
1107  OPEN_KEYDIR_SUFFIX("ed25519_signing_cert", ".tmp");
1108 
1109  OPEN_DATADIR2_SUFFIX("stats", "bridge-stats", ".tmp");
1110  OPEN_DATADIR2_SUFFIX("stats", "dirreq-stats", ".tmp");
1111 
1112  OPEN_DATADIR2_SUFFIX("stats", "entry-stats", ".tmp");
1113  OPEN_DATADIR2_SUFFIX("stats", "exit-stats", ".tmp");
1114  OPEN_DATADIR2_SUFFIX("stats", "buffer-stats", ".tmp");
1115  OPEN_DATADIR2_SUFFIX("stats", "conn-stats", ".tmp");
1116  OPEN_DATADIR2_SUFFIX("stats", "hidserv-stats", ".tmp");
1117  OPEN_DATADIR2_SUFFIX("stats", "hidserv-v3-stats", ".tmp");
1118 
1119  OPEN_DATADIR("approved-routers");
1120  OPEN_DATADIR_SUFFIX("fingerprint", ".tmp");
1121  OPEN_DATADIR_SUFFIX("fingerprint-ed25519", ".tmp");
1122  OPEN_DATADIR_SUFFIX("hashed-fingerprint", ".tmp");
1123  OPEN_DATADIR_SUFFIX("router-stability", ".tmp");
1124 
1125  OPEN("/etc/resolv.conf");
1126 
1127  RENAME_SUFFIX("fingerprint", ".tmp");
1128  RENAME_SUFFIX("fingerprint-ed25519", ".tmp");
1129  RENAME_KEYDIR_SUFFIX("secret_onion_key_ntor", ".tmp");
1130 
1131  RENAME_KEYDIR_SUFFIX("secret_id_key", ".tmp");
1132  RENAME_KEYDIR_SUFFIX("secret_id_key.old", ".tmp");
1133  RENAME_KEYDIR_SUFFIX("secret_onion_key", ".tmp");
1134  RENAME_KEYDIR_SUFFIX("secret_onion_key.old", ".tmp");
1135 
1136  RENAME_SUFFIX2("stats", "bridge-stats", ".tmp");
1137  RENAME_SUFFIX2("stats", "dirreq-stats", ".tmp");
1138  RENAME_SUFFIX2("stats", "entry-stats", ".tmp");
1139  RENAME_SUFFIX2("stats", "exit-stats", ".tmp");
1140  RENAME_SUFFIX2("stats", "buffer-stats", ".tmp");
1141  RENAME_SUFFIX2("stats", "conn-stats", ".tmp");
1142  RENAME_SUFFIX2("stats", "hidserv-stats", ".tmp");
1143  RENAME_SUFFIX2("stats", "hidserv-v3-stats", ".tmp");
1144  RENAME_SUFFIX("hashed-fingerprint", ".tmp");
1145  RENAME_SUFFIX("router-stability", ".tmp");
1146 
1147  RENAME_KEYDIR_SUFFIX("ed25519_master_id_secret_key", ".tmp");
1148  RENAME_KEYDIR_SUFFIX("ed25519_master_id_secret_key_encrypted", ".tmp");
1149  RENAME_KEYDIR_SUFFIX("ed25519_master_id_public_key", ".tmp");
1150  RENAME_KEYDIR_SUFFIX("ed25519_signing_secret_key", ".tmp");
1151  RENAME_KEYDIR_SUFFIX("ed25519_signing_cert", ".tmp");
1152 
1153  sandbox_cfg_allow_rename(&cfg,
1154  get_keydir_fname("secret_onion_key"),
1155  get_keydir_fname("secret_onion_key.old"));
1156  sandbox_cfg_allow_rename(&cfg,
1157  get_keydir_fname("secret_onion_key_ntor"),
1158  get_keydir_fname("secret_onion_key_ntor.old"));
1159 
1160  STAT_KEY_DIRECTORY();
1161  OPEN_DATADIR("stats");
1162  STAT_DATADIR("stats");
1163  STAT_DATADIR2("stats", "dirreq-stats");
1164 
1166  }
1167 
1168  init_addrinfo();
1169 
1170  return cfg;
1171 }
1172 
1173 int
1174 run_tor_main_loop(void)
1175 {
1176  handle_signals();
1179 
1180  /* load the private keys, if we're supposed to have them, and set up the
1181  * TLS context. */
1182  if (! client_identity_key_is_set()) {
1183  if (init_keys() < 0) {
1184  log_err(LD_OR, "Error initializing keys; exiting");
1185  return -1;
1186  }
1187  }
1188 
1189  /* Set up our buckets */
1191 
1192  /* initialize the bootstrap status events to know we're starting up */
1193  control_event_bootstrap(BOOTSTRAP_STATUS_STARTING, 0);
1194 
1195  /* Initialize the keypinning log. */
1196  if (authdir_mode_v3(get_options())) {
1197  char *fname = get_datadir_fname("key-pinning-journal");
1198  int r = 0;
1199  if (keypin_load_journal(fname)<0) {
1200  log_err(LD_DIR, "Error loading key-pinning journal: %s",strerror(errno));
1201  r = -1;
1202  }
1203  if (keypin_open_journal(fname)<0) {
1204  log_err(LD_DIR, "Error opening key-pinning journal: %s",strerror(errno));
1205  r = -1;
1206  }
1207  tor_free(fname);
1208  if (r)
1209  return r;
1210  }
1211  {
1212  /* This is the old name for key-pinning-journal. These got corrupted
1213  * in a couple of cases by #16530, so we started over. See #16580 for
1214  * the rationale and for other options we didn't take. We can remove
1215  * this code once all the authorities that ran 0.2.7.1-alpha-dev are
1216  * upgraded.
1217  */
1218  char *fname = get_datadir_fname("key-pinning-entries");
1219  unlink(fname);
1220  tor_free(fname);
1221  }
1222 
1223  if (trusted_dirs_reload_certs()) {
1224  log_warn(LD_DIR,
1225  "Couldn't load all cached v3 certificates. Starting anyway.");
1226  }
1228  return -1;
1229  }
1230  /* load the routers file, or assign the defaults. */
1231  if (router_reload_router_list()) {
1232  return -1;
1233  }
1234  /* load the networkstatuses. (This launches a download for new routers as
1235  * appropriate.)
1236  */
1237  const time_t now = time(NULL);
1238  directory_info_has_arrived(now, 1, 0);
1239 
1241  /* launch cpuworkers. Need to do this *after* we've read the onion key. */
1242  cpu_init();
1243  }
1245 
1246  /* Setup shared random protocol subsystem. */
1247  if (authdir_mode_v3(get_options())) {
1248  if (sr_init(1) < 0) {
1249  return -1;
1250  }
1251  }
1252 
1253  /* initialize dns resolve map, spawn workers if needed */
1254  if (dns_init() < 0) {
1255  if (get_options()->ServerDNSAllowBrokenConfig)
1256  log_warn(LD_GENERAL, "Couldn't set up any working nameservers. "
1257  "Network not up yet? Will try again soon.");
1258  else {
1259  log_err(LD_GENERAL,"Error initializing dns subsystem; exiting. To "
1260  "retry instead, set the ServerDNSAllowBrokenResolvConf option.");
1261  }
1262  }
1263 
1264 #ifdef HAVE_SYSTEMD
1265  {
1266  const int r = sd_notify(0, "READY=1");
1267  if (r < 0) {
1268  log_warn(LD_GENERAL, "Unable to send readiness to systemd: %s",
1269  strerror(r));
1270  } else if (r > 0) {
1271  log_notice(LD_GENERAL, "Signaled readiness to systemd");
1272  } else {
1273  log_info(LD_GENERAL, "Systemd NOTIFY_SOCKET not present.");
1274  }
1275  }
1276 #endif /* defined(HAVE_SYSTEMD) */
1277 
1278  return do_main_loop();
1279 }
1280 
1281 /** Install the publish/subscribe relationships for all the subsystems. */
1282 void
1284 {
1285  pubsub_builder_t *builder = pubsub_builder_new();
1286  int r = subsystems_add_pubsub(builder);
1287  tor_assert(r == 0);
1288  r = tor_mainloop_connect_pubsub(builder); // consumes builder
1289  tor_assert(r == 0);
1290 }
1291 
1292 /** Connect the mainloop to its publish/subscribe message delivery events if
1293  * appropriate, and configure the global channels appropriately. */
1294 void
1296 {
1297  if (get_options()->command == CMD_RUN_TOR) {
1299  /* XXXX For each pubsub channel, its delivery strategy should be set at
1300  * this XXXX point, using tor_mainloop_set_delivery_strategy().
1301  */
1304  }
1305 }
1306 
1307 /* Main entry point for the Tor process. Called from tor_main(), and by
1308  * anybody embedding Tor. */
1309 int
1311 {
1312  int result = 0;
1313 
1314 #ifdef EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED
1315  event_set_mem_functions(tor_malloc_, tor_realloc_, tor_free_);
1316 #endif
1317 
1318  subsystems_init();
1319 
1321 
1322  int argc = tor_cfg->argc + tor_cfg->argc_owned;
1323  char **argv = tor_calloc(argc, sizeof(char*));
1324  memcpy(argv, tor_cfg->argv, tor_cfg->argc*sizeof(char*));
1325  if (tor_cfg->argc_owned)
1326  memcpy(argv + tor_cfg->argc, tor_cfg->argv_owned,
1327  tor_cfg->argc_owned*sizeof(char*));
1328 
1329  int done = 0;
1330  result = nt_service_parse_options(argc, argv, &done);
1331  if (POSSIBLE(done))
1332  goto done;
1333 
1334  pubsub_install();
1335 
1336  {
1337  int init_rv = tor_init(argc, argv);
1338  if (init_rv) {
1339  tor_free_all(0);
1340  result = (init_rv < 0) ? -1 : 0;
1341  goto done;
1342  }
1343  }
1344 
1345  pubsub_connect();
1346 
1347  if (get_options()->Sandbox && get_options()->command == CMD_RUN_TOR) {
1348 #ifdef ENABLE_FRAGILE_HARDENING
1349  log_warn(LD_CONFIG, "Sandbox is enabled but this Tor was built using "
1350  "fragile compiler hardening. The sandbox may be unable to filter "
1351  "requests to open files and directories and its overall "
1352  "effectiveness will be reduced.");
1353 #endif
1354 
1355  sandbox_cfg_t* cfg = sandbox_init_filter();
1356 
1357  if (sandbox_init(cfg)) {
1358  tor_free(argv);
1359  log_err(LD_BUG,"Failed to create syscall sandbox filter");
1360  tor_free_all(0);
1361  return -1;
1362  }
1363  tor_make_getaddrinfo_cache_active();
1364 
1365  // registering libevent rng
1366 #ifdef HAVE_EVUTIL_SECURE_RNG_SET_URANDOM_DEVICE_FILE
1367  evutil_secure_rng_set_urandom_device_file(
1368  (char*) sandbox_intern_string("/dev/urandom"));
1369 #endif
1370  }
1371 
1372  switch (get_options()->command) {
1373  case CMD_RUN_TOR:
1374  nt_service_set_state(SERVICE_RUNNING);
1375  result = run_tor_main_loop();
1376  break;
1377  case CMD_KEYGEN:
1378  result = load_ed_keys(get_options(), time(NULL)) < 0;
1379  break;
1380  case CMD_KEY_EXPIRATION:
1381  init_keys();
1382  result = log_cert_expiration();
1383  break;
1384  case CMD_LIST_FINGERPRINT:
1385  result = do_list_fingerprint();
1386  break;
1387  case CMD_HASH_PASSWORD:
1388  do_hash_password();
1389  result = 0;
1390  break;
1391  case CMD_VERIFY_CONFIG:
1392  if (quiet_level == QUIET_NONE)
1393  printf("Configuration was valid\n");
1394  result = 0;
1395  break;
1396  case CMD_DUMP_CONFIG:
1397  result = do_dump_config();
1398  break;
1399  case CMD_RUN_UNITTESTS: /* only set by test.c */
1400  case CMD_IMMEDIATE: /* Handled in config.c */
1401  default:
1402  log_warn(LD_BUG,"Illegal command number %d: internal error.",
1403  get_options()->command);
1404  result = -1;
1405  }
1406  tor_cleanup();
1407  done:
1408  tor_free(argv);
1409  return result;
1410 }
void addressmap_init(void)
Definition: addressmap.c:90
void addressmap_clear_transient(void)
Definition: addressmap.c:311
Header for addressmap.c.
time_t approx_time(void)
Definition: approx_time.c:32
int trusted_dirs_reload_certs(void)
Definition: authcert.c:324
Header file for authcert.c.
int authdir_mode(const or_options_t *options)
Definition: authmode.c:25
Header file for directory authority mode.
void base16_encode(char *dest, size_t destlen, const char *src, size_t srclen)
Definition: binascii.c:478
size_t buf_allocation(const buf_t *buf)
Definition: buffers.c:401
Header file for buffers.c.
void bwhist_init(void)
Definition: bwhist.c:139
Header for feature/stats/bwhist.c.
void channel_dumpstats(int severity)
Definition: channel.c:2075
void channel_listener_dumpstats(int severity)
Definition: channel.c:2106
Header file for channel.c.
void channelpadding_new_consensus_params(const networkstatus_t *ns)
uint64_t stats_n_padding_cells_processed
Definition: channeltls.c:82
void circuit_mark_all_dirty_circs_as_unusable(void)
Definition: circuitlist.c:2077
void circuit_dump_by_conn(connection_t *conn, int severity)
Definition: circuitlist.c:1390
Header file for circuitlist.c.
void circpad_machines_init(void)
void circpad_new_consensus_params(const networkstatus_t *ns)
Header file for circuitpadding.c.
uint64_t stats_n_created_cells_processed
Definition: command.c:70
uint64_t stats_n_destroy_cells_processed
Definition: command.c:74
uint64_t stats_n_relay_cells_processed
Definition: command.c:72
uint64_t stats_n_create_cells_processed
Definition: command.c:68
Header file for command.c.
#define POSSIBLE(expr)
struct event_base * tor_libevent_get_base(void)
const char * tor_libevent_get_version_str(void)
Header for compat_libevent.c.
int tor_compress_supports_method(compress_method_t method)
Definition: compress.c:304
void tor_compress_log_init_warnings(void)
Definition: compress.c:682
const char * tor_compress_version_str(compress_method_t method)
Definition: compress.c:417
Headers for compress.c.
const smartlist_t * get_configured_ports(void)
Definition: config.c:6674
parsed_cmdline_t * config_parse_commandline(int argc, char **argv, int ignore_errors)
Definition: config.c:2522
int options_init_from_torrc(int argc, char **argv)
Definition: config.c:4435
int quiet
Definition: config.c:2451
const or_options_t * get_options(void)
Definition: config.c:926
static char * torrc_defaults_fname
Definition: config.c:884
void init_protocol_warning_severity_level(void)
Definition: config.c:1168
static char * torrc_fname
Definition: config.c:882
char * options_dump(const or_options_t *options, int how_to_dump)
Definition: config.c:2911
const char * get_torrc_fname(int defaults_fname)
Definition: config.c:4725
int set_options(or_options_t *new_val, char **msg)
Definition: config.c:962
tor_cmdline_mode_t command
Definition: config.c:2449
Header file for config.c.
#define CONFIG_BACKUP_PATTERN
Definition: config.h:48
Header for confline.c.
void congestion_control_new_consensus_params(const networkstatus_t *ns)
Public APIs for congestion control.
void flow_control_new_consensus_params(const networkstatus_t *ns)
APIs for stream flow control on congestion controlled circuits.
int connection_is_listener(connection_t *conn)
Definition: connection.c:5025
void connection_dump_buffer_mem_stats(int severity)
Definition: connection.c:5611
void connection_bucket_init(void)
Definition: connection.c:3830
const char * connection_describe(const connection_t *conn)
Definition: connection.c:546
Header file for connection.c.
#define CONN_TYPE_OR
Definition: connection.h:44
or_connection_t * TO_OR_CONN(connection_t *c)
Header file for connection_or.c.
void consdiffmgr_enable_background_compression(void)
Definition: consdiffmgr.c:1918
int consdiffmgr_register_with_sandbox(struct sandbox_cfg_elem_t **cfg)
Definition: consdiffmgr.c:857
Header for consdiffmgr.c.
Header file for control.c.
char * get_controller_cookie_file_name(void)
Definition: control_auth.c:48
Header file for control_auth.c.
void control_event_bootstrap(bootstrap_status_t status, int progress)
int control_event_signal(uintptr_t signal_num)
Header file for control_events.c.
void cpu_init(void)
Definition: cpuworker.c:120
void cpuworker_log_onionskin_overhead(int severity, int onionskin_type, const char *onionskin_type_name)
Definition: cpuworker.c:345
void cpuworkers_rotate_keyinfo(void)
Definition: cpuworker.c:241
Header file for cpuworker.c.
void digest256_to_base64(char *d64, const char *digest)
Header for crypto_format.c.
const char * crypto_get_library_name(void)
Definition: crypto_init.c:178
const char * crypto_get_library_version_string(void)
Definition: crypto_init.c:191
Headers for crypto_init.c.
void crypto_rand(char *to, size_t n)
Definition: crypto_rand.c:479
Common functions for using (pseudo-)random number generators.
int crypto_pk_get_fingerprint(crypto_pk_t *pk, char *fp_out, int add_space)
Definition: crypto_rsa.c:229
#define FINGERPRINT_LEN
Definition: crypto_rsa.h:34
void secret_to_key_rfc2440(char *key_out, size_t key_out_len, const char *secret, size_t secret_len, const char *s2k_specifier)
Definition: crypto_s2k.c:205
Header for crypto_s2k.c.
#define S2K_RFC2440_SPECIFIER_LEN
Definition: crypto_s2k.h:21
#define DIGEST_LEN
Definition: digest_sizes.h:20
void router_reset_status_download_failures(void)
Definition: dirlist.c:151
int dns_init(void)
Definition: dns.c:232
void dump_dns_mem_usage(int severity)
Definition: dns.c:2215
int dns_reset(void)
Definition: dns.c:245
Header file for dns.c.
char * get_ext_or_auth_cookie_file_name(void)
Definition: ext_orport.c:127
Header for ext_orport.c.
int tor_unlink(const char *pathname)
Definition: files.c:154
int accounting_record_bandwidth_usage(time_t now, or_state_t *state)
Definition: hibernate.c:705
int accounting_is_enabled(const or_options_t *options)
Definition: hibernate.c:305
void hibernate_begin_shutdown(void)
Definition: hibernate.c:927
Header file for hibernate.c.
void hs_init(void)
Definition: hs_common.c:1700
void hs_dos_init(void)
Definition: hs_dos.c:225
Header file containing denial of service defenses for the HS subsystem for all versions.
void hs_service_lists_fnames_for_sandbox(smartlist_t *file_list, smartlist_t *dir_list)
Definition: hs_service.c:4073
void hs_service_dump_stats(int severity)
Definition: hs_service.c:4250
Header file containing service data for the HS subsystem.
int keypin_load_journal(const char *fname)
Definition: keypin.c:448
int keypin_open_journal(const char *fname)
Definition: keypin.c:301
Header for keypin.c.
const char * tor_libc_get_name(void)
Definition: libc.c:32
const char * tor_libc_get_version_str(void)
Definition: libc.c:47
Header for lib/osinfo/libc.c.
tor_lockfile_t * tor_lockfile_lock(const char *filename, int blocking, int *locked_out)
Definition: lockfile.c:63
void tor_lockfile_unlock(tor_lockfile_t *lockfile)
Definition: lockfile.c:121
Header for lockfile.c.
void tor_log(int severity, log_domain_mask_t domain, const char *format,...)
Definition: log.c:590
void truncate_logs(void)
Definition: log.c:1456
void switch_logs_debug(void)
Definition: log.c:1441
int get_min_log_level(void)
Definition: log.c:1426
void log_set_application_name(const char *name)
Definition: log.c:211
void tor_log_get_logfile_names(smartlist_t *out)
Definition: log.c:683
#define LD_OR
Definition: log.h:92
#define LD_FS
Definition: log.h:70
#define LD_BUG
Definition: log.h:86
#define LD_NET
Definition: log.h:66
#define LD_GENERAL
Definition: log.h:62
#define LD_DIR
Definition: log.h:88
#define LD_CONFIG
Definition: log.h:68
#define LOG_INFO
Definition: log.h:45
static tor_lockfile_t * lockfile
Definition: main.c:653
int tor_run_main(const tor_main_configuration_t *tor_cfg)
Definition: main.c:1310
static int do_dump_config(void)
Definition: main.c:799
static int do_list_fingerprint(void)
Definition: main.c:727
struct event * signal_event
Definition: main.c:441
void release_lockfile(void)
Definition: main.c:704
static void do_hash_password(void)
Definition: main.c:781
int tor_init(int argc, char *argv[])
Definition: main.c:533
int try_locking(const or_options_t *options, int err_if_locked)
Definition: main.c:661
static void process_signal(int sig)
Definition: main.c:215
static void dumpstats(int severity)
Definition: main.c:327
int have_lockfile(void)
Definition: main.c:697
static void dumpmemusage(int severity)
Definition: main.c:314
int signal_value
Definition: main.c:436
int try_to_register
Definition: main.c:439
static void signal_callback(evutil_socket_t fd, short events, void *arg)
Definition: main.c:202
void tor_remove_file(const char *filename)
Definition: main.c:717
static int do_hup(void)
Definition: main.c:114
void handle_signals(void)
Definition: main.c:479
void pubsub_install(void)
Definition: main.c:1283
void pubsub_connect(void)
Definition: main.c:1295
Header file for main.c.
uint64_t get_bytes_read(void)
Definition: mainloop.c:455
void update_current_time(time_t now)
Definition: mainloop.c:2216
void do_signewnym(time_t now)
Definition: mainloop.c:1316
void initialize_mainloop_events(void)
Definition: mainloop.c:2351
int do_main_loop(void)
Definition: mainloop.c:2365
void schedule_rescan_periodic_events(void)
Definition: mainloop.c:1575
void tor_shutdown_event_loop_and_exit(int exitcode)
Definition: mainloop.c:763
void tor_init_connection_lists(void)
Definition: mainloop.c:404
smartlist_t * get_connection_array(void)
Definition: mainloop.c:443
void directory_info_has_arrived(time_t now, int from_cache, int suppress_logs)
Definition: mainloop.c:1114
uint64_t get_bytes_written(void)
Definition: mainloop.c:465
time_t time_of_process_start
Definition: mainloop.c:142
Header file for mainloop.c.
int tor_mainloop_connect_pubsub(struct pubsub_builder_t *builder)
void tor_mainloop_connect_pubsub_events(void)
int tor_mainloop_set_delivery_strategy(const char *msg_channel_name, deliv_strategy_t strategy)
Header for mainloop_pubsub.c.
@ DELIV_IMMEDIATE
void tor_free_(void *mem)
Definition: malloc.c:227
void * tor_realloc_(void *ptr, size_t size)
Definition: malloc.c:118
void * tor_malloc_(size_t size)
Definition: malloc.c:32
#define tor_free(p)
Definition: malloc.h:56
Header for meminfo.c.
int net_is_disabled(void)
Definition: netstatus.c:25
void set_network_participation(bool participation)
Definition: netstatus.c:101
void reset_user_activity(time_t now)
Definition: netstatus.c:82
void note_user_activity(time_t now)
Definition: netstatus.c:63
Header for netstatus.c.
void update_networkstatus_downloads(time_t now)
int router_reload_consensus_networkstatus(void)
Header file for networkstatus.c.
Header file for ntmain.c.
Master header file for Tor-specific functionality.
#define RELAY_PAYLOAD_SIZE
Definition: or.h:485
OR connection structure.
int get_parent_directory(char *fname)
Definition: path.c:195
Listener port configuration structure.
Header file for predict_ports.c.
int tor_asprintf(char **strp, const char *fmt,...)
Definition: printf.c:75
int tor_snprintf(char *str, size_t size, const char *format,...)
Definition: printf.c:27
int dirserv_load_fingerprint_file(void)
Header file for process_descs.c.
pubsub_builder_t * pubsub_builder_new(void)
Definition: pubsub_build.c:56
Header used for constructing the OO publish-subscribe facility.
struct pubsub_builder_t pubsub_builder_t
Definition: pubsub_build.h:28
quiet_level_t quiet_level
Definition: quiet_level.c:20
void add_default_log_for_quiet_level(quiet_level_t quiet)
Definition: quiet_level.c:24
Declare the quiet_level enumeration and global.
quiet_level_t
Definition: quiet_level.h:16
@ QUIET_NONE
Definition: quiet_level.h:18
uint64_t stats_n_data_cells_received
Definition: relay.c:2123
void dump_cell_pool_usage(int severity)
Definition: relay.c:2600
uint64_t stats_n_relay_cells_relayed
Definition: relay.c:123
uint64_t stats_n_data_cells_packaged
Definition: relay.c:2117
uint64_t stats_n_data_bytes_received
Definition: relay.c:2127
uint64_t stats_n_relay_cells_delivered
Definition: relay.c:127
uint64_t stats_n_data_bytes_packaged
Definition: relay.c:2121
Header file for relay.c.
uint64_t rephist_total_alloc
Definition: rephist.c:95
void rep_hist_init(void)
Definition: rephist.c:622
void rep_hist_dump_stats(time_t now, int severity)
Definition: rephist.c:943
uint32_t rephist_total_num
Definition: rephist.c:97
Header file for rephist.c.
Header for resolve.c.
const char risky_option_list[]
Definition: risky_options.c:18
Header for risky_options.c.
void router_reset_warnings(void)
Definition: router.c:3588
int init_keys(void)
Definition: router.c:962
int client_identity_key_is_set(void)
Definition: router.c:441
int load_ed_keys(const or_options_t *options, time_t now)
Definition: routerkeys.c:55
int log_cert_expiration(void)
Definition: routerkeys.c:606
int generate_ed_link_cert(const or_options_t *options, time_t now, int force)
Definition: routerkeys.c:365
Header for routerkeys.c.
void dump_routerlist_mem_usage(int severity)
Definition: routerlist.c:1058
int router_reload_router_list(void)
Definition: routerlist.c:458
void routerlist_reset_warnings(void)
Definition: routerlist.c:1531
void router_reset_descriptor_download_failures(void)
Definition: routerlist.c:2927
Header file for routerlist.c.
int dir_server_mode(const or_options_t *options)
Definition: routermode.c:23
int server_mode(const or_options_t *options)
Definition: routermode.c:34
Header file for routermode.c.
void routerparse_init(void)
Definition: routerparse.c:1246
Header file for routerparse.c.
int sandbox_cfg_allow_open_filename(sandbox_cfg_t **cfg, char *file)
Definition: sandbox.c:2134
int sandbox_cfg_allow_stat_filename(sandbox_cfg_t **cfg, char *file)
Definition: sandbox.c:2155
int sandbox_init(sandbox_cfg_t *cfg)
Definition: sandbox.c:2110
sandbox_cfg_t * sandbox_cfg_new(void)
Definition: sandbox.c:2104
int sandbox_cfg_allow_openat_filename(sandbox_cfg_t **cfg, char *file)
Definition: sandbox.c:2141
Header file for sandbox.c.
struct sandbox_cfg_elem_t sandbox_cfg_t
Definition: sandbox.h:35
#define sandbox_intern_string(s)
Definition: sandbox.h:110
int sr_init(int save_to_disk)
This file contains ABI/API of the shared random protocol defined in proposal #250....
void tor_free_all(int postfork)
Definition: shutdown.c:109
void tor_cleanup(void)
Definition: shutdown.c:58
Header file for shutdown.c.
smartlist_t * smartlist_new(void)
#define SMARTLIST_FOREACH_BEGIN(sl, type, var)
#define SMARTLIST_FOREACH(sl, type, var, cmd)
or_state_t * get_or_state(void)
Definition: statefile.c:220
Header for statefile.c.
int log_heartbeat(time_t now)
Definition: status.c:183
Header for status.c.
struct tor_tls_t * tls
char * command_arg
Definition: or_options_st.h:69
int DisableSignalHandlers
char * ServerDNSResolvConfFile
struct smartlist_t * FilesOpenedByIncludes
char * Nickname
Definition: or_options_st.h:97
int ReloadTorrcOnSIGHUP
char * DirPortFrontPage
char * DataDirectory
Definition: or_options_st.h:84
int BridgeAuthoritativeDir
quiet_level_t quiet_level
Definition: config.h:203
tor_cmdline_mode_t command
Definition: config.h:199
int subsystems_add_pubsub(pubsub_builder_t *builder)
Definition: subsysmgr.c:195
int subsystems_init(void)
Definition: subsysmgr.c:114
Header for subsysmgr.c.
void timers_initialize(void)
Definition: timers.c:205
Header for timers.c.
Public C API for the Tor network service.
Internal declarations for in-process Tor API.
@ CMD_HASH_PASSWORD
@ CMD_LIST_FINGERPRINT
@ CMD_VERIFY_CONFIG
@ CMD_RUN_TOR
@ CMD_KEY_EXPIRATION
@ CMD_KEYGEN
@ CMD_DUMP_CONFIG
@ CMD_IMMEDIATE
@ CMD_RUN_UNITTESTS
Headers for tortls.c.
int tor_tls_get_buffer_sizes(tor_tls_t *tls, size_t *rbuf_capacity, size_t *rbuf_bytes, size_t *wbuf_capacity, size_t *wbuf_bytes)
Definition: tortls_nss.c:694
Header for version.c.
const char * get_version(void)
Definition: version.c:38
Header for trace.c.
const char * get_uname(void)
Definition: uname.c:67
Header for uname.c.
#define tor_assert(expr)
Definition: util_bug.h:102
void notify_pending_waitpid_callbacks(void)
Definition: waitpid.c:141
Headers for waitpid.c.
#define ED25519_BASE64_LEN
Definition: x25519_sizes.h:43