Tor 0.4.9.2-alpha-dev
All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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"
17#include "app/main/main.h"
18#include "app/main/ntmain.h"
20#include "app/main/shutdown.h"
21#include "app/main/subsysmgr.h"
27#include "core/or/channel.h"
28#include "core/or/channelpadding.h"
32#include "core/or/circuitlist.h"
33#include "core/or/command.h"
35#include "core/or/relay.h"
36#include "core/or/status.h"
37#include "feature/api/tor_api.h"
48#include "feature/hs/hs_dos.h"
53#include "feature/relay/dns.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"
79#include "lib/evloop/timers.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
107static void dumpmemusage(int severity);
108static void dumpstats(int severity); /* log stats */
109static 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. */
113static int
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)
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 */
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())
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 if (load_family_id_keys(options,
192 log_warn(LD_OR, "Problem reloading family ID keys; "
193 "still using old keys.");
194 }
195
196 /* Update cpuworker and dnsworker processes, so they get up-to-date
197 * configuration options. */
199 dns_reset();
200 }
201 return 0;
202}
203
204/** Libevent callback: invoked when we get a signal.
205 */
206static void
207signal_callback(evutil_socket_t fd, short events, void *arg)
208{
209 const int *sigptr = arg;
210 const int sig = *sigptr;
211 (void)fd;
212 (void)events;
213
214 update_current_time(time(NULL));
215 process_signal(sig);
216}
217
218/** Do the work of acting on a signal received in <b>sig</b> */
219static void
221{
222 switch (sig)
223 {
224 case SIGTERM:
225 log_notice(LD_GENERAL,"Catching signal TERM, exiting cleanly.");
227 break;
228 case SIGINT:
229 if (!server_mode(get_options())) { /* do it now */
230 log_notice(LD_GENERAL,"Interrupt: exiting cleanly.");
232 return;
233 }
234#ifdef HAVE_SYSTEMD
235 sd_notify(0, "STOPPING=1");
236#endif
238 break;
239#ifdef SIGPIPE
240 case SIGPIPE:
241 log_debug(LD_GENERAL,"Caught SIGPIPE. Ignoring.");
242 break;
243#endif
244 case SIGUSR1:
245 /* prefer to log it at INFO, but make sure we always see it */
248 break;
249 case SIGUSR2:
251 log_debug(LD_GENERAL,"Caught USR2, going to loglevel debug. "
252 "Send HUP to change back.");
254 break;
255 case SIGHUP:
256#ifdef HAVE_SYSTEMD
257 sd_notify(0, "RELOADING=1");
258#endif
259 if (do_hup() < 0) {
260 log_warn(LD_CONFIG,"Restart failed (config error?). Exiting.");
262 return;
263 }
264#ifdef HAVE_SYSTEMD
265 sd_notify(0, "READY=1");
266#endif
268 break;
269#ifdef SIGCHLD
270 case SIGCHLD:
272 break;
273#endif
274 case SIGNEWNYM: {
275 do_signewnym(time(NULL));
276 break;
277 }
278 case SIGCLEARDNSCACHE:
281 break;
282 case SIGHEARTBEAT:
283 log_heartbeat(time(NULL));
285 break;
286 case SIGACTIVE:
287 /* "SIGACTIVE" counts as ersatz user activity. */
290 break;
291 case SIGDORMANT:
292 /* "SIGDORMANT" means to ignore past user activity */
293 log_notice(LD_GENERAL, "Going dormant because of controller request.");
298 break;
299 }
300}
301
302#ifdef _WIN32
303/** Activate SIGINT on receiving a control signal in console. */
304static BOOL WINAPI
305process_win32_console_ctrl(DWORD ctrl_type)
306{
307 /* Ignore type of the ctrl signal */
308 (void) ctrl_type;
309
310 activate_signal(SIGINT);
311 return TRUE;
312}
313#endif /* defined(_WIN32) */
314
315/**
316 * Write current memory usage information to the log.
317 */
318static void
319dumpmemusage(int severity)
320{
322 tor_log(severity, LD_GENERAL, "In rephist: %"PRIu64" used by %d Tors.",
325 dump_cell_pool_usage(severity);
326 dump_dns_mem_usage(severity);
327}
328
329/** Write all statistics to the log, with log level <b>severity</b>. Called
330 * in response to a SIGUSR1. */
331static void
332dumpstats(int severity)
333{
334 time_t now = time(NULL);
335 time_t elapsed;
336 size_t rbuf_cap, wbuf_cap, rbuf_len, wbuf_len;
337
338 tor_log(severity, LD_GENERAL, "Dumping stats:");
339
341 int i = conn_sl_idx;
342 tor_log(severity, LD_GENERAL,
343 "Conn %d (socket %d) is a %s, created %d secs ago",
344 i, (int)conn->s,
346 (int)(now - conn->timestamp_created));
347 if (!connection_is_listener(conn)) {
348 tor_log(severity,LD_GENERAL,
349 "Conn %d: %d bytes waiting on inbuf (len %d, last read %d secs ago)",
350 i,
351 (int)connection_get_inbuf_len(conn),
352 (int)buf_allocation(conn->inbuf),
353 (int)(now - conn->timestamp_last_read_allowed));
354 tor_log(severity,LD_GENERAL,
355 "Conn %d: %d bytes waiting on outbuf "
356 "(len %d, last written %d secs ago)",i,
357 (int)connection_get_outbuf_len(conn),
358 (int)buf_allocation(conn->outbuf),
359 (int)(now - conn->timestamp_last_write_allowed));
360 if (conn->type == CONN_TYPE_OR) {
361 or_connection_t *or_conn = TO_OR_CONN(conn);
362 if (or_conn->tls) {
363 if (tor_tls_get_buffer_sizes(or_conn->tls, &rbuf_cap, &rbuf_len,
364 &wbuf_cap, &wbuf_len) == 0) {
365 tor_log(severity, LD_GENERAL,
366 "Conn %d: %d/%d bytes used on OpenSSL read buffer; "
367 "%d/%d bytes used on write buffer.",
368 i, (int)rbuf_len, (int)rbuf_cap, (int)wbuf_len, (int)wbuf_cap);
369 }
370 }
371 }
372 }
373 circuit_dump_by_conn(conn, severity); /* dump info about all the circuits
374 * using this conn */
375 } SMARTLIST_FOREACH_END(conn);
376
377 channel_dumpstats(severity);
379
380 // TODO CGO: Use of RELAY_PAYLOAD_SIZE_MAX may make this a bit wrong.
381 tor_log(severity, LD_NET,
382 "Cells processed: %"PRIu64" padding\n"
383 " %"PRIu64" create\n"
384 " %"PRIu64" created\n"
385 " %"PRIu64" relay\n"
386 " (%"PRIu64" relayed)\n"
387 " (%"PRIu64" delivered)\n"
388 " %"PRIu64" destroy",
397 tor_log(severity,LD_NET,"Average packaged cell fullness: %2.3f%%",
398 100*(((double)stats_n_data_bytes_packaged) /
401 tor_log(severity,LD_NET,"Average delivered cell fullness: %2.3f%%",
402 100*(((double)stats_n_data_bytes_received) /
404
405 cpuworker_log_onionskin_overhead(severity, ONION_HANDSHAKE_TYPE_TAP, "TAP");
406 cpuworker_log_onionskin_overhead(severity, ONION_HANDSHAKE_TYPE_NTOR,"ntor");
407
408 if (now - time_of_process_start >= 0)
409 elapsed = now - time_of_process_start;
410 else
411 elapsed = 0;
412
413 if (elapsed) {
414 tor_log(severity, LD_NET,
415 "Average bandwidth: %"PRIu64"/%d = %d bytes/sec reading",
416 (get_bytes_read()),
417 (int)elapsed,
418 (int) (get_bytes_read()/elapsed));
419 tor_log(severity, LD_NET,
420 "Average bandwidth: %"PRIu64"/%d = %d bytes/sec writing",
422 (int)elapsed,
423 (int) (get_bytes_written()/elapsed));
424 }
425
426 tor_log(severity, LD_NET, "--------------- Dumping memory information:");
427 dumpmemusage(severity);
428
429 rep_hist_dump_stats(now,severity);
430 hs_service_dump_stats(severity);
431}
432
433#ifdef _WIN32
434#define UNIX_ONLY 0
435#else
436#define UNIX_ONLY 1
437#endif
438
439static struct {
440 /** A numeric code for this signal. Must match the signal value if
441 * try_to_register is true. */
443 /** True if we should try to register this signal with libevent and catch
444 * corresponding posix signals. False otherwise. */
446 /** Pointer to hold the event object constructed for this signal. */
447 struct event *signal_event;
448} signal_handlers[] = {
449#ifdef SIGINT
450 { SIGINT, UNIX_ONLY, NULL }, /* do a controlled slow shutdown */
451#endif
452#ifdef SIGTERM
453 { SIGTERM, UNIX_ONLY, NULL }, /* to terminate now */
454#endif
455#ifdef SIGPIPE
456 { SIGPIPE, UNIX_ONLY, NULL }, /* otherwise SIGPIPE kills us */
457#endif
458#ifdef SIGUSR1
459 { SIGUSR1, UNIX_ONLY, NULL }, /* dump stats */
460#endif
461#ifdef SIGUSR2
462 { SIGUSR2, UNIX_ONLY, NULL }, /* go to loglevel debug */
463#endif
464#ifdef SIGHUP
465 { SIGHUP, UNIX_ONLY, NULL }, /* to reload config, retry conns, etc */
466#endif
467#ifdef SIGXFSZ
468 { SIGXFSZ, UNIX_ONLY, NULL }, /* handle file-too-big resource exhaustion */
469#endif
470#ifdef SIGCHLD
471 { SIGCHLD, UNIX_ONLY, NULL }, /* handle dns/cpu workers that exit */
472#endif
473 /* These are controller-only */
474 { SIGNEWNYM, 0, NULL },
475 { SIGCLEARDNSCACHE, 0, NULL },
476 { SIGHEARTBEAT, 0, NULL },
477 { SIGACTIVE, 0, NULL },
478 { SIGDORMANT, 0, NULL },
479 { -1, -1, NULL }
480};
481
482/** Set up the signal handler events for this process, and register them
483 * with libevent if appropriate. */
484void
486{
487 int i;
488 const int enabled = !get_options()->DisableSignalHandlers;
489
490 for (i = 0; signal_handlers[i].signal_value >= 0; ++i) {
491 /* Signal handlers are only registered with libevent if they need to catch
492 * real POSIX signals. We construct these signal handler events in either
493 * case, though, so that controllers can activate them with the SIGNAL
494 * command.
495 */
496 if (enabled && signal_handlers[i].try_to_register) {
497 signal_handlers[i].signal_event =
498 tor_evsignal_new(tor_libevent_get_base(),
499 signal_handlers[i].signal_value,
501 &signal_handlers[i].signal_value);
502 if (event_add(signal_handlers[i].signal_event, NULL))
503 log_warn(LD_BUG, "Error from libevent when adding "
504 "event for signal %d",
505 signal_handlers[i].signal_value);
506 } else {
507 signal_handlers[i].signal_event =
508 tor_event_new(tor_libevent_get_base(), -1,
509 EV_SIGNAL, signal_callback,
510 &signal_handlers[i].signal_value);
511 }
512 }
513
514#ifdef _WIN32
515 /* Windows lacks traditional POSIX signals but WinAPI provides a function
516 * to handle control signals like Ctrl+C in the console, we can use this to
517 * simulate the SIGINT signal */
518 if (enabled) SetConsoleCtrlHandler(process_win32_console_ctrl, TRUE);
519#endif /* defined(_WIN32) */
520}
521
522/* Cause the signal handler for signal_num to be called in the event loop. */
523void
524activate_signal(int signal_num)
525{
526 int i;
527 for (i = 0; signal_handlers[i].signal_value >= 0; ++i) {
528 if (signal_handlers[i].signal_value == signal_num) {
529 event_active(signal_handlers[i].signal_event, EV_SIGNAL, 1);
530 return;
531 }
532 }
533}
534
535/** Main entry point for the Tor command-line client. Return 0 on "success",
536 * negative on "failure", and positive on "success and exit".
537 */
538int
539tor_init(int argc, char *argv[])
540{
541 char progname[256];
543 bool running_tor = false;
544
545 time_of_process_start = time(NULL);
547 /* Have the log set up with our application name. */
548 tor_snprintf(progname, sizeof(progname), "Tor %s", get_version());
549 log_set_application_name(progname);
550
551 /* Initialize the history structures. */
553 bwhist_init();
554 /* Initialize the service cache. */
555 addressmap_init(); /* Init the client dns cache. Do it always, since it's
556 * cheap. */
557
558 /* Initialize the HS subsystem. */
559 hs_init();
560
561 {
562 /* We check for the "quiet"/"hush" settings first, since they decide
563 whether we log anything at all to stdout. */
564 parsed_cmdline_t *cmdline;
565 cmdline = config_parse_commandline(argc, argv, 1);
566 if (cmdline) {
567 quiet = cmdline->quiet_level;
568 running_tor = (cmdline->command == CMD_RUN_TOR);
569 }
570 parsed_cmdline_free(cmdline);
571 }
572
573 /* give it somewhere to log to initially */
576
577 {
578 const char *version = get_version();
579
580 log_notice(LD_GENERAL, "Tor %s running on %s with Libevent %s, "
581 "%s %s, Zlib %s, Liblzma %s, Libzstd %s and %s %s as libc.",
582 version,
583 get_uname(),
587 tor_compress_supports_method(ZLIB_METHOD) ?
588 tor_compress_version_str(ZLIB_METHOD) : "N/A",
589 tor_compress_supports_method(LZMA_METHOD) ?
590 tor_compress_version_str(LZMA_METHOD) : "N/A",
591 tor_compress_supports_method(ZSTD_METHOD) ?
592 tor_compress_version_str(ZSTD_METHOD) : "N/A",
594 tor_libc_get_name() : "Unknown",
596
597 log_notice(LD_GENERAL, "Tor can't help you if you use it wrong! "
598 "Learn how to be safe at "
599 "https://support.torproject.org/faq/staying-anonymous/");
600
601 if (strstr(version, "alpha") || strstr(version, "beta"))
602 log_notice(LD_GENERAL, "This version is not a stable Tor release. "
603 "Expect more bugs than usual.");
604
605 if (strlen(risky_option_list) && running_tor) {
606 log_warn(LD_GENERAL, "This build of Tor has been compiled with one "
607 "or more options that might make it less reliable or secure! "
608 "They are:%s", risky_option_list);
609 }
610
612 }
613
614 /* Warn _if_ the tracing subsystem is built in. */
615 tracing_log_warning();
616
617 int init_rv = options_init_from_torrc(argc,argv);
618 if (init_rv < 0) {
619 log_err(LD_CONFIG,"Reading config failed--see warnings above.");
620 return -1;
621 } else if (init_rv > 0) {
622 // We succeeded, and should exit anyway -- probably the user just said
623 // "--version" or something like that.
624 return 1;
625 }
626
627 /* Initialize channelpadding and circpad parameters to defaults
628 * until we get a consensus */
633
634 /* Initialize circuit padding to defaults+torrc until we get a consensus */
636
637 /* Initialize hidden service DoS subsystem. We need to do this once the
638 * configuration object has been set because it can be accessed. */
639 hs_dos_init();
640
641 /* Initialize predicted ports list after loading options */
642 predicted_ports_init();
643
644#ifndef _WIN32
645 if (geteuid()==0)
646 log_warn(LD_GENERAL,"You are running Tor as root. You don't need to, "
647 "and you probably shouldn't.");
648#endif
649
650 /* Scan/clean unparseable descriptors; after reading config */
652
653 return 0;
654}
655
656/** A lockfile structure, used to prevent two Tors from messing with the
657 * data directory at once. If this variable is non-NULL, we're holding
658 * the lockfile. */
660
661/** Try to grab the lock file described in <b>options</b>, if we do not
662 * already have it. If <b>err_if_locked</b> is true, warn if somebody else is
663 * holding the lock, and exit if we can't get it after waiting. Otherwise,
664 * return -1 if we can't get the lockfile. Return 0 on success.
665 */
666int
667try_locking(const or_options_t *options, int err_if_locked)
668{
669 if (lockfile)
670 return 0;
671 else {
672 char *fname = options_get_datadir_fname(options, "lock");
673 int already_locked = 0;
674 tor_lockfile_t *lf = tor_lockfile_lock(fname, 0, &already_locked);
675 tor_free(fname);
676 if (!lf) {
677 if (err_if_locked && already_locked) {
678 int r;
679 log_warn(LD_GENERAL, "It looks like another Tor process is running "
680 "with the same data directory. Waiting 5 seconds to see "
681 "if it goes away.");
682#ifndef _WIN32
683 sleep(5);
684#else
685 Sleep(5000);
686#endif
687 r = try_locking(options, 0);
688 if (r<0) {
689 log_err(LD_GENERAL, "No, it's still there. Exiting.");
690 return -1;
691 }
692 return r;
693 }
694 return -1;
695 }
696 lockfile = lf;
697 return 0;
698 }
699}
700
701/** Return true iff we've successfully acquired the lock file. */
702int
704{
705 return lockfile != NULL;
706}
707
708/** If we have successfully acquired the lock file, release it. */
709void
711{
712 if (lockfile) {
714 lockfile = NULL;
715 }
716}
717
718/**
719 * Remove the specified file, and log a warning if the operation fails for
720 * any reason other than the file not existing. Ignores NULL filenames.
721 */
722void
723tor_remove_file(const char *filename)
724{
725 if (filename && tor_unlink(filename) != 0 && errno != ENOENT) {
726 log_warn(LD_FS, "Couldn't unlink %s: %s",
727 filename, strerror(errno));
728 }
729}
730
731/** Read/create keys as needed, and echo our fingerprint to stdout. */
732static int
734{
735 const or_options_t *options = get_options();
736 const char *arg = options->command_arg;
737 char rsa[FINGERPRINT_LEN + 1];
738 crypto_pk_t *k;
739 const ed25519_public_key_t *edkey;
740 const char *nickname = options->Nickname;
741 sandbox_disable_getaddrinfo_cache();
742
743 bool show_rsa = !strcmp(arg, "") || !strcmp(arg, "rsa");
744 bool show_ed25519 = !strcmp(arg, "ed25519");
745 if (!show_rsa && !show_ed25519) {
746 log_err(LD_GENERAL,
747 "If you give a key type, you must specify 'rsa' or 'ed25519'. Exiting.");
748 return -1;
749 }
750
751 if (!server_mode(options)) {
752 log_err(LD_GENERAL,
753 "Clients don't have long-term identity keys. Exiting.");
754 return -1;
755 }
756 tor_assert(nickname);
757 if (init_keys() < 0) {
758 log_err(LD_GENERAL, "Error initializing keys; exiting.");
759 return -1;
760 }
761 if (!(k = get_server_identity_key())) {
762 log_err(LD_GENERAL, "Error: missing RSA identity key.");
763 return -1;
764 }
765 if (crypto_pk_get_fingerprint(k, rsa, 1) < 0) {
766 log_err(LD_BUG, "Error computing RSA fingerprint");
767 return -1;
768 }
769 if (!(edkey = get_master_identity_key())) {
770 log_err(LD_GENERAL,"Error: missing ed25519 identity key.");
771 return -1;
772 }
773 if (show_rsa) {
774 printf("%s %s\n", nickname, rsa);
775 }
776 if (show_ed25519) {
777 char ed25519[ED25519_BASE64_LEN + 1];
778 digest256_to_base64(ed25519, (const char *) edkey->pubkey);
779 printf("%s %s\n", nickname, ed25519);
780 }
781 return 0;
782}
783
784/** Entry point for password hashing: take the desired password from
785 * the command line, and print its salted hash to stdout. **/
786static void
788{
789
790 char output[256];
792
794 key[S2K_RFC2440_SPECIFIER_LEN-1] = (uint8_t)96; /* Hash 64 K of data. */
796 get_options()->command_arg, strlen(get_options()->command_arg),
797 key);
798 base16_encode(output, sizeof(output), key, sizeof(key));
799 printf("16:%s\n",output);
800}
801
802/** Entry point for configuration dumping: write the configuration to
803 * stdout. */
804static int
806{
807 const or_options_t *options = get_options();
808 const char *arg = options->command_arg;
809 int how;
810 char *opts;
811
812 if (!strcmp(arg, "short")) {
813 how = OPTIONS_DUMP_MINIMAL;
814 } else if (!strcmp(arg, "non-builtin")) {
815 // Deprecated since 0.4.5.1-alpha.
816 fprintf(stderr, "'non-builtin' is deprecated; use 'short' instead.\n");
817 how = OPTIONS_DUMP_MINIMAL;
818 } else if (!strcmp(arg, "full")) {
819 how = OPTIONS_DUMP_ALL;
820 } else {
821 fprintf(stderr, "No valid argument to --dump-config found!\n");
822 fprintf(stderr, "Please select 'short' or 'full'.\n");
823
824 return -1;
825 }
826
827 opts = options_dump(options, how);
828 printf("%s", opts);
829 tor_free(opts);
830
831 return 0;
832}
833
834/** Implement --keygen-family; create a family ID key and write it to a file.
835 */
836static int
837do_keygen_family(const char *fname_base)
838{
840 char *fname_key = NULL, *fname_id = NULL, *id_contents = NULL;
841 int r = -1;
842
843 if (BUG(!fname_base))
844 goto done;
845
846 tor_asprintf(&fname_key, "%s.secret_family_key", fname_base);
847 tor_asprintf(&fname_id, "%s.public_family_id", fname_base);
848
849 if (create_family_id_key(fname_key, &pk) < 0)
850 goto done;
851 tor_asprintf(&id_contents, "%s\n", ed25519_fmt(&pk));
852 if (write_str_to_file(fname_id, id_contents, 0) < 0)
853 goto done;
854
855 printf("# Generated %s\n", fname_key);
856 printf("FamilyId %s\n", ed25519_fmt(&pk));
857
858 r = 0;
859
860 done:
861 tor_free(fname_key);
862 tor_free(fname_id);
863 tor_free(id_contents);
864 return r;
865}
866
867static void
868init_addrinfo(void)
869{
870 if (! server_mode(get_options()) || get_options()->Address) {
871 /* We don't need to seed our own hostname, because we won't be calling
872 * resolve_my_address on it.
873 */
874 return;
875 }
876 char hname[256];
877
878 // host name to sandbox
879 gethostname(hname, sizeof(hname));
880 tor_add_addrinfo(hname);
881}
882
883static sandbox_cfg_t*
884sandbox_init_filter(void)
885{
886 const or_options_t *options = get_options();
888
890 get_cachedir_fname("cached-status"));
891
892#define OPEN(name) \
893 sandbox_cfg_allow_open_filename(&cfg, tor_strdup(name))
894
895#define OPENDIR(dir) \
896 sandbox_cfg_allow_opendir_dirname(&cfg, tor_strdup(dir))
897
898#define OPEN_DATADIR(name) \
899 sandbox_cfg_allow_open_filename(&cfg, get_datadir_fname(name))
900
901#define OPEN_DATADIR2(name, name2) \
902 sandbox_cfg_allow_open_filename(&cfg, get_datadir_fname2((name), (name2)))
903
904#define OPEN_DATADIR_SUFFIX(name, suffix) do { \
905 OPEN_DATADIR(name); \
906 OPEN_DATADIR(name suffix); \
907 } while (0)
908
909#define OPEN_DATADIR2_SUFFIX(name, name2, suffix) do { \
910 OPEN_DATADIR2(name, name2); \
911 OPEN_DATADIR2(name, name2 suffix); \
912 } while (0)
913
914// KeyDirectory is a directory, but it is only opened in check_private_dir
915// which calls open instead of opendir
916#define OPEN_KEY_DIRECTORY() \
917 OPEN(options->KeyDirectory)
918#define OPEN_CACHEDIR(name) \
919 sandbox_cfg_allow_open_filename(&cfg, get_cachedir_fname(name))
920#define OPEN_CACHEDIR_SUFFIX(name, suffix) do { \
921 OPEN_CACHEDIR(name); \
922 OPEN_CACHEDIR(name suffix); \
923 } while (0)
924#define OPEN_KEYDIR(name) \
925 sandbox_cfg_allow_open_filename(&cfg, get_keydir_fname(name))
926#define OPEN_KEYDIR_SUFFIX(name, suffix) do { \
927 OPEN_KEYDIR(name); \
928 OPEN_KEYDIR(name suffix); \
929 } while (0)
930
931 // DataDirectory is a directory, but it is only opened in check_private_dir
932 // which calls open instead of opendir
933 OPEN(options->DataDirectory);
934 OPEN_KEY_DIRECTORY();
935
936 OPEN_CACHEDIR_SUFFIX("cached-certs", ".tmp");
937 OPEN_CACHEDIR_SUFFIX("cached-consensus", ".tmp");
938 OPEN_CACHEDIR_SUFFIX("unverified-consensus", ".tmp");
939 OPEN_CACHEDIR_SUFFIX("unverified-microdesc-consensus", ".tmp");
940 OPEN_CACHEDIR_SUFFIX("cached-microdesc-consensus", ".tmp");
941 OPEN_CACHEDIR_SUFFIX("cached-microdescs", ".tmp");
942 OPEN_CACHEDIR_SUFFIX("cached-microdescs.new", ".tmp");
943 OPEN_CACHEDIR_SUFFIX("cached-descriptors", ".tmp");
944 OPEN_CACHEDIR_SUFFIX("cached-descriptors.new", ".tmp");
945 OPEN_CACHEDIR("cached-descriptors.tmp.tmp");
946 OPEN_CACHEDIR_SUFFIX("cached-extrainfo", ".tmp");
947 OPEN_CACHEDIR_SUFFIX("cached-extrainfo.new", ".tmp");
948 OPEN_CACHEDIR("cached-extrainfo.tmp.tmp");
949
950 OPEN_DATADIR_SUFFIX("state", ".tmp");
951 OPEN_DATADIR_SUFFIX("sr-state", ".tmp");
952 OPEN_DATADIR_SUFFIX("unparseable-desc", ".tmp");
953 OPEN_DATADIR_SUFFIX("v3-status-votes", ".tmp");
954 OPEN_DATADIR("key-pinning-journal");
955 OPEN("/dev/srandom");
956 OPEN("/dev/urandom");
957 OPEN("/dev/random");
958 OPEN("/etc/hosts");
959 OPEN("/proc/meminfo");
960
961#ifdef HAVE_MODULE_RELAY
962 {
963 smartlist_t *family_id_files =
964 list_family_key_files(options, options->FamilyKeyDirectory);
965
966 SMARTLIST_FOREACH(family_id_files, const char *, fn,
967 OPEN(fn));
968
969 SMARTLIST_FOREACH(family_id_files, char *, cp, tor_free(cp));
970 smartlist_free(family_id_files);
971 }
972#endif
973
974 if (options->BridgeAuthoritativeDir)
975 OPEN_DATADIR_SUFFIX("networkstatus-bridges", ".tmp");
976
977 if (authdir_mode(options)) {
978 OPEN_DATADIR("approved-routers");
979 OPEN_DATADIR_SUFFIX("my-consensus-microdesc", ".tmp");
980 OPEN_DATADIR_SUFFIX("my-consensus-ns", ".tmp");
981 if (options->V3BandwidthsFile) {
982 log_notice(LD_GENERAL, "Adding V3BandwidthsFile %s to sandboxing set.",
983 options->V3BandwidthsFile);
984 OPEN(options->V3BandwidthsFile);
985 }
986 }
987
988 if (options->ServerDNSResolvConfFile)
990 tor_strdup(options->ServerDNSResolvConfFile));
991 else
992 sandbox_cfg_allow_open_filename(&cfg, tor_strdup("/etc/resolv.conf"));
993
994 const char *torrc_defaults_fname = get_torrc_fname(1);
997 }
998 const char *torrc_fname = get_torrc_fname(0);
999 if (torrc_fname) {
1001 // allow torrc backup and torrc.tmp to make SAVECONF work
1002 char *torrc_bck = NULL;
1004 sandbox_cfg_allow_rename(&cfg, tor_strdup(torrc_fname), torrc_bck);
1005 char *torrc_tmp = NULL;
1006 tor_asprintf(&torrc_tmp, "%s.tmp", torrc_fname);
1007 sandbox_cfg_allow_rename(&cfg, torrc_tmp, tor_strdup(torrc_fname));
1008 sandbox_cfg_allow_open_filename(&cfg, tor_strdup(torrc_tmp));
1009 // we need to stat the existing backup file
1010 sandbox_cfg_allow_stat_filename(&cfg, tor_strdup(torrc_bck));
1011 }
1012
1013 SMARTLIST_FOREACH(options->FilesOpenedByIncludes, char *, f, {
1014 if (file_status(f) == FN_DIR) {
1015 OPENDIR(f);
1016 } else {
1017 OPEN(f);
1018 }
1019 });
1020
1021#define RENAME_SUFFIX(name, suffix) \
1022 sandbox_cfg_allow_rename(&cfg, \
1023 get_datadir_fname(name suffix), \
1024 get_datadir_fname(name))
1025
1026#define RENAME_SUFFIX2(prefix, name, suffix) \
1027 sandbox_cfg_allow_rename(&cfg, \
1028 get_datadir_fname2(prefix, name suffix), \
1029 get_datadir_fname2(prefix, name))
1030
1031#define RENAME_CACHEDIR_SUFFIX(name, suffix) \
1032 sandbox_cfg_allow_rename(&cfg, \
1033 get_cachedir_fname(name suffix), \
1034 get_cachedir_fname(name))
1035
1036#define RENAME_KEYDIR_SUFFIX(name, suffix) \
1037 sandbox_cfg_allow_rename(&cfg, \
1038 get_keydir_fname(name suffix), \
1039 get_keydir_fname(name))
1040
1041 RENAME_CACHEDIR_SUFFIX("cached-certs", ".tmp");
1042 RENAME_CACHEDIR_SUFFIX("cached-consensus", ".tmp");
1043 RENAME_CACHEDIR_SUFFIX("unverified-consensus", ".tmp");
1044 RENAME_CACHEDIR_SUFFIX("unverified-microdesc-consensus", ".tmp");
1045 RENAME_CACHEDIR_SUFFIX("cached-microdesc-consensus", ".tmp");
1046 RENAME_CACHEDIR_SUFFIX("cached-microdescs", ".tmp");
1047 RENAME_CACHEDIR_SUFFIX("cached-microdescs", ".new");
1048 RENAME_CACHEDIR_SUFFIX("cached-microdescs.new", ".tmp");
1049 RENAME_CACHEDIR_SUFFIX("cached-descriptors", ".tmp");
1050 RENAME_CACHEDIR_SUFFIX("cached-descriptors", ".new");
1051 RENAME_CACHEDIR_SUFFIX("cached-descriptors.new", ".tmp");
1052 RENAME_CACHEDIR_SUFFIX("cached-extrainfo", ".tmp");
1053 RENAME_CACHEDIR_SUFFIX("cached-extrainfo", ".new");
1054 RENAME_CACHEDIR_SUFFIX("cached-extrainfo.new", ".tmp");
1055
1056 RENAME_SUFFIX("state", ".tmp");
1057 RENAME_SUFFIX("sr-state", ".tmp");
1058 RENAME_SUFFIX("unparseable-desc", ".tmp");
1059 RENAME_SUFFIX("v3-status-votes", ".tmp");
1060
1061 if (options->BridgeAuthoritativeDir)
1062 RENAME_SUFFIX("networkstatus-bridges", ".tmp");
1063
1064 if (authdir_mode(options)) {
1065 RENAME_SUFFIX("my-consensus-microdesc", ".tmp");
1066 RENAME_SUFFIX("my-consensus-ns", ".tmp");
1067 }
1068
1069#define STAT_DATADIR(name) \
1070 sandbox_cfg_allow_stat_filename(&cfg, get_datadir_fname(name))
1071
1072#define STAT_CACHEDIR(name) \
1073 sandbox_cfg_allow_stat_filename(&cfg, get_cachedir_fname(name))
1074
1075#define STAT_DATADIR2(name, name2) \
1076 sandbox_cfg_allow_stat_filename(&cfg, get_datadir_fname2((name), (name2)))
1077
1078#define STAT_KEY_DIRECTORY() \
1079 sandbox_cfg_allow_stat_filename(&cfg, tor_strdup(options->KeyDirectory))
1080
1081 STAT_DATADIR(NULL);
1082 STAT_DATADIR("lock");
1083 STAT_DATADIR("state");
1084 STAT_DATADIR("router-stability");
1085
1086 STAT_CACHEDIR("cached-extrainfo.new");
1087
1088 {
1089 smartlist_t *files = smartlist_new();
1091 SMARTLIST_FOREACH(files, char *, file_name, {
1092 /* steals reference */
1093 sandbox_cfg_allow_open_filename(&cfg, file_name);
1094 });
1095 smartlist_free(files);
1096 }
1097
1098 {
1099 smartlist_t *files = smartlist_new();
1100 smartlist_t *dirs = smartlist_new();
1102 SMARTLIST_FOREACH(files, char *, file_name, {
1103 char *tmp_name = NULL;
1104 tor_asprintf(&tmp_name, "%s.tmp", file_name);
1105 sandbox_cfg_allow_rename(&cfg,
1106 tor_strdup(tmp_name), tor_strdup(file_name));
1107 /* steals references */
1108 sandbox_cfg_allow_open_filename(&cfg, file_name);
1109 sandbox_cfg_allow_open_filename(&cfg, tmp_name);
1110 });
1111 SMARTLIST_FOREACH(dirs, char *, dir, {
1112 /* steals reference */
1114 });
1115 smartlist_free(files);
1116 smartlist_free(dirs);
1117 }
1118
1119 {
1120 char *fname;
1121 if ((fname = get_controller_cookie_file_name())) {
1123 }
1124 if ((fname = get_ext_or_auth_cookie_file_name())) {
1126 }
1127 }
1128
1130 if (!port->is_unix_addr)
1131 continue;
1132 /* When we open an AF_UNIX address, we want permission to open the
1133 * directory that holds it. */
1134 char *dirname = tor_strdup(port->unix_addr);
1135 if (get_parent_directory(dirname) == 0) {
1136 OPENDIR(dirname);
1137 }
1138 tor_free(dirname);
1139 sandbox_cfg_allow_chmod_filename(&cfg, tor_strdup(port->unix_addr));
1140 sandbox_cfg_allow_chown_filename(&cfg, tor_strdup(port->unix_addr));
1141 } SMARTLIST_FOREACH_END(port);
1142
1143 if (options->DirPortFrontPage) {
1145 tor_strdup(options->DirPortFrontPage));
1146 }
1147
1148 // orport
1149 if (server_mode(get_options())) {
1150
1151 OPEN_KEYDIR_SUFFIX("secret_id_key", ".tmp");
1152 OPEN_KEYDIR_SUFFIX("secret_onion_key", ".tmp");
1153 OPEN_KEYDIR_SUFFIX("secret_onion_key_ntor", ".tmp");
1154 OPEN_KEYDIR("secret_id_key.old");
1155 OPEN_KEYDIR("secret_onion_key.old");
1156 OPEN_KEYDIR("secret_onion_key_ntor.old");
1157
1158 OPEN_KEYDIR_SUFFIX("ed25519_master_id_secret_key", ".tmp");
1159 OPEN_KEYDIR_SUFFIX("ed25519_master_id_secret_key_encrypted", ".tmp");
1160 OPEN_KEYDIR_SUFFIX("ed25519_master_id_public_key", ".tmp");
1161 OPEN_KEYDIR_SUFFIX("ed25519_signing_secret_key", ".tmp");
1162 OPEN_KEYDIR_SUFFIX("ed25519_signing_secret_key_encrypted", ".tmp");
1163 OPEN_KEYDIR_SUFFIX("ed25519_signing_public_key", ".tmp");
1164 OPEN_KEYDIR_SUFFIX("ed25519_signing_cert", ".tmp");
1165
1166 OPEN_DATADIR2_SUFFIX("stats", "bridge-stats", ".tmp");
1167 OPEN_DATADIR2_SUFFIX("stats", "dirreq-stats", ".tmp");
1168
1169 OPEN_DATADIR2_SUFFIX("stats", "entry-stats", ".tmp");
1170 OPEN_DATADIR2_SUFFIX("stats", "exit-stats", ".tmp");
1171 OPEN_DATADIR2_SUFFIX("stats", "buffer-stats", ".tmp");
1172 OPEN_DATADIR2_SUFFIX("stats", "conn-stats", ".tmp");
1173 OPEN_DATADIR2_SUFFIX("stats", "hidserv-stats", ".tmp");
1174 OPEN_DATADIR2_SUFFIX("stats", "hidserv-v3-stats", ".tmp");
1175
1176 OPEN_DATADIR("approved-routers");
1177 OPEN_DATADIR_SUFFIX("fingerprint", ".tmp");
1178 OPEN_DATADIR_SUFFIX("fingerprint-ed25519", ".tmp");
1179 OPEN_DATADIR_SUFFIX("hashed-fingerprint", ".tmp");
1180 OPEN_DATADIR_SUFFIX("router-stability", ".tmp");
1181
1182 OPEN("/etc/resolv.conf");
1183
1184 RENAME_SUFFIX("fingerprint", ".tmp");
1185 RENAME_SUFFIX("fingerprint-ed25519", ".tmp");
1186 RENAME_KEYDIR_SUFFIX("secret_onion_key_ntor", ".tmp");
1187
1188 RENAME_KEYDIR_SUFFIX("secret_id_key", ".tmp");
1189 RENAME_KEYDIR_SUFFIX("secret_id_key.old", ".tmp");
1190 RENAME_KEYDIR_SUFFIX("secret_onion_key", ".tmp");
1191 RENAME_KEYDIR_SUFFIX("secret_onion_key.old", ".tmp");
1192
1193 RENAME_SUFFIX2("stats", "bridge-stats", ".tmp");
1194 RENAME_SUFFIX2("stats", "dirreq-stats", ".tmp");
1195 RENAME_SUFFIX2("stats", "entry-stats", ".tmp");
1196 RENAME_SUFFIX2("stats", "exit-stats", ".tmp");
1197 RENAME_SUFFIX2("stats", "buffer-stats", ".tmp");
1198 RENAME_SUFFIX2("stats", "conn-stats", ".tmp");
1199 RENAME_SUFFIX2("stats", "hidserv-stats", ".tmp");
1200 RENAME_SUFFIX2("stats", "hidserv-v3-stats", ".tmp");
1201 RENAME_SUFFIX("hashed-fingerprint", ".tmp");
1202 RENAME_SUFFIX("router-stability", ".tmp");
1203
1204 RENAME_KEYDIR_SUFFIX("ed25519_master_id_secret_key", ".tmp");
1205 RENAME_KEYDIR_SUFFIX("ed25519_master_id_secret_key_encrypted", ".tmp");
1206 RENAME_KEYDIR_SUFFIX("ed25519_master_id_public_key", ".tmp");
1207 RENAME_KEYDIR_SUFFIX("ed25519_signing_secret_key", ".tmp");
1208 RENAME_KEYDIR_SUFFIX("ed25519_signing_cert", ".tmp");
1209
1210 sandbox_cfg_allow_rename(&cfg,
1211 get_keydir_fname("secret_onion_key"),
1212 get_keydir_fname("secret_onion_key.old"));
1213 sandbox_cfg_allow_rename(&cfg,
1214 get_keydir_fname("secret_onion_key_ntor"),
1215 get_keydir_fname("secret_onion_key_ntor.old"));
1216
1217 STAT_KEY_DIRECTORY();
1218 OPEN_DATADIR("stats");
1219 STAT_DATADIR("stats");
1220 STAT_DATADIR2("stats", "dirreq-stats");
1221
1223 }
1224
1225 init_addrinfo();
1226
1227 return cfg;
1228}
1229
1230int
1231run_tor_main_loop(void)
1232{
1236
1237 /* load the private keys, if we're supposed to have them, and set up the
1238 * TLS context. */
1240 if (init_keys() < 0) {
1241 log_err(LD_OR, "Error initializing keys; exiting");
1242 return -1;
1243 }
1244 }
1245
1246 /* Set up our buckets */
1248
1249 /* initialize the bootstrap status events to know we're starting up */
1250 control_event_bootstrap(BOOTSTRAP_STATUS_STARTING, 0);
1251
1252 /* Initialize the keypinning log. */
1253 if (authdir_mode_v3(get_options())) {
1254 char *fname = get_datadir_fname("key-pinning-journal");
1255 int r = 0;
1256 if (keypin_load_journal(fname)<0) {
1257 log_err(LD_DIR, "Error loading key-pinning journal: %s",strerror(errno));
1258 r = -1;
1259 }
1260 if (keypin_open_journal(fname)<0) {
1261 log_err(LD_DIR, "Error opening key-pinning journal: %s",strerror(errno));
1262 r = -1;
1263 }
1264 tor_free(fname);
1265 if (r)
1266 return r;
1267 }
1268 {
1269 /* This is the old name for key-pinning-journal. These got corrupted
1270 * in a couple of cases by #16530, so we started over. See #16580 for
1271 * the rationale and for other options we didn't take. We can remove
1272 * this code once all the authorities that ran 0.2.7.1-alpha-dev are
1273 * upgraded.
1274 */
1275 char *fname = get_datadir_fname("key-pinning-entries");
1276 unlink(fname);
1277 tor_free(fname);
1278 }
1279
1281 log_warn(LD_DIR,
1282 "Couldn't load all cached v3 certificates. Starting anyway.");
1283 }
1285 return -1;
1286 }
1287 /* load the routers file, or assign the defaults. */
1289 return -1;
1290 }
1291 /* load the networkstatuses. (This launches a download for new routers as
1292 * appropriate.)
1293 */
1294 const time_t now = time(NULL);
1295 directory_info_has_arrived(now, 1, 0);
1296
1297 /* launch cpuworkers. Need to do this *after* we've read the onion key. */
1298 /* launch them always for all tors, now that clients can solve onion PoWs. */
1299 if (cpuworker_init() == -1)
1300 return -1;
1301
1303
1304 /* Setup shared random protocol subsystem. */
1305 if (authdir_mode_v3(get_options())) {
1306 if (sr_init(1) < 0) {
1307 return -1;
1308 }
1309 }
1310
1311 /* initialize dns resolve map, spawn workers if needed */
1312 if (dns_init() < 0) {
1313 if (get_options()->ServerDNSAllowBrokenConfig)
1314 log_warn(LD_GENERAL, "Couldn't set up any working nameservers. "
1315 "Network not up yet? Will try again soon.");
1316 else {
1317 log_err(LD_GENERAL,"Error initializing dns subsystem; exiting. To "
1318 "retry instead, set the ServerDNSAllowBrokenResolvConf option.");
1319 }
1320 }
1321
1322#ifdef HAVE_SYSTEMD
1323 {
1324 const int r = sd_notify(0, "READY=1");
1325 if (r < 0) {
1326 log_warn(LD_GENERAL, "Unable to send readiness to systemd: %s",
1327 strerror(r));
1328 } else if (r > 0) {
1329 log_notice(LD_GENERAL, "Signaled readiness to systemd");
1330 } else {
1331 log_info(LD_GENERAL, "Systemd NOTIFY_SOCKET not present.");
1332 }
1333 }
1334#endif /* defined(HAVE_SYSTEMD) */
1335
1336 return do_main_loop();
1337}
1338
1339/** Install the publish/subscribe relationships for all the subsystems. */
1340void
1342{
1344 int r = subsystems_add_pubsub(builder);
1345 tor_assert(r == 0);
1346 r = tor_mainloop_connect_pubsub(builder); // consumes builder
1347 tor_assert(r == 0);
1348}
1349
1350/** Connect the mainloop to its publish/subscribe message delivery events if
1351 * appropriate, and configure the global channels appropriately. */
1352void
1354{
1355 if (get_options()->command == CMD_RUN_TOR) {
1357 /* XXXX For each pubsub channel, its delivery strategy should be set at
1358 * this XXXX point, using tor_mainloop_set_delivery_strategy().
1359 */
1362 }
1363}
1364
1365/* Main entry point for the Tor process. Called from tor_main(), and by
1366 * anybody embedding Tor. */
1367int
1369{
1370 int result = 0;
1371
1372#ifdef EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED
1373 event_set_mem_functions(tor_malloc_, tor_realloc_, tor_free_);
1374#endif
1375
1377
1379
1380 int argc = tor_cfg->argc + tor_cfg->argc_owned;
1381 char **argv = tor_calloc(argc, sizeof(char*));
1382 memcpy(argv, tor_cfg->argv, tor_cfg->argc*sizeof(char*));
1383 if (tor_cfg->argc_owned)
1384 memcpy(argv + tor_cfg->argc, tor_cfg->argv_owned,
1385 tor_cfg->argc_owned*sizeof(char*));
1386
1387 int done = 0;
1388 result = nt_service_parse_options(argc, argv, &done);
1389 if (POSSIBLE(done))
1390 goto done;
1391
1393
1394 {
1395 int init_rv = tor_init(argc, argv);
1396 if (init_rv) {
1397 tor_free_all(0);
1398 result = (init_rv < 0) ? -1 : 0;
1399 goto done;
1400 }
1401 }
1402
1404
1405 if (get_options()->Sandbox && get_options()->command == CMD_RUN_TOR) {
1406#ifdef ENABLE_FRAGILE_HARDENING
1407 log_warn(LD_CONFIG, "Sandbox is enabled but this Tor was built using "
1408 "fragile compiler hardening. The sandbox may be unable to filter "
1409 "requests to open files and directories and its overall "
1410 "effectiveness will be reduced.");
1411#endif
1412
1413 sandbox_cfg_t* cfg = sandbox_init_filter();
1414
1415 if (sandbox_init(cfg)) {
1416 tor_free(argv);
1417 log_err(LD_BUG,"Failed to create syscall sandbox filter");
1418 tor_free_all(0);
1419 return -1;
1420 }
1421 tor_make_getaddrinfo_cache_active();
1422
1423 // registering libevent rng
1424#ifdef HAVE_EVUTIL_SECURE_RNG_SET_URANDOM_DEVICE_FILE
1425 evutil_secure_rng_set_urandom_device_file(
1426 (char*) sandbox_intern_string("/dev/urandom"));
1427#endif
1428 }
1429
1430 switch (get_options()->command) {
1431 case CMD_RUN_TOR:
1432 nt_service_set_state(SERVICE_RUNNING);
1433 result = run_tor_main_loop();
1434 break;
1435 case CMD_KEYGEN:
1436 result = load_ed_keys(get_options(), time(NULL)) < 0;
1437 break;
1438 case CMD_KEYGEN_FAMILY:
1439 result = do_keygen_family(get_options()->command_arg);
1440 break;
1441 case CMD_KEY_EXPIRATION:
1442 init_keys();
1443 result = log_cert_expiration();
1444 break;
1446 result = do_list_fingerprint();
1447 break;
1448 case CMD_HASH_PASSWORD:
1450 result = 0;
1451 break;
1452 case CMD_VERIFY_CONFIG:
1453 if (quiet_level == QUIET_NONE)
1454 printf("Configuration was valid\n");
1455 result = 0;
1456 break;
1457 case CMD_DUMP_CONFIG:
1458 result = do_dump_config();
1459 break;
1460 case CMD_RUN_UNITTESTS: /* only set by test.c */
1461 case CMD_IMMEDIATE: /* Handled in config.c */
1462 default:
1463 log_warn(LD_BUG,"Illegal command number %d: internal error.",
1464 get_options()->command);
1465 result = -1;
1466 }
1467 tor_cleanup();
1468 done:
1469 tor_free(argv);
1470 return result;
1471}
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:2078
void channel_listener_dumpstats(int severity)
Definition: channel.c:2109
Header file for channel.c.
void channelpadding_new_consensus_params(const networkstatus_t *ns)
uint64_t stats_n_padding_cells_processed
Definition: channeltls.c:84
void circuit_mark_all_dirty_circs_as_unusable(void)
Definition: circuitlist.c:2075
void circuit_dump_by_conn(connection_t *conn, int severity)
Definition: circuitlist.c:1412
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)
const char * tor_libevent_get_version_str(void)
struct event_base * tor_libevent_get_base(void)
Header for compat_libevent.c.
const char * tor_compress_version_str(compress_method_t method)
Definition: compress.c:425
int tor_compress_supports_method(compress_method_t method)
Definition: compress.c:312
void tor_compress_log_init_warnings(void)
Definition: compress.c:690
Headers for compress.c.
const char * get_torrc_fname(int defaults_fname)
Definition: config.c:4783
const smartlist_t * get_configured_ports(void)
Definition: config.c:6732
int options_init_from_torrc(int argc, char **argv)
Definition: config.c:4489
int quiet
Definition: config.c:2479
static char * torrc_defaults_fname
Definition: config.c:905
void init_protocol_warning_severity_level(void)
Definition: config.c:1196
char * options_dump(const or_options_t *options, int how_to_dump)
Definition: config.c:2950
static char * torrc_fname
Definition: config.c:903
const or_options_t * get_options(void)
Definition: config.c:947
int set_options(or_options_t *new_val, char **msg)
Definition: config.c:983
tor_cmdline_mode_t command
Definition: config.c:2477
parsed_cmdline_t * config_parse_commandline(int argc, char **argv, int ignore_errors)
Definition: config.c:2553
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:5033
void connection_dump_buffer_mem_stats(int severity)
Definition: connection.c:5619
void connection_bucket_init(void)
Definition: connection.c:3832
const char * connection_describe(const connection_t *conn)
Definition: connection.c:541
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:79
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.
int cpuworker_init(void)
Definition: cpuworker.c:118
void cpuworker_log_onionskin_overhead(int severity, int onionskin_type, const char *onionskin_type_name)
Definition: cpuworker.c:352
void cpuworkers_rotate_keyinfo(void)
Definition: cpuworker.c:248
Header file for cpuworker.c.
void digest256_to_base64(char *d64, const char *digest)
const char * ed25519_fmt(const ed25519_public_key_t *pkey)
Header for crypto_format.c.
const char * crypto_get_library_version_string(void)
Definition: crypto_init.c:191
const char * crypto_get_library_name(void)
Definition: crypto_init.c:178
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:233
void dump_dns_mem_usage(int severity)
Definition: dns.c:2229
int dns_reset(void)
Definition: dns.c:246
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 write_str_to_file(const char *fname, const char *str, int bin)
Definition: files.c:275
int tor_unlink(const char *pathname)
Definition: files.c:155
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:226
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:4347
void hs_service_dump_stats(int severity)
Definition: hs_service.c:4524
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_version_str(void)
Definition: libc.c:51
const char * tor_libc_get_name(void)
Definition: libc.c:36
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:591
void truncate_logs(void)
Definition: log.c:1462
void switch_logs_debug(void)
Definition: log.c:1447
int get_min_log_level(void)
Definition: log.c:1432
void log_set_application_name(const char *name)
Definition: log.c:212
void tor_log_get_logfile_names(smartlist_t *out)
Definition: log.c:684
#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:659
int tor_run_main(const tor_main_configuration_t *tor_cfg)
Definition: main.c:1368
static int do_dump_config(void)
Definition: main.c:805
static int do_list_fingerprint(void)
Definition: main.c:733
struct event * signal_event
Definition: main.c:447
void release_lockfile(void)
Definition: main.c:710
static void do_hash_password(void)
Definition: main.c:787
int tor_init(int argc, char *argv[])
Definition: main.c:539
int try_locking(const or_options_t *options, int err_if_locked)
Definition: main.c:667
static int do_keygen_family(const char *fname_base)
Definition: main.c:837
static void process_signal(int sig)
Definition: main.c:220
static void dumpstats(int severity)
Definition: main.c:332
int have_lockfile(void)
Definition: main.c:703
static void dumpmemusage(int severity)
Definition: main.c:319
int signal_value
Definition: main.c:442
int try_to_register
Definition: main.c:445
static void signal_callback(evutil_socket_t fd, short events, void *arg)
Definition: main.c:207
void tor_remove_file(const char *filename)
Definition: main.c:723
static int do_hup(void)
Definition: main.c:114
void handle_signals(void)
Definition: main.c:485
void pubsub_install(void)
Definition: main.c:1341
void pubsub_connect(void)
Definition: main.c:1353
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:2226
void do_signewnym(time_t now)
Definition: mainloop.c:1326
void initialize_mainloop_events(void)
Definition: mainloop.c:2361
int do_main_loop(void)
Definition: mainloop.c:2375
void schedule_rescan_periodic_events(void)
Definition: mainloop.c:1585
smartlist_t * get_connection_array(void)
Definition: mainloop.c:443
void tor_shutdown_event_loop_and_exit(int exitcode)
Definition: mainloop.c:773
void tor_init_connection_lists(void)
Definition: mainloop.c:404
void directory_info_has_arrived(time_t now, int from_cache, int suppress_logs)
Definition: mainloop.c:1124
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_malloc_(size_t size)
Definition: malloc.c:32
void * tor_realloc_(void *ptr, size_t size)
Definition: malloc.c:118
#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)
networkstatus_t * networkstatus_get_latest_consensus(void)
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_MAX
Definition: or.h:567
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:2185
void dump_cell_pool_usage(int severity)
Definition: relay.c:2679
uint64_t stats_n_relay_cells_relayed
Definition: relay.c:137
uint64_t stats_n_data_cells_packaged
Definition: relay.c:2179
uint64_t stats_n_data_bytes_received
Definition: relay.c:2189
uint64_t stats_n_relay_cells_delivered
Definition: relay.c:141
uint64_t stats_n_data_bytes_packaged
Definition: relay.c:2183
Header file for relay.c.
uint64_t rephist_total_alloc
Definition: rephist.c:95
void rep_hist_init(void)
Definition: rephist.c:625
void rep_hist_dump_stats(time_t now, int severity)
Definition: rephist.c:946
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:3674
int init_keys(void)
Definition: router.c:993
int client_identity_key_is_set(void)
Definition: router.c:465
int load_ed_keys(const or_options_t *options, time_t now)
Definition: routerkeys.c:63
smartlist_t * list_family_key_files(const or_options_t *options, const char *keydir)
Definition: routerkeys.c:782
int create_family_id_key(const char *fname, ed25519_public_key_t *pk_out)
Definition: routerkeys.c:876
int log_cert_expiration(void)
Definition: routerkeys.c:614
int generate_ed_link_cert(const or_options_t *options, time_t now, int force)
Definition: routerkeys.c:373
int load_family_id_keys(const or_options_t *options, const networkstatus_t *ns)
Definition: routerkeys.c:912
Header for routerkeys.c.
void dump_routerlist_mem_usage(int severity)
Definition: routerlist.c:1066
int router_reload_router_list(void)
Definition: routerlist.c:458
void routerlist_reset_warnings(void)
Definition: routerlist.c:1539
void router_reset_descriptor_download_failures(void)
Definition: routerlist.c:2935
Header file for routerlist.c.
int server_mode(const or_options_t *options)
Definition: routermode.c:34
Header file for routermode.c.
void routerparse_init(void)
Definition: routerparse.c:1388
Header file for routerparse.c.
int sandbox_cfg_allow_open_filename(sandbox_cfg_t **cfg, char *file)
Definition: sandbox.c:2299
int sandbox_cfg_allow_stat_filename(sandbox_cfg_t **cfg, char *file)
Definition: sandbox.c:2320
sandbox_cfg_t * sandbox_cfg_new(void)
Definition: sandbox.c:2269
int sandbox_init(sandbox_cfg_t *cfg)
Definition: sandbox.c:2275
int sandbox_cfg_allow_openat_filename(sandbox_cfg_t **cfg, char *file)
Definition: sandbox.c:2306
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:111
void tor_cleanup(void)
Definition: shutdown.c:60
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
char * FamilyKeyDirectory
Definition: or_options_st.h:94
struct smartlist_t * FilesOpenedByIncludes
char * V3BandwidthsFile
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_KEYGEN_FAMILY
@ 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:636
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:103
void notify_pending_waitpid_callbacks(void)
Definition: waitpid.c:141
Headers for waitpid.c.
#define ED25519_BASE64_LEN
Definition: x25519_sizes.h:43