2006-02-09 06:46:49 +01:00
|
|
|
/* Copyright (c) 2001 Matej Pfajfar.
|
|
|
|
* Copyright (c) 2001-2004, Roger Dingledine.
|
2007-12-12 22:09:01 +01:00
|
|
|
* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
|
2011-01-03 17:50:39 +01:00
|
|
|
* Copyright (c) 2007-2011, The Tor Project, Inc. */
|
Implemented link padding and receiver token buckets
Each socket reads at most 'bandwidth' bytes per second sustained, but
can handle bursts of up to 10*bandwidth bytes.
Cells are now sent out at evenly-spaced intervals, with padding sent
out otherwise. Set Linkpadding=0 in the rc file to send cells as soon
as they're available (and to never send padding cells).
Added license/copyrights statements at the top of most files.
router->min and router->max have been merged into a single 'bandwidth'
value. We should make the routerinfo_t reflect this (want to do that,
Mat?)
As the bandwidth increases, and we want to stop sleeping more and more
frequently to send a single cell, cpu usage goes up. At 128kB/s we're
pretty much calling poll with a timeout of 1ms or even 0ms. The current
code takes a timeout of 0-9ms and makes it 10ms. prepare_for_poll()
handles everything that should have happened in the past, so as long as
our buffers don't get too full in that 10ms, we're ok.
Speaking of too full, if you run three servers at 100kB/s with -l debug,
it spends too much time printing debugging messages to be able to keep
up with the cells. The outbuf ultimately fills up and it kills that
connection. If you run with -l err, it works fine up through 500kB/s and
probably beyond. Down the road we'll want to teach it to recognize when
an outbuf is getting full, and back off.
svn:r50
2002-07-16 03:12:15 +02:00
|
|
|
/* See LICENSE for licensing information */
|
2005-06-11 07:31:17 +02:00
|
|
|
|
2004-05-10 06:48:13 +02:00
|
|
|
/**
|
2004-11-30 07:17:35 +01:00
|
|
|
* \file config.c
|
|
|
|
* \brief Code to parse and interpret configuration files.
|
2004-05-10 06:48:13 +02:00
|
|
|
**/
|
|
|
|
|
2007-04-11 15:18:25 +02:00
|
|
|
#define CONFIG_PRIVATE
|
|
|
|
|
2002-06-27 00:45:49 +02:00
|
|
|
#include "or.h"
|
2010-07-22 01:21:00 +02:00
|
|
|
#include "circuitbuild.h"
|
2010-07-22 09:46:23 +02:00
|
|
|
#include "circuitlist.h"
|
2010-07-22 10:22:51 +02:00
|
|
|
#include "config.h"
|
2010-07-22 10:32:52 +02:00
|
|
|
#include "connection.h"
|
2010-07-22 10:43:02 +02:00
|
|
|
#include "connection_edge.h"
|
2010-08-15 10:01:42 +02:00
|
|
|
#include "connection_or.h"
|
2010-07-22 11:35:09 +02:00
|
|
|
#include "control.h"
|
2010-07-22 11:40:39 +02:00
|
|
|
#include "cpuworker.h"
|
2010-07-22 12:09:49 +02:00
|
|
|
#include "dirserv.h"
|
2010-07-22 12:19:28 +02:00
|
|
|
#include "dirvote.h"
|
2010-07-22 12:24:25 +02:00
|
|
|
#include "dns.h"
|
2010-07-21 14:38:52 +02:00
|
|
|
#include "geoip.h"
|
2010-07-22 12:30:46 +02:00
|
|
|
#include "hibernate.h"
|
2010-07-23 19:58:06 +02:00
|
|
|
#include "main.h"
|
2010-07-23 20:18:55 +02:00
|
|
|
#include "networkstatus.h"
|
2010-07-23 20:51:25 +02:00
|
|
|
#include "policies.h"
|
2010-07-23 21:53:11 +02:00
|
|
|
#include "relay.h"
|
2010-07-22 00:13:51 +02:00
|
|
|
#include "rendclient.h"
|
2010-07-22 00:30:17 +02:00
|
|
|
#include "rendservice.h"
|
2010-07-23 22:57:20 +02:00
|
|
|
#include "rephist.h"
|
2010-07-21 16:17:10 +02:00
|
|
|
#include "router.h"
|
2010-07-21 17:08:11 +02:00
|
|
|
#include "routerlist.h"
|
2004-08-18 05:42:55 +02:00
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
#include <shlobj.h>
|
|
|
|
#endif
|
2002-10-03 04:17:41 +02:00
|
|
|
|
2011-05-15 17:23:04 +02:00
|
|
|
#include "procmon.h"
|
|
|
|
|
2004-05-10 06:48:13 +02:00
|
|
|
/** Enumeration of types which option values can take */
|
|
|
|
typedef enum config_type_t {
|
2004-10-14 04:47:09 +02:00
|
|
|
CONFIG_TYPE_STRING = 0, /**< An arbitrary string. */
|
2008-06-16 20:09:53 +02:00
|
|
|
CONFIG_TYPE_FILENAME, /**< A filename: some prefixes get expanded. */
|
2004-10-14 04:47:09 +02:00
|
|
|
CONFIG_TYPE_UINT, /**< A non-negative integer less than MAX_INT */
|
2011-05-02 21:05:10 +02:00
|
|
|
CONFIG_TYPE_PORT, /**< A port from 1...65535, 0 for "not set", or
|
|
|
|
* "auto". */
|
2004-11-22 22:56:51 +01:00
|
|
|
CONFIG_TYPE_INTERVAL, /**< A number of seconds, with optional units*/
|
2010-08-27 08:13:54 +02:00
|
|
|
CONFIG_TYPE_MSEC_INTERVAL,/**< A number of milliseconds, with optional
|
|
|
|
* units */
|
2004-11-22 22:56:51 +01:00
|
|
|
CONFIG_TYPE_MEMUNIT, /**< A number of bytes, with optional units*/
|
2004-10-14 04:47:09 +02:00
|
|
|
CONFIG_TYPE_DOUBLE, /**< A floating-point value */
|
|
|
|
CONFIG_TYPE_BOOL, /**< A boolean value, expressed as 0 or 1. */
|
2010-11-08 19:34:40 +01:00
|
|
|
CONFIG_TYPE_AUTOBOOL, /**< A boolean+auto value, expressed 0 for false,
|
|
|
|
* 1 for true, and -1 for auto */
|
2009-05-27 23:55:51 +02:00
|
|
|
CONFIG_TYPE_ISOTIME, /**< An ISO-formatted time relative to GMT. */
|
2005-12-14 21:40:40 +01:00
|
|
|
CONFIG_TYPE_CSV, /**< A list of strings, separated by commas and
|
|
|
|
* optional whitespace. */
|
2004-10-14 04:47:09 +02:00
|
|
|
CONFIG_TYPE_LINELIST, /**< Uninterpreted config lines */
|
2004-11-04 23:31:50 +01:00
|
|
|
CONFIG_TYPE_LINELIST_S, /**< Uninterpreted, context-sensitive config lines,
|
|
|
|
* mixed with other keywords. */
|
|
|
|
CONFIG_TYPE_LINELIST_V, /**< Catch-all "virtual" option to summarize
|
|
|
|
* context-sensitive config lines when fetching.
|
|
|
|
*/
|
2008-07-18 20:36:32 +02:00
|
|
|
CONFIG_TYPE_ROUTERSET, /**< A list of router names, addrs, and fps,
|
|
|
|
* parsed into a routerset_t. */
|
2004-10-14 04:47:09 +02:00
|
|
|
CONFIG_TYPE_OBSOLETE, /**< Obsolete (ignored) option. */
|
2004-05-10 06:48:13 +02:00
|
|
|
} config_type_t;
|
2003-09-08 07:16:18 +02:00
|
|
|
|
2005-10-06 07:08:00 +02:00
|
|
|
/** An abbreviation for a configuration option allowed on the command line. */
|
2004-10-27 04:30:28 +02:00
|
|
|
typedef struct config_abbrev_t {
|
2004-10-27 23:14:11 +02:00
|
|
|
const char *abbreviated;
|
|
|
|
const char *full;
|
2004-10-27 19:37:01 +02:00
|
|
|
int commandline_only;
|
2005-10-17 05:06:00 +02:00
|
|
|
int warn;
|
2004-10-27 04:30:28 +02:00
|
|
|
} config_abbrev_t;
|
|
|
|
|
2004-10-27 19:37:01 +02:00
|
|
|
/* Handy macro for declaring "In the config file or on the command line,
|
|
|
|
* you can abbreviate <b>tok</b>s as <b>tok</b>". */
|
2005-10-17 05:06:00 +02:00
|
|
|
#define PLURAL(tok) { #tok, #tok "s", 0, 0 }
|
2004-10-27 19:37:01 +02:00
|
|
|
|
2008-12-23 18:56:31 +01:00
|
|
|
/** A list of abbreviations and aliases to map command-line options, obsolete
|
|
|
|
* option names, or alternative option names, to their current values. */
|
2005-07-28 21:01:48 +02:00
|
|
|
static config_abbrev_t _option_abbrevs[] = {
|
2004-10-27 19:37:01 +02:00
|
|
|
PLURAL(ExitNode),
|
2004-11-09 07:09:06 +01:00
|
|
|
PLURAL(EntryNode),
|
2004-10-27 19:37:01 +02:00
|
|
|
PLURAL(ExcludeNode),
|
|
|
|
PLURAL(FirewallPort),
|
2005-01-12 05:58:23 +01:00
|
|
|
PLURAL(LongLivedPort),
|
2004-10-27 19:37:01 +02:00
|
|
|
PLURAL(HiddenServiceNode),
|
|
|
|
PLURAL(HiddenServiceExcludeNode),
|
2010-10-29 19:41:24 +02:00
|
|
|
PLURAL(NumCPU),
|
2004-10-27 19:37:01 +02:00
|
|
|
PLURAL(RendNode),
|
|
|
|
PLURAL(RendExcludeNode),
|
2004-11-21 00:16:03 +01:00
|
|
|
PLURAL(StrictEntryNode),
|
|
|
|
PLURAL(StrictExitNode),
|
2009-09-18 04:45:54 +02:00
|
|
|
PLURAL(StrictNode),
|
2005-10-18 01:00:08 +02:00
|
|
|
{ "l", "Log", 1, 0},
|
2006-03-19 02:21:59 +01:00
|
|
|
{ "AllowUnverifiedNodes", "AllowInvalidNodes", 0, 0},
|
2007-05-25 16:48:16 +02:00
|
|
|
{ "AutomapHostSuffixes", "AutomapHostsSuffixes", 0, 0},
|
|
|
|
{ "AutomapHostOnResolve", "AutomapHostsOnResolve", 0, 0},
|
2005-10-17 05:06:00 +02:00
|
|
|
{ "BandwidthRateBytes", "BandwidthRate", 0, 0},
|
|
|
|
{ "BandwidthBurstBytes", "BandwidthBurst", 0, 0},
|
|
|
|
{ "DirFetchPostPeriod", "StatusFetchPeriod", 0, 0},
|
|
|
|
{ "MaxConn", "ConnLimit", 0, 1},
|
2005-11-11 18:04:14 +01:00
|
|
|
{ "ORBindAddress", "ORListenAddress", 0, 0},
|
|
|
|
{ "DirBindAddress", "DirListenAddress", 0, 0},
|
|
|
|
{ "SocksBindAddress", "SocksListenAddress", 0, 0},
|
2006-01-10 23:42:44 +01:00
|
|
|
{ "UseHelperNodes", "UseEntryGuards", 0, 0},
|
|
|
|
{ "NumHelperNodes", "NumEntryGuards", 0, 0},
|
|
|
|
{ "UseEntryNodes", "UseEntryGuards", 0, 0},
|
|
|
|
{ "NumEntryNodes", "NumEntryGuards", 0, 0},
|
2006-09-21 23:48:16 +02:00
|
|
|
{ "ResolvConf", "ServerDNSResolvConfFile", 0, 1},
|
|
|
|
{ "SearchDomains", "ServerDNSSearchDomains", 0, 1},
|
2009-09-18 04:45:54 +02:00
|
|
|
{ "ServerDNSAllowBrokenResolvConf", "ServerDNSAllowBrokenConfig", 0, 0},
|
2007-11-11 02:06:16 +01:00
|
|
|
{ "PreferTunnelledDirConns", "PreferTunneledDirConns", 0, 0},
|
2007-12-19 05:58:58 +01:00
|
|
|
{ "BridgeAuthoritativeDirectory", "BridgeAuthoritativeDir", 0, 0},
|
2008-02-23 00:20:28 +01:00
|
|
|
{ "HashedControlPassword", "__HashedControlSessionPassword", 1, 0},
|
2009-09-18 04:45:54 +02:00
|
|
|
{ "StrictEntryNodes", "StrictNodes", 0, 1},
|
|
|
|
{ "StrictExitNodes", "StrictNodes", 0, 1},
|
2005-12-28 10:07:31 +01:00
|
|
|
{ NULL, NULL, 0, 0},
|
|
|
|
};
|
2008-12-23 18:56:31 +01:00
|
|
|
|
|
|
|
/** A list of state-file "abbreviations," for compatibility. */
|
2005-12-28 10:07:31 +01:00
|
|
|
static config_abbrev_t _state_abbrevs[] = {
|
2006-01-06 16:43:03 +01:00
|
|
|
{ "AccountingBytesReadInterval", "AccountingBytesReadInInterval", 0, 0 },
|
2006-01-10 23:42:44 +01:00
|
|
|
{ "HelperNode", "EntryGuard", 0, 0 },
|
|
|
|
{ "HelperNodeDownSince", "EntryGuardDownSince", 0, 0 },
|
|
|
|
{ "HelperNodeUnlistedSince", "EntryGuardUnlistedSince", 0, 0 },
|
|
|
|
{ "EntryNode", "EntryGuard", 0, 0 },
|
|
|
|
{ "EntryNodeDownSince", "EntryGuardDownSince", 0, 0 },
|
|
|
|
{ "EntryNodeUnlistedSince", "EntryGuardUnlistedSince", 0, 0 },
|
2005-10-17 05:06:00 +02:00
|
|
|
{ NULL, NULL, 0, 0},
|
2004-10-27 04:30:28 +02:00
|
|
|
};
|
2004-10-27 19:37:01 +02:00
|
|
|
#undef PLURAL
|
2004-10-27 04:30:28 +02:00
|
|
|
|
2004-11-03 11:08:44 +01:00
|
|
|
/** A variable allowed in the configuration file or on the command line. */
|
2004-10-27 04:30:28 +02:00
|
|
|
typedef struct config_var_t {
|
2004-11-03 11:08:44 +01:00
|
|
|
const char *name; /**< The full keyword (case insensitive). */
|
2005-12-14 21:40:40 +01:00
|
|
|
config_type_t type; /**< How to interpret the type and turn it into a
|
|
|
|
* value. */
|
2004-11-03 11:08:44 +01:00
|
|
|
off_t var_offset; /**< Offset of the corresponding member of or_options_t. */
|
|
|
|
const char *initvalue; /**< String (or null) describing initial value. */
|
2004-10-27 04:30:28 +02:00
|
|
|
} config_var_t;
|
|
|
|
|
2004-10-27 05:08:04 +02:00
|
|
|
/** An entry for config_vars: "The option <b>name</b> has type
|
|
|
|
* CONFIG_TYPE_<b>conftype</b>, and corresponds to
|
|
|
|
* or_options_t.<b>member</b>"
|
|
|
|
*/
|
2005-12-14 21:40:40 +01:00
|
|
|
#define VAR(name,conftype,member,initvalue) \
|
|
|
|
{ name, CONFIG_TYPE_ ## conftype, STRUCT_OFFSET(or_options_t, member), \
|
2006-01-06 16:43:03 +01:00
|
|
|
initvalue }
|
2007-08-27 20:56:20 +02:00
|
|
|
/** As VAR, but the option name and member name are the same. */
|
|
|
|
#define V(member,conftype,initvalue) \
|
|
|
|
VAR(#member, conftype, member, initvalue)
|
2004-10-27 05:08:04 +02:00
|
|
|
/** An entry for config_vars: "The option <b>name</b> is obsolete." */
|
2006-01-06 16:43:03 +01:00
|
|
|
#define OBSOLETE(name) { name, CONFIG_TYPE_OBSOLETE, 0, NULL }
|
2004-10-27 04:30:28 +02:00
|
|
|
|
2004-10-27 05:08:04 +02:00
|
|
|
/** Array of configuration options. Until we disallow nonstandard
|
|
|
|
* abbreviations, order is significant, since the first matching option will
|
|
|
|
* be chosen first.
|
|
|
|
*/
|
2005-07-28 21:01:48 +02:00
|
|
|
static config_var_t _option_vars[] = {
|
2006-12-20 22:02:10 +01:00
|
|
|
OBSOLETE("AccountingMaxKB"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(AccountingMax, MEMUNIT, "0 bytes"),
|
|
|
|
V(AccountingStart, STRING, NULL),
|
|
|
|
V(Address, STRING, NULL),
|
2009-08-08 01:26:41 +02:00
|
|
|
V(AllowDotExit, BOOL, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(AllowInvalidNodes, CSV, "middle,rendezvous"),
|
|
|
|
V(AllowNonRFC953Hostnames, BOOL, "0"),
|
2008-09-26 20:58:45 +02:00
|
|
|
V(AllowSingleHopCircuits, BOOL, "0"),
|
|
|
|
V(AllowSingleHopExits, BOOL, "0"),
|
2007-12-12 05:38:54 +01:00
|
|
|
V(AlternateBridgeAuthority, LINELIST, NULL),
|
|
|
|
V(AlternateDirAuthority, LINELIST, NULL),
|
|
|
|
V(AlternateHSAuthority, LINELIST, NULL),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(AssumeReachable, BOOL, "0"),
|
2007-12-10 17:49:54 +01:00
|
|
|
V(AuthDirBadDir, LINELIST, NULL),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(AuthDirBadExit, LINELIST, NULL),
|
|
|
|
V(AuthDirInvalid, LINELIST, NULL),
|
|
|
|
V(AuthDirReject, LINELIST, NULL),
|
|
|
|
V(AuthDirRejectUnlisted, BOOL, "0"),
|
2007-12-10 17:49:54 +01:00
|
|
|
V(AuthDirListBadDirs, BOOL, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(AuthDirListBadExits, BOOL, "0"),
|
2008-01-10 17:08:47 +01:00
|
|
|
V(AuthDirMaxServersPerAddr, UINT, "2"),
|
|
|
|
V(AuthDirMaxServersPerAuthAddr,UINT, "5"),
|
2007-08-27 20:56:20 +02:00
|
|
|
VAR("AuthoritativeDirectory", BOOL, AuthoritativeDir, "0"),
|
|
|
|
V(AutomapHostsOnResolve, BOOL, "0"),
|
|
|
|
V(AutomapHostsSuffixes, CSV, ".onion,.exit"),
|
|
|
|
V(AvoidDiskWrites, BOOL, "0"),
|
2007-11-03 23:08:52 +01:00
|
|
|
V(BandwidthBurst, MEMUNIT, "10 MB"),
|
|
|
|
V(BandwidthRate, MEMUNIT, "5 MB"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(BridgeAuthoritativeDir, BOOL, "0"),
|
|
|
|
VAR("Bridge", LINELIST, Bridges, NULL),
|
2007-12-22 11:54:21 +01:00
|
|
|
V(BridgePassword, STRING, NULL),
|
2007-12-17 23:44:11 +01:00
|
|
|
V(BridgeRecordUsageByCountry, BOOL, "1"),
|
2007-12-04 19:35:03 +01:00
|
|
|
V(BridgeRelay, BOOL, "0"),
|
2009-07-05 19:53:25 +02:00
|
|
|
V(CellStatistics, BOOL, "0"),
|
2010-05-08 20:54:29 +02:00
|
|
|
V(LearnCircuitBuildTimeout, BOOL, "1"),
|
2009-09-02 05:27:43 +02:00
|
|
|
V(CircuitBuildTimeout, INTERVAL, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(CircuitIdleTimeout, INTERVAL, "1 hour"),
|
2009-11-22 05:36:36 +01:00
|
|
|
V(CircuitStreamTimeout, INTERVAL, "0"),
|
2009-12-15 19:53:53 +01:00
|
|
|
V(CircuitPriorityHalflife, DOUBLE, "-100.0"), /*negative:'Use default'*/
|
2007-08-27 20:56:20 +02:00
|
|
|
V(ClientDNSRejectInternalAddresses, BOOL,"1"),
|
2011-01-26 17:35:24 +01:00
|
|
|
V(ClientRejectInternalAddresses, BOOL, "1"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(ClientOnly, BOOL, "0"),
|
2009-09-15 10:40:08 +02:00
|
|
|
V(ConsensusParams, STRING, NULL),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(ConnLimit, UINT, "1000"),
|
2010-08-15 14:58:35 +02:00
|
|
|
V(ConnDirectionStatistics, BOOL, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(ConstrainedSockets, BOOL, "0"),
|
|
|
|
V(ConstrainedSockSize, MEMUNIT, "8192"),
|
|
|
|
V(ContactInfo, STRING, NULL),
|
|
|
|
V(ControlListenAddress, LINELIST, NULL),
|
2011-05-02 21:05:10 +02:00
|
|
|
V(ControlPort, PORT, "0"),
|
2011-05-13 01:17:48 +02:00
|
|
|
V(ControlPortFileGroupReadable,BOOL, "0"),
|
2011-05-09 18:13:37 +02:00
|
|
|
V(ControlPortWriteToFile, FILENAME, NULL),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(ControlSocket, LINELIST, NULL),
|
2011-05-30 21:31:06 +02:00
|
|
|
V(ControlSocketsGroupWritable, BOOL, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(CookieAuthentication, BOOL, "0"),
|
|
|
|
V(CookieAuthFileGroupReadable, BOOL, "0"),
|
|
|
|
V(CookieAuthFile, STRING, NULL),
|
2011-04-05 20:50:32 +02:00
|
|
|
V(CountPrivateBandwidth, BOOL, "0"),
|
2008-06-16 20:09:53 +02:00
|
|
|
V(DataDirectory, FILENAME, NULL),
|
2006-12-20 22:02:10 +01:00
|
|
|
OBSOLETE("DebugLogFile"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(DirAllowPrivateAddresses, BOOL, NULL),
|
2008-06-20 19:03:13 +02:00
|
|
|
V(TestingAuthDirTimeToLearnReachability, INTERVAL, "30 minutes"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(DirListenAddress, LINELIST, NULL),
|
2006-04-10 22:16:46 +02:00
|
|
|
OBSOLETE("DirFetchPeriod"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(DirPolicy, LINELIST, NULL),
|
2011-05-02 21:05:10 +02:00
|
|
|
V(DirPort, PORT, "0"),
|
2008-12-08 19:00:34 +01:00
|
|
|
V(DirPortFrontPage, FILENAME, NULL),
|
2005-08-22 23:53:12 +02:00
|
|
|
OBSOLETE("DirPostPeriod"),
|
2009-05-27 17:52:46 +02:00
|
|
|
OBSOLETE("DirRecordUsageByCountry"),
|
|
|
|
OBSOLETE("DirRecordUsageGranularity"),
|
|
|
|
OBSOLETE("DirRecordUsageRetainIPs"),
|
|
|
|
OBSOLETE("DirRecordUsageSaveInterval"),
|
2010-11-09 14:18:00 +01:00
|
|
|
V(DirReqStatistics, BOOL, "1"),
|
2007-08-27 20:56:20 +02:00
|
|
|
VAR("DirServer", LINELIST, DirServers, NULL),
|
2009-10-22 06:21:57 +02:00
|
|
|
V(DisableAllSwap, BOOL, "0"),
|
2010-09-28 20:01:45 +02:00
|
|
|
V(DisableIOCP, BOOL, "1"),
|
2011-05-02 21:05:10 +02:00
|
|
|
V(DNSPort, PORT, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(DNSListenAddress, LINELIST, NULL),
|
|
|
|
V(DownloadExtraInfo, BOOL, "0"),
|
|
|
|
V(EnforceDistinctSubnets, BOOL, "1"),
|
2008-09-25 22:21:35 +02:00
|
|
|
V(EntryNodes, ROUTERSET, NULL),
|
2009-07-05 20:48:16 +02:00
|
|
|
V(EntryStatistics, BOOL, "0"),
|
2008-06-20 19:03:13 +02:00
|
|
|
V(TestingEstimatedDescriptorPropagationTime, INTERVAL, "10 minutes"),
|
2008-07-18 20:36:32 +02:00
|
|
|
V(ExcludeNodes, ROUTERSET, NULL),
|
|
|
|
V(ExcludeExitNodes, ROUTERSET, NULL),
|
2008-09-26 20:58:45 +02:00
|
|
|
V(ExcludeSingleHopRelays, BOOL, "1"),
|
2008-09-25 22:21:35 +02:00
|
|
|
V(ExitNodes, ROUTERSET, NULL),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(ExitPolicy, LINELIST, NULL),
|
|
|
|
V(ExitPolicyRejectPrivate, BOOL, "1"),
|
2009-06-24 19:51:45 +02:00
|
|
|
V(ExitPortStatistics, BOOL, "0"),
|
2010-11-09 14:18:00 +01:00
|
|
|
V(ExtraInfoStatistics, BOOL, "1"),
|
2009-12-15 19:53:53 +01:00
|
|
|
|
2010-05-21 04:53:39 +02:00
|
|
|
#if defined (WINCE)
|
|
|
|
V(FallbackNetworkstatusFile, FILENAME, "fallback-consensus"),
|
|
|
|
#else
|
2008-06-16 20:09:53 +02:00
|
|
|
V(FallbackNetworkstatusFile, FILENAME,
|
2007-10-29 16:15:49 +01:00
|
|
|
SHARE_DATADIR PATH_SEPARATOR "tor" PATH_SEPARATOR "fallback-consensus"),
|
2010-05-21 04:53:39 +02:00
|
|
|
#endif
|
2007-08-27 20:56:20 +02:00
|
|
|
V(FascistFirewall, BOOL, "0"),
|
|
|
|
V(FirewallPorts, CSV, ""),
|
|
|
|
V(FastFirstHopPK, BOOL, "1"),
|
2007-12-21 07:08:00 +01:00
|
|
|
V(FetchDirInfoEarly, BOOL, "0"),
|
2009-07-12 03:43:33 +02:00
|
|
|
V(FetchDirInfoExtraEarly, BOOL, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(FetchServerDescriptors, BOOL, "1"),
|
|
|
|
V(FetchHidServDescriptors, BOOL, "1"),
|
|
|
|
V(FetchUselessDescriptors, BOOL, "0"),
|
2011-04-28 16:05:32 +02:00
|
|
|
V(FetchV2Networkstatus, BOOL, "0"),
|
2008-05-29 03:22:30 +02:00
|
|
|
#ifdef WIN32
|
2008-06-16 20:09:53 +02:00
|
|
|
V(GeoIPFile, FILENAME, "<default>"),
|
2008-05-29 03:22:30 +02:00
|
|
|
#else
|
2008-06-16 20:09:53 +02:00
|
|
|
V(GeoIPFile, FILENAME,
|
|
|
|
SHARE_DATADIR PATH_SEPARATOR "tor" PATH_SEPARATOR "geoip"),
|
2008-05-29 03:22:30 +02:00
|
|
|
#endif
|
2008-11-07 03:06:12 +01:00
|
|
|
OBSOLETE("Group"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(HardwareAccel, BOOL, "0"),
|
2010-12-01 02:24:03 +01:00
|
|
|
V(HeartbeatPeriod, INTERVAL, "6 hours"),
|
2009-05-24 01:42:44 +02:00
|
|
|
V(AccelName, STRING, NULL),
|
|
|
|
V(AccelDir, FILENAME, NULL),
|
2007-12-09 05:59:27 +01:00
|
|
|
V(HashedControlPassword, LINELIST, NULL),
|
2008-09-11 22:06:04 +02:00
|
|
|
V(HidServDirectoryV2, BOOL, "1"),
|
2005-08-05 03:35:43 +02:00
|
|
|
VAR("HiddenServiceDir", LINELIST_S, RendConfigLines, NULL),
|
2008-07-23 16:07:32 +02:00
|
|
|
OBSOLETE("HiddenServiceExcludeNodes"),
|
|
|
|
OBSOLETE("HiddenServiceNodes"),
|
2005-08-05 03:35:43 +02:00
|
|
|
VAR("HiddenServiceOptions",LINELIST_V, RendConfigLines, NULL),
|
|
|
|
VAR("HiddenServicePort", LINELIST_S, RendConfigLines, NULL),
|
2007-10-31 21:48:06 +01:00
|
|
|
VAR("HiddenServiceVersion",LINELIST_S, RendConfigLines, NULL),
|
2008-08-08 16:36:11 +02:00
|
|
|
VAR("HiddenServiceAuthorizeClient",LINELIST_S,RendConfigLines, NULL),
|
2008-08-12 18:12:26 +02:00
|
|
|
V(HidServAuth, LINELIST, NULL),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(HSAuthoritativeDir, BOOL, "0"),
|
2009-10-28 07:47:47 +01:00
|
|
|
OBSOLETE("HSAuthorityRecordStats"),
|
2010-10-29 19:41:24 +02:00
|
|
|
V(HTTPProxy, STRING, NULL),
|
|
|
|
V(HTTPProxyAuthenticator, STRING, NULL),
|
|
|
|
V(HTTPSProxy, STRING, NULL),
|
|
|
|
V(HTTPSProxyAuthenticator, STRING, NULL),
|
2009-06-19 01:59:18 +02:00
|
|
|
V(Socks4Proxy, STRING, NULL),
|
|
|
|
V(Socks5Proxy, STRING, NULL),
|
|
|
|
V(Socks5ProxyUsername, STRING, NULL),
|
|
|
|
V(Socks5ProxyPassword, STRING, NULL),
|
2005-08-08 23:52:57 +02:00
|
|
|
OBSOLETE("IgnoreVersion"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(KeepalivePeriod, INTERVAL, "5 minutes"),
|
|
|
|
VAR("Log", LINELIST, Logs, NULL),
|
2011-01-25 21:53:15 +01:00
|
|
|
V(LogMessageDomains, BOOL, "0"),
|
2004-10-27 04:30:28 +02:00
|
|
|
OBSOLETE("LinkPadding"),
|
2006-12-20 22:02:10 +01:00
|
|
|
OBSOLETE("LogLevel"),
|
|
|
|
OBSOLETE("LogFile"),
|
2010-08-27 08:13:54 +02:00
|
|
|
V(LogTimeGranularity, MSEC_INTERVAL, "1 second"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(LongLivedPorts, CSV,
|
2006-09-25 07:24:43 +02:00
|
|
|
"21,22,706,1863,5050,5190,5222,5223,6667,6697,8300"),
|
2007-08-27 20:56:20 +02:00
|
|
|
VAR("MapAddress", LINELIST, AddressMap, NULL),
|
|
|
|
V(MaxAdvertisedBandwidth, MEMUNIT, "1 GB"),
|
|
|
|
V(MaxCircuitDirtiness, INTERVAL, "10 minutes"),
|
|
|
|
V(MaxOnionsPending, UINT, "100"),
|
2005-08-15 11:17:47 +02:00
|
|
|
OBSOLETE("MonthlyAccountingStart"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(MyFamily, STRING, NULL),
|
|
|
|
V(NewCircuitPeriod, INTERVAL, "30 seconds"),
|
2005-10-08 07:47:58 +02:00
|
|
|
VAR("NamingAuthoritativeDirectory",BOOL, NamingAuthoritativeDir, "0"),
|
2010-10-30 06:08:47 +02:00
|
|
|
V(NATDListenAddress, LINELIST, NULL),
|
2011-05-02 21:05:10 +02:00
|
|
|
V(NATDPort, PORT, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(Nickname, STRING, NULL),
|
2010-06-03 12:52:34 +02:00
|
|
|
V(WarnUnsafeSocks, BOOL, "1"),
|
2010-10-30 06:38:50 +02:00
|
|
|
OBSOLETE("NoPublish"),
|
2007-08-27 20:56:20 +02:00
|
|
|
VAR("NodeFamily", LINELIST, NodeFamilies, NULL),
|
2010-11-15 20:14:13 +01:00
|
|
|
V(NumCPUs, UINT, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(NumEntryGuards, UINT, "3"),
|
|
|
|
V(ORListenAddress, LINELIST, NULL),
|
2011-05-02 21:05:10 +02:00
|
|
|
V(ORPort, PORT, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(OutboundBindAddress, STRING, NULL),
|
2007-02-08 23:07:56 +01:00
|
|
|
OBSOLETE("PathlenCoinWeight"),
|
2009-12-30 05:13:03 +01:00
|
|
|
V(PerConnBWBurst, MEMUNIT, "0"),
|
|
|
|
V(PerConnBWRate, MEMUNIT, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(PidFile, STRING, NULL),
|
2008-06-14 18:01:29 +02:00
|
|
|
V(TestingTorNetwork, BOOL, "0"),
|
2010-06-16 20:47:06 +02:00
|
|
|
V(PortForwarding, BOOL, "0"),
|
|
|
|
V(PortForwardingHelper, FILENAME, "tor-fw-helper"),
|
2008-03-10 08:50:09 +01:00
|
|
|
V(PreferTunneledDirConns, BOOL, "1"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(ProtocolWarnings, BOOL, "0"),
|
2007-12-22 09:27:42 +01:00
|
|
|
V(PublishServerDescriptor, CSV, "1"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(PublishHidServDescriptors, BOOL, "1"),
|
|
|
|
V(ReachableAddresses, LINELIST, NULL),
|
|
|
|
V(ReachableDirAddresses, LINELIST, NULL),
|
|
|
|
V(ReachableORAddresses, LINELIST, NULL),
|
|
|
|
V(RecommendedVersions, LINELIST, NULL),
|
|
|
|
V(RecommendedClientVersions, LINELIST, NULL),
|
|
|
|
V(RecommendedServerVersions, LINELIST, NULL),
|
2008-12-18 00:02:04 +01:00
|
|
|
OBSOLETE("RedirectExit"),
|
2010-11-08 19:34:40 +01:00
|
|
|
V(RefuseUnknownExits, AUTOBOOL, "auto"),
|
2008-01-20 06:54:15 +01:00
|
|
|
V(RejectPlaintextPorts, CSV, ""),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(RelayBandwidthBurst, MEMUNIT, "0"),
|
|
|
|
V(RelayBandwidthRate, MEMUNIT, "0"),
|
2008-07-23 16:07:32 +02:00
|
|
|
OBSOLETE("RendExcludeNodes"),
|
|
|
|
OBSOLETE("RendNodes"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(RendPostPeriod, INTERVAL, "1 hour"),
|
|
|
|
V(RephistTrackTime, INTERVAL, "24 hours"),
|
2004-10-27 04:30:28 +02:00
|
|
|
OBSOLETE("RouterFile"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(RunAsDaemon, BOOL, "0"),
|
2010-10-30 00:03:31 +02:00
|
|
|
// V(RunTesting, BOOL, "0"),
|
|
|
|
OBSOLETE("RunTesting"), // currently unused
|
2009-09-28 15:08:32 +02:00
|
|
|
V(SafeLogging, STRING, "1"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(SafeSocks, BOOL, "0"),
|
2008-12-17 23:58:14 +01:00
|
|
|
V(ServerDNSAllowBrokenConfig, BOOL, "1"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(ServerDNSAllowNonRFC953Hostnames, BOOL,"0"),
|
|
|
|
V(ServerDNSDetectHijacking, BOOL, "1"),
|
2008-10-29 20:20:02 +01:00
|
|
|
V(ServerDNSRandomizeCase, BOOL, "1"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(ServerDNSResolvConfFile, STRING, NULL),
|
|
|
|
V(ServerDNSSearchDomains, BOOL, "0"),
|
|
|
|
V(ServerDNSTestAddresses, CSV,
|
2006-12-28 22:29:11 +01:00
|
|
|
"www.google.com,www.mit.edu,www.yahoo.com,www.slashdot.org"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(ShutdownWaitLength, INTERVAL, "30 seconds"),
|
|
|
|
V(SocksListenAddress, LINELIST, NULL),
|
|
|
|
V(SocksPolicy, LINELIST, NULL),
|
2011-05-02 21:05:10 +02:00
|
|
|
V(SocksPort, PORT, "9050"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(SocksTimeout, INTERVAL, "2 minutes"),
|
2006-04-10 22:16:46 +02:00
|
|
|
OBSOLETE("StatusFetchPeriod"),
|
2009-09-18 04:45:54 +02:00
|
|
|
V(StrictNodes, BOOL, "0"),
|
2006-12-20 22:02:10 +01:00
|
|
|
OBSOLETE("SysLog"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(TestSocks, BOOL, "0"),
|
2008-08-05 02:12:05 +02:00
|
|
|
OBSOLETE("TestVia"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(TrackHostExits, CSV, NULL),
|
|
|
|
V(TrackHostExitsExpire, INTERVAL, "30 minutes"),
|
2004-10-27 04:30:28 +02:00
|
|
|
OBSOLETE("TrafficShaping"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(TransListenAddress, LINELIST, NULL),
|
2011-05-02 21:05:10 +02:00
|
|
|
V(TransPort, PORT, "0"),
|
2008-03-10 08:50:09 +01:00
|
|
|
V(TunnelDirConns, BOOL, "1"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(UpdateBridgesFromAuthority, BOOL, "0"),
|
2011-06-03 17:17:15 +02:00
|
|
|
VAR("UseBridges", AUTOBOOL, UseBridges_, "auto"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(UseEntryGuards, BOOL, "1"),
|
2010-11-08 20:21:32 +01:00
|
|
|
V(UseMicrodescriptors, AUTOBOOL, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(User, STRING, NULL),
|
2005-09-15 16:39:05 +02:00
|
|
|
VAR("V1AuthoritativeDirectory",BOOL, V1AuthoritativeDir, "0"),
|
2007-05-02 11:12:04 +02:00
|
|
|
VAR("V2AuthoritativeDirectory",BOOL, V2AuthoritativeDir, "0"),
|
2007-05-22 19:58:25 +02:00
|
|
|
VAR("V3AuthoritativeDirectory",BOOL, V3AuthoritativeDir, "0"),
|
2008-06-20 19:03:13 +02:00
|
|
|
V(TestingV3AuthInitialVotingInterval, INTERVAL, "30 minutes"),
|
|
|
|
V(TestingV3AuthInitialVoteDelay, INTERVAL, "5 minutes"),
|
|
|
|
V(TestingV3AuthInitialDistDelay, INTERVAL, "5 minutes"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(V3AuthVotingInterval, INTERVAL, "1 hour"),
|
|
|
|
V(V3AuthVoteDelay, INTERVAL, "5 minutes"),
|
|
|
|
V(V3AuthDistDelay, INTERVAL, "5 minutes"),
|
|
|
|
V(V3AuthNIntervalsValid, UINT, "3"),
|
2008-05-12 04:14:01 +02:00
|
|
|
V(V3AuthUseLegacyKey, BOOL, "0"),
|
2009-07-31 06:33:53 +02:00
|
|
|
V(V3BandwidthsFile, FILENAME, NULL),
|
2005-10-08 07:47:58 +02:00
|
|
|
VAR("VersioningAuthoritativeDirectory",BOOL,VersioningAuthoritativeDir, "0"),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(VirtualAddrNetwork, STRING, "127.192.0.0/10"),
|
2008-01-20 06:54:15 +01:00
|
|
|
V(WarnPlaintextPorts, CSV, "23,109,110,143"),
|
2010-11-09 21:36:27 +01:00
|
|
|
V(_UseFilteringSSLBufferevents, BOOL, "0"),
|
2008-12-10 23:17:02 +01:00
|
|
|
VAR("__ReloadTorrcOnSIGHUP", BOOL, ReloadTorrcOnSIGHUP, "1"),
|
2007-08-27 20:56:20 +02:00
|
|
|
VAR("__AllDirActionsPrivate", BOOL, AllDirActionsPrivate, "0"),
|
|
|
|
VAR("__DisablePredictedCircuits",BOOL,DisablePredictedCircuits, "0"),
|
|
|
|
VAR("__LeaveStreamsUnattached",BOOL, LeaveStreamsUnattached, "0"),
|
2008-02-17 19:45:07 +01:00
|
|
|
VAR("__HashedControlSessionPassword", LINELIST, HashedControlSessionPassword,
|
|
|
|
NULL),
|
2011-05-15 17:23:04 +02:00
|
|
|
VAR("__OwningControllerProcess",STRING,OwningControllerProcess, NULL),
|
2007-11-29 16:25:04 +01:00
|
|
|
V(MinUptimeHidServDirectoryV2, INTERVAL, "24 hours"),
|
2011-03-01 10:05:18 +01:00
|
|
|
V(_UsingTestNetworkDefaults, BOOL, "0"),
|
2009-12-10 17:12:42 +01:00
|
|
|
|
2006-01-06 16:43:03 +01:00
|
|
|
{ NULL, CONFIG_TYPE_OBSOLETE, 0, NULL }
|
2004-10-27 04:30:28 +02:00
|
|
|
};
|
2008-06-14 18:01:29 +02:00
|
|
|
|
2008-12-23 18:56:31 +01:00
|
|
|
/** Override default values with these if the user sets the TestingTorNetwork
|
|
|
|
* option. */
|
2008-06-14 18:01:29 +02:00
|
|
|
static config_var_t testing_tor_network_defaults[] = {
|
2008-12-17 23:58:14 +01:00
|
|
|
V(ServerDNSAllowBrokenConfig, BOOL, "1"),
|
2008-06-14 18:01:29 +02:00
|
|
|
V(DirAllowPrivateAddresses, BOOL, "1"),
|
|
|
|
V(EnforceDistinctSubnets, BOOL, "0"),
|
|
|
|
V(AssumeReachable, BOOL, "1"),
|
|
|
|
V(AuthDirMaxServersPerAddr, UINT, "0"),
|
|
|
|
V(AuthDirMaxServersPerAuthAddr,UINT, "0"),
|
|
|
|
V(ClientDNSRejectInternalAddresses, BOOL,"0"),
|
2011-01-26 17:35:24 +01:00
|
|
|
V(ClientRejectInternalAddresses, BOOL, "0"),
|
2011-04-05 20:50:32 +02:00
|
|
|
V(CountPrivateBandwidth, BOOL, "1"),
|
2008-06-14 18:01:29 +02:00
|
|
|
V(ExitPolicyRejectPrivate, BOOL, "0"),
|
|
|
|
V(V3AuthVotingInterval, INTERVAL, "5 minutes"),
|
|
|
|
V(V3AuthVoteDelay, INTERVAL, "20 seconds"),
|
|
|
|
V(V3AuthDistDelay, INTERVAL, "20 seconds"),
|
2008-06-20 19:03:13 +02:00
|
|
|
V(TestingV3AuthInitialVotingInterval, INTERVAL, "5 minutes"),
|
|
|
|
V(TestingV3AuthInitialVoteDelay, INTERVAL, "20 seconds"),
|
|
|
|
V(TestingV3AuthInitialDistDelay, INTERVAL, "20 seconds"),
|
|
|
|
V(TestingAuthDirTimeToLearnReachability, INTERVAL, "0 minutes"),
|
|
|
|
V(TestingEstimatedDescriptorPropagationTime, INTERVAL, "0 minutes"),
|
2010-10-26 18:37:57 +02:00
|
|
|
V(MinUptimeHidServDirectoryV2, INTERVAL, "0 minutes"),
|
2011-03-01 10:05:18 +01:00
|
|
|
V(_UsingTestNetworkDefaults, BOOL, "1"),
|
2011-04-05 20:50:32 +02:00
|
|
|
|
2008-06-14 18:01:29 +02:00
|
|
|
{ NULL, CONFIG_TYPE_OBSOLETE, 0, NULL }
|
|
|
|
};
|
2005-07-28 21:01:48 +02:00
|
|
|
#undef VAR
|
|
|
|
|
2005-12-14 21:40:40 +01:00
|
|
|
#define VAR(name,conftype,member,initvalue) \
|
|
|
|
{ name, CONFIG_TYPE_ ## conftype, STRUCT_OFFSET(or_state_t, member), \
|
2006-01-06 16:43:03 +01:00
|
|
|
initvalue }
|
2008-12-23 18:56:31 +01:00
|
|
|
|
|
|
|
/** Array of "state" variables saved to the ~/.tor/state file. */
|
2005-07-28 21:01:48 +02:00
|
|
|
static config_var_t _state_vars[] = {
|
2007-08-27 20:56:20 +02:00
|
|
|
V(AccountingBytesReadInInterval, MEMUNIT, NULL),
|
|
|
|
V(AccountingBytesWrittenInInterval, MEMUNIT, NULL),
|
|
|
|
V(AccountingExpectedUsage, MEMUNIT, NULL),
|
|
|
|
V(AccountingIntervalStart, ISOTIME, NULL),
|
|
|
|
V(AccountingSecondsActive, INTERVAL, NULL),
|
2010-09-03 20:29:17 +02:00
|
|
|
V(AccountingSecondsToReachSoftLimit,INTERVAL, NULL),
|
|
|
|
V(AccountingSoftLimitHitAt, ISOTIME, NULL),
|
|
|
|
V(AccountingBytesAtSoftLimit, MEMUNIT, NULL),
|
2007-08-24 10:01:47 +02:00
|
|
|
|
2006-01-10 23:42:44 +01:00
|
|
|
VAR("EntryGuard", LINELIST_S, EntryGuards, NULL),
|
|
|
|
VAR("EntryGuardDownSince", LINELIST_S, EntryGuards, NULL),
|
|
|
|
VAR("EntryGuardUnlistedSince", LINELIST_S, EntryGuards, NULL),
|
2007-08-29 19:22:00 +02:00
|
|
|
VAR("EntryGuardAddedBy", LINELIST_S, EntryGuards, NULL),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(EntryGuards, LINELIST_V, NULL),
|
2005-08-05 03:35:43 +02:00
|
|
|
|
2007-08-27 20:56:20 +02:00
|
|
|
V(BWHistoryReadEnds, ISOTIME, NULL),
|
|
|
|
V(BWHistoryReadInterval, UINT, "900"),
|
|
|
|
V(BWHistoryReadValues, CSV, ""),
|
2011-01-10 20:11:22 +01:00
|
|
|
V(BWHistoryReadMaxima, CSV, ""),
|
2007-08-27 20:56:20 +02:00
|
|
|
V(BWHistoryWriteEnds, ISOTIME, NULL),
|
|
|
|
V(BWHistoryWriteInterval, UINT, "900"),
|
|
|
|
V(BWHistoryWriteValues, CSV, ""),
|
2011-01-10 20:11:22 +01:00
|
|
|
V(BWHistoryWriteMaxima, CSV, ""),
|
2010-07-07 14:55:42 +02:00
|
|
|
V(BWHistoryDirReadEnds, ISOTIME, NULL),
|
|
|
|
V(BWHistoryDirReadInterval, UINT, "900"),
|
|
|
|
V(BWHistoryDirReadValues, CSV, ""),
|
2011-01-10 20:11:22 +01:00
|
|
|
V(BWHistoryDirReadMaxima, CSV, ""),
|
2010-07-07 14:55:42 +02:00
|
|
|
V(BWHistoryDirWriteEnds, ISOTIME, NULL),
|
|
|
|
V(BWHistoryDirWriteInterval, UINT, "900"),
|
|
|
|
V(BWHistoryDirWriteValues, CSV, ""),
|
2011-01-10 20:11:22 +01:00
|
|
|
V(BWHistoryDirWriteMaxima, CSV, ""),
|
2005-12-24 00:56:42 +01:00
|
|
|
|
2007-08-27 20:56:20 +02:00
|
|
|
V(TorVersion, STRING, NULL),
|
2005-12-31 09:16:07 +01:00
|
|
|
|
2007-08-27 20:56:20 +02:00
|
|
|
V(LastRotatedOnionKey, ISOTIME, NULL),
|
|
|
|
V(LastWritten, ISOTIME, NULL),
|
2005-12-28 10:07:31 +01:00
|
|
|
|
2009-09-07 05:43:02 +02:00
|
|
|
V(TotalBuildTimes, UINT, NULL),
|
2010-08-11 07:48:29 +02:00
|
|
|
V(CircuitBuildAbandonedCount, UINT, "0"),
|
2009-09-07 05:14:13 +02:00
|
|
|
VAR("CircuitBuildTimeBin", LINELIST_S, BuildtimeHistogram, NULL),
|
|
|
|
VAR("BuildtimeHistogram", LINELIST_V, BuildtimeHistogram, NULL),
|
2009-08-26 02:13:12 +02:00
|
|
|
|
2006-01-06 16:43:03 +01:00
|
|
|
{ NULL, CONFIG_TYPE_OBSOLETE, 0, NULL }
|
2005-07-28 21:01:48 +02:00
|
|
|
};
|
|
|
|
|
2004-10-27 04:30:28 +02:00
|
|
|
#undef VAR
|
2007-08-27 20:56:20 +02:00
|
|
|
#undef V
|
2004-10-27 04:30:28 +02:00
|
|
|
#undef OBSOLETE
|
|
|
|
|
2006-03-17 06:50:41 +01:00
|
|
|
/** Represents an English description of a configuration variable; used when
|
|
|
|
* generating configuration file comments. */
|
2005-07-28 21:01:48 +02:00
|
|
|
typedef struct config_var_description_t {
|
|
|
|
const char *name;
|
|
|
|
const char *description;
|
|
|
|
} config_var_description_t;
|
|
|
|
|
2007-02-16 19:12:47 +01:00
|
|
|
/** Type of a callback to validate whether a given configuration is
|
2007-02-24 08:50:38 +01:00
|
|
|
* well-formed and consistent. See options_trial_assign() for documentation
|
2007-02-16 19:12:47 +01:00
|
|
|
* of arguments. */
|
2006-03-26 08:51:26 +02:00
|
|
|
typedef int (*validate_fn_t)(void*,void*,int,char**);
|
2005-07-22 22:37:42 +02:00
|
|
|
|
2005-10-06 06:33:40 +02:00
|
|
|
/** Information on the keys, value types, key-to-struct-member mappings,
|
|
|
|
* variable descriptions, validation functions, and abbreviations for a
|
|
|
|
* configuration or storage format. */
|
2005-07-22 22:37:42 +02:00
|
|
|
typedef struct {
|
2007-02-16 19:12:47 +01:00
|
|
|
size_t size; /**< Size of the struct that everything gets parsed into. */
|
|
|
|
uint32_t magic; /**< Required 'magic value' to make sure we have a struct
|
|
|
|
* of the right type. */
|
2007-02-24 08:50:38 +01:00
|
|
|
off_t magic_offset; /**< Offset of the magic value within the struct. */
|
2007-02-16 19:12:47 +01:00
|
|
|
config_abbrev_t *abbrevs; /**< List of abbreviations that we expand when
|
2007-02-24 08:50:38 +01:00
|
|
|
* parsing this format. */
|
2007-02-16 19:12:47 +01:00
|
|
|
config_var_t *vars; /**< List of variables we recognize, their default
|
|
|
|
* values, and where we stick them in the structure. */
|
|
|
|
validate_fn_t validate_fn; /**< Function to validate config. */
|
2006-02-13 09:22:57 +01:00
|
|
|
/** If present, extra is a LINELIST variable for unrecognized
|
|
|
|
* lines. Otherwise, unrecognized lines are an error. */
|
|
|
|
config_var_t *extra;
|
2005-07-22 22:37:42 +02:00
|
|
|
} config_format_t;
|
|
|
|
|
2007-02-16 19:12:47 +01:00
|
|
|
/** Macro: assert that <b>cfg</b> has the right magic field for format
|
|
|
|
* <b>fmt</b>. */
|
2007-06-17 20:22:39 +02:00
|
|
|
#define CHECK(fmt, cfg) STMT_BEGIN \
|
2005-07-22 22:37:42 +02:00
|
|
|
tor_assert(fmt && cfg); \
|
2005-12-14 21:40:40 +01:00
|
|
|
tor_assert((fmt)->magic == \
|
2006-02-12 23:28:30 +01:00
|
|
|
*(uint32_t*)STRUCT_VAR_P(cfg,fmt->magic_offset)); \
|
2007-06-17 20:22:39 +02:00
|
|
|
STMT_END
|
2005-07-22 22:37:42 +02:00
|
|
|
|
2008-06-04 09:08:05 +02:00
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
static char *get_windows_conf_root(void);
|
|
|
|
#endif
|
2005-07-22 23:12:10 +02:00
|
|
|
static void config_line_append(config_line_t **lst,
|
2005-01-05 07:05:37 +01:00
|
|
|
const char *key, const char *val);
|
2005-09-08 08:59:58 +02:00
|
|
|
static void option_clear(config_format_t *fmt, or_options_t *options,
|
|
|
|
config_var_t *var);
|
2005-07-22 22:37:42 +02:00
|
|
|
static void option_reset(config_format_t *fmt, or_options_t *options,
|
2005-09-14 04:07:35 +02:00
|
|
|
config_var_t *var, int use_defaults);
|
2005-07-28 21:01:48 +02:00
|
|
|
static void config_free(config_format_t *fmt, void *options);
|
2007-12-12 05:38:54 +01:00
|
|
|
static int config_lines_eq(config_line_t *a, config_line_t *b);
|
2005-07-22 22:37:42 +02:00
|
|
|
static int option_is_same(config_format_t *fmt,
|
2005-12-14 21:40:40 +01:00
|
|
|
or_options_t *o1, or_options_t *o2,
|
|
|
|
const char *name);
|
2005-07-22 22:37:42 +02:00
|
|
|
static or_options_t *options_dup(config_format_t *fmt, or_options_t *old);
|
2006-03-26 08:51:26 +02:00
|
|
|
static int options_validate(or_options_t *old_options, or_options_t *options,
|
|
|
|
int from_setconf, char **msg);
|
|
|
|
static int options_act_reversible(or_options_t *old_options, char **msg);
|
2005-08-22 02:18:45 +02:00
|
|
|
static int options_act(or_options_t *old_options);
|
2006-03-26 08:51:26 +02:00
|
|
|
static int options_transition_allowed(or_options_t *old, or_options_t *new,
|
|
|
|
char **msg);
|
2005-08-22 02:18:45 +02:00
|
|
|
static int options_transition_affects_workers(or_options_t *old_options,
|
|
|
|
or_options_t *new_options);
|
|
|
|
static int options_transition_affects_descriptor(or_options_t *old_options,
|
|
|
|
or_options_t *new_options);
|
2006-03-26 08:51:26 +02:00
|
|
|
static int check_nickname_list(const char *lst, const char *name, char **msg);
|
2005-02-22 01:53:08 +01:00
|
|
|
static void config_register_addressmaps(or_options_t *options);
|
2004-11-06 06:18:11 +01:00
|
|
|
|
2007-05-08 13:28:05 +02:00
|
|
|
static int parse_bridge_line(const char *line, int validate_only);
|
2007-12-12 05:38:54 +01:00
|
|
|
static int parse_dir_server_line(const char *line,
|
2010-11-08 20:27:36 +01:00
|
|
|
dirinfo_type_t required_type,
|
2007-12-12 05:38:54 +01:00
|
|
|
int validate_only);
|
2004-11-09 06:35:49 +01:00
|
|
|
static int validate_data_directory(or_options_t *options);
|
2004-11-14 21:51:28 +01:00
|
|
|
static int write_configuration_file(const char *fname, or_options_t *options);
|
2005-07-22 23:12:10 +02:00
|
|
|
static config_line_t *get_assigned_option(config_format_t *fmt,
|
2008-12-29 21:17:24 +01:00
|
|
|
void *options, const char *key,
|
|
|
|
int escape_val);
|
2005-07-28 21:01:48 +02:00
|
|
|
static void config_init(config_format_t *fmt, void *options);
|
2006-01-10 21:38:33 +01:00
|
|
|
static int or_state_validate(or_state_t *old_options, or_state_t *options,
|
2006-03-26 08:51:26 +02:00
|
|
|
int from_setconf, char **msg);
|
2007-10-02 22:35:23 +02:00
|
|
|
static int or_state_load(void);
|
|
|
|
static int options_init_logs(or_options_t *options, int validate_only);
|
2003-09-08 07:16:18 +02:00
|
|
|
|
2011-05-02 21:51:30 +02:00
|
|
|
static int is_listening_on_low_port(int port_option,
|
2009-05-26 12:41:45 +02:00
|
|
|
const config_line_t *listen_options);
|
|
|
|
|
2004-11-20 01:37:00 +01:00
|
|
|
static uint64_t config_parse_memunit(const char *s, int *ok);
|
2010-08-27 08:13:54 +02:00
|
|
|
static int config_parse_msec_interval(const char *s, int *ok);
|
2004-11-20 01:37:00 +01:00
|
|
|
static int config_parse_interval(const char *s, int *ok);
|
2010-09-28 20:01:45 +02:00
|
|
|
static void init_libevent(const or_options_t *options);
|
2005-12-08 19:56:32 +01:00
|
|
|
static int opt_streq(const char *s1, const char *s2);
|
2004-11-20 01:37:00 +01:00
|
|
|
|
2007-02-16 19:12:47 +01:00
|
|
|
/** Magic value for or_options_t. */
|
2005-07-22 22:37:42 +02:00
|
|
|
#define OR_OPTIONS_MAGIC 9090909
|
|
|
|
|
2007-02-16 19:12:47 +01:00
|
|
|
/** Configuration format for or_options_t. */
|
2005-08-04 21:56:41 +02:00
|
|
|
static config_format_t options_format = {
|
2005-07-22 22:37:42 +02:00
|
|
|
sizeof(or_options_t),
|
|
|
|
OR_OPTIONS_MAGIC,
|
|
|
|
STRUCT_OFFSET(or_options_t, _magic),
|
2005-07-28 21:01:48 +02:00
|
|
|
_option_abbrevs,
|
|
|
|
_option_vars,
|
|
|
|
(validate_fn_t)options_validate,
|
2006-02-12 23:28:30 +01:00
|
|
|
NULL
|
2005-07-28 21:01:48 +02:00
|
|
|
};
|
|
|
|
|
2007-02-16 19:12:47 +01:00
|
|
|
/** Magic value for or_state_t. */
|
2005-07-28 21:01:48 +02:00
|
|
|
#define OR_STATE_MAGIC 0x57A73f57
|
|
|
|
|
2007-02-16 19:12:47 +01:00
|
|
|
/** "Extra" variable in the state that receives lines we can't parse. This
|
|
|
|
* lets us preserve options from versions of Tor newer than us. */
|
2006-02-12 23:28:30 +01:00
|
|
|
static config_var_t state_extra_var = {
|
|
|
|
"__extra", CONFIG_TYPE_LINELIST, STRUCT_OFFSET(or_state_t, ExtraLines), NULL
|
|
|
|
};
|
|
|
|
|
2007-02-16 19:12:47 +01:00
|
|
|
/** Configuration format for or_state_t. */
|
2005-07-28 21:01:48 +02:00
|
|
|
static config_format_t state_format = {
|
|
|
|
sizeof(or_state_t),
|
|
|
|
OR_STATE_MAGIC,
|
|
|
|
STRUCT_OFFSET(or_state_t, _magic),
|
2005-12-28 10:07:31 +01:00
|
|
|
_state_abbrevs,
|
2005-07-28 21:01:48 +02:00
|
|
|
_state_vars,
|
|
|
|
(validate_fn_t)or_state_validate,
|
2006-02-12 23:28:30 +01:00
|
|
|
&state_extra_var,
|
2005-07-22 22:37:42 +02:00
|
|
|
};
|
|
|
|
|
2004-11-06 06:18:11 +01:00
|
|
|
/*
|
|
|
|
* Functions to read and write the global options pointer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/** Command-line and config-file options. */
|
2005-07-28 21:01:48 +02:00
|
|
|
static or_options_t *global_options = NULL;
|
2004-11-15 04:53:03 +01:00
|
|
|
/** Name of most recently read torrc file. */
|
2005-08-10 20:05:20 +02:00
|
|
|
static char *torrc_fname = NULL;
|
2006-01-02 05:14:52 +01:00
|
|
|
/** Persistent serialized state. */
|
2005-07-28 21:01:48 +02:00
|
|
|
static or_state_t *global_state = NULL;
|
2008-03-10 13:41:40 +01:00
|
|
|
/** Configuration Options set by command line. */
|
|
|
|
static config_line_t *global_cmdline_options = NULL;
|
2008-12-07 02:34:45 +01:00
|
|
|
/** Contents of most recently read DirPortFrontPage file. */
|
2008-12-07 02:21:19 +01:00
|
|
|
static char *global_dirfrontpagecontents = NULL;
|
|
|
|
|
|
|
|
/** Return the contents of our frontpage string, or NULL if not configured. */
|
|
|
|
const char *
|
|
|
|
get_dirportfrontpage(void)
|
|
|
|
{
|
|
|
|
return global_dirfrontpagecontents;
|
|
|
|
}
|
2004-11-06 06:18:11 +01:00
|
|
|
|
2006-03-17 06:50:41 +01:00
|
|
|
/** Allocate an empty configuration object of a given format type. */
|
2005-07-22 22:37:42 +02:00
|
|
|
static void *
|
|
|
|
config_alloc(config_format_t *fmt)
|
|
|
|
{
|
2006-08-11 09:41:21 +02:00
|
|
|
void *opts = tor_malloc_zero(fmt->size);
|
2006-02-12 23:28:30 +01:00
|
|
|
*(uint32_t*)STRUCT_VAR_P(opts, fmt->magic_offset) = fmt->magic;
|
2005-07-22 22:37:42 +02:00
|
|
|
CHECK(fmt, opts);
|
|
|
|
return opts;
|
|
|
|
}
|
|
|
|
|
2004-11-09 00:12:40 +01:00
|
|
|
/** Return the currently configured options. */
|
|
|
|
or_options_t *
|
2005-06-11 20:52:12 +02:00
|
|
|
get_options(void)
|
|
|
|
{
|
2004-11-06 06:18:11 +01:00
|
|
|
tor_assert(global_options);
|
|
|
|
return global_options;
|
|
|
|
}
|
2004-11-09 00:12:40 +01:00
|
|
|
|
2005-08-22 02:18:45 +02:00
|
|
|
/** Change the current global options to contain <b>new_val</b> instead of
|
|
|
|
* their current value; take action based on the new value; free the old value
|
2008-03-13 16:11:56 +01:00
|
|
|
* as necessary. Returns 0 on success, -1 on failure.
|
2004-11-09 00:12:40 +01:00
|
|
|
*/
|
2005-09-14 04:36:29 +02:00
|
|
|
int
|
2006-03-26 08:51:26 +02:00
|
|
|
set_options(or_options_t *new_val, char **msg)
|
2005-06-11 20:52:12 +02:00
|
|
|
{
|
2005-08-22 02:18:45 +02:00
|
|
|
or_options_t *old_options = global_options;
|
2004-11-09 00:12:40 +01:00
|
|
|
global_options = new_val;
|
2005-08-26 22:26:20 +02:00
|
|
|
/* Note that we pass the *old* options below, for comparison. It
|
|
|
|
* pulls the new options directly out of global_options. */
|
2006-03-26 08:51:26 +02:00
|
|
|
if (options_act_reversible(old_options, msg)<0) {
|
|
|
|
tor_assert(*msg);
|
2005-09-14 04:36:29 +02:00
|
|
|
global_options = old_options;
|
|
|
|
return -1;
|
|
|
|
}
|
2005-08-22 02:18:45 +02:00
|
|
|
if (options_act(old_options) < 0) { /* acting on the options failed. die. */
|
2006-03-26 08:51:26 +02:00
|
|
|
log_err(LD_BUG,
|
2006-02-13 10:02:35 +01:00
|
|
|
"Acting on config options left us in a broken state. Dying.");
|
2005-08-22 02:18:45 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2009-12-12 08:07:59 +01:00
|
|
|
|
|
|
|
config_free(&options_format, old_options);
|
2005-09-14 04:36:29 +02:00
|
|
|
|
|
|
|
return 0;
|
2004-11-09 05:28:18 +01:00
|
|
|
}
|
|
|
|
|
2009-06-12 19:38:37 +02:00
|
|
|
extern const char tor_git_revision[]; /* from tor_main.c */
|
2007-05-22 17:48:46 +02:00
|
|
|
|
2008-12-23 18:56:31 +01:00
|
|
|
/** The version of this Tor process, as parsed. */
|
2007-07-17 11:26:45 +02:00
|
|
|
static char *_version = NULL;
|
|
|
|
|
2008-12-23 18:56:31 +01:00
|
|
|
/** Return the current Tor version. */
|
2007-05-22 17:48:46 +02:00
|
|
|
const char *
|
|
|
|
get_version(void)
|
|
|
|
{
|
2007-07-17 11:26:45 +02:00
|
|
|
if (_version == NULL) {
|
2009-06-12 19:38:37 +02:00
|
|
|
if (strlen(tor_git_revision)) {
|
|
|
|
size_t len = strlen(VERSION)+strlen(tor_git_revision)+16;
|
2007-07-17 11:26:45 +02:00
|
|
|
_version = tor_malloc(len);
|
2009-06-12 19:38:37 +02:00
|
|
|
tor_snprintf(_version, len, "%s (git-%s)", VERSION, tor_git_revision);
|
2007-05-22 17:48:46 +02:00
|
|
|
} else {
|
2007-07-17 11:26:45 +02:00
|
|
|
_version = tor_strdup(VERSION);
|
2007-05-22 17:48:46 +02:00
|
|
|
}
|
|
|
|
}
|
2007-07-17 11:26:45 +02:00
|
|
|
return _version;
|
2007-05-22 17:48:46 +02:00
|
|
|
}
|
|
|
|
|
2008-09-25 22:21:35 +02:00
|
|
|
/** Release additional memory allocated in options
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
or_options_free(or_options_t *options)
|
|
|
|
{
|
2009-09-28 16:37:01 +02:00
|
|
|
if (!options)
|
|
|
|
return;
|
|
|
|
|
2009-12-12 08:07:59 +01:00
|
|
|
routerset_free(options->_ExcludeExitNodesUnion);
|
2010-10-01 00:25:25 +02:00
|
|
|
if (options->NodeFamilySets) {
|
|
|
|
SMARTLIST_FOREACH(options->NodeFamilySets, routerset_t *,
|
|
|
|
rs, routerset_free(rs));
|
|
|
|
smartlist_free(options->NodeFamilySets);
|
|
|
|
}
|
2008-09-25 22:21:35 +02:00
|
|
|
config_free(&options_format, options);
|
|
|
|
}
|
|
|
|
|
2006-03-17 06:50:41 +01:00
|
|
|
/** Release all memory and resources held by global configuration structures.
|
|
|
|
*/
|
2005-02-11 02:26:47 +01:00
|
|
|
void
|
|
|
|
config_free_all(void)
|
|
|
|
{
|
2009-12-12 08:07:59 +01:00
|
|
|
or_options_free(global_options);
|
|
|
|
global_options = NULL;
|
|
|
|
|
|
|
|
config_free(&state_format, global_state);
|
|
|
|
global_state = NULL;
|
|
|
|
|
|
|
|
config_free_lines(global_cmdline_options);
|
|
|
|
global_cmdline_options = NULL;
|
|
|
|
|
2005-08-10 20:05:20 +02:00
|
|
|
tor_free(torrc_fname);
|
2007-07-17 11:26:45 +02:00
|
|
|
tor_free(_version);
|
2008-12-07 02:21:19 +01:00
|
|
|
tor_free(global_dirfrontpagecontents);
|
2005-02-11 02:26:47 +01:00
|
|
|
}
|
|
|
|
|
2009-12-15 23:23:36 +01:00
|
|
|
/** Make <b>address</b> -- a piece of information related to our operation as
|
|
|
|
* a client -- safe to log according to the settings in options->SafeLogging,
|
|
|
|
* and return it.
|
|
|
|
*
|
|
|
|
* (We return "[scrubbed]" if SafeLogging is "1", and address otherwise.)
|
2005-05-03 12:04:08 +02:00
|
|
|
*/
|
|
|
|
const char *
|
2009-12-15 23:23:36 +01:00
|
|
|
safe_str_client(const char *address)
|
2005-06-11 20:52:12 +02:00
|
|
|
{
|
2007-08-14 22:19:46 +02:00
|
|
|
tor_assert(address);
|
2009-12-12 07:12:47 +01:00
|
|
|
if (get_options()->_SafeLogging == SAFELOG_SCRUB_ALL)
|
2009-09-28 15:08:32 +02:00
|
|
|
return "[scrubbed]";
|
|
|
|
else
|
|
|
|
return address;
|
|
|
|
}
|
|
|
|
|
2009-12-15 23:23:36 +01:00
|
|
|
/** Make <b>address</b> -- a piece of information of unspecified sensitivity
|
|
|
|
* -- safe to log according to the settings in options->SafeLogging, and
|
|
|
|
* return it.
|
|
|
|
*
|
|
|
|
* (We return "[scrubbed]" if SafeLogging is anything besides "0", and address
|
|
|
|
* otherwise.)
|
2005-05-03 12:04:08 +02:00
|
|
|
*/
|
|
|
|
const char *
|
2005-06-11 20:52:12 +02:00
|
|
|
safe_str(const char *address)
|
|
|
|
{
|
2007-08-14 22:19:46 +02:00
|
|
|
tor_assert(address);
|
2009-12-12 07:12:47 +01:00
|
|
|
if (get_options()->_SafeLogging != SAFELOG_SCRUB_NONE)
|
2005-05-03 12:04:08 +02:00
|
|
|
return "[scrubbed]";
|
|
|
|
else
|
|
|
|
return address;
|
|
|
|
}
|
|
|
|
|
2009-12-15 23:23:36 +01:00
|
|
|
/** Equivalent to escaped(safe_str_client(address)). See reentrancy note on
|
2006-09-21 23:48:11 +02:00
|
|
|
* escaped(): don't use this outside the main thread, or twice in the same
|
|
|
|
* log statement. */
|
2006-03-05 10:50:26 +01:00
|
|
|
const char *
|
2009-12-15 23:23:36 +01:00
|
|
|
escaped_safe_str_client(const char *address)
|
2006-03-05 10:50:26 +01:00
|
|
|
{
|
2009-12-12 07:12:47 +01:00
|
|
|
if (get_options()->_SafeLogging == SAFELOG_SCRUB_ALL)
|
2009-09-28 15:08:32 +02:00
|
|
|
return "[scrubbed]";
|
|
|
|
else
|
|
|
|
return escaped(address);
|
|
|
|
}
|
|
|
|
|
2006-09-25 07:24:43 +02:00
|
|
|
/** Equivalent to escaped(safe_str(address)). See reentrancy note on
|
2006-09-21 23:48:11 +02:00
|
|
|
* escaped(): don't use this outside the main thread, or twice in the same
|
|
|
|
* log statement. */
|
2006-03-05 10:50:26 +01:00
|
|
|
const char *
|
|
|
|
escaped_safe_str(const char *address)
|
|
|
|
{
|
2009-12-12 07:12:47 +01:00
|
|
|
if (get_options()->_SafeLogging != SAFELOG_SCRUB_NONE)
|
2006-03-05 10:50:26 +01:00
|
|
|
return "[scrubbed]";
|
|
|
|
else
|
|
|
|
return escaped(address);
|
|
|
|
}
|
|
|
|
|
2007-12-12 05:38:54 +01:00
|
|
|
/** Add the default directory authorities directly into the trusted dir list,
|
|
|
|
* but only add them insofar as they share bits with <b>type</b>. */
|
2005-11-18 03:47:09 +01:00
|
|
|
static void
|
2010-11-08 20:27:36 +01:00
|
|
|
add_default_trusted_dir_authorities(dirinfo_type_t type)
|
2005-11-18 03:47:09 +01:00
|
|
|
{
|
2006-03-18 23:37:27 +01:00
|
|
|
int i;
|
2005-11-18 03:47:09 +01:00
|
|
|
const char *dirservers[] = {
|
2010-01-19 20:12:39 +01:00
|
|
|
"moria1 orport=9101 no-v2 "
|
|
|
|
"v3ident=D586D18309DED4CD6D57C18FDB97EFA96D330566 "
|
|
|
|
"128.31.0.39:9131 9695 DFC3 5FFE B861 329B 9F1A B04C 4639 7020 CE31",
|
2008-05-13 14:47:27 +02:00
|
|
|
"tor26 v1 orport=443 v3ident=14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4 "
|
2007-09-20 23:36:56 +02:00
|
|
|
"86.59.21.38:80 847B 1F85 0344 D787 6491 A548 92F9 0493 4E4E B85D",
|
2008-04-23 02:31:20 +02:00
|
|
|
"dizum orport=443 v3ident=E8A9C45EDE6D711294FADF8E7951F4DE6CA56B58 "
|
|
|
|
"194.109.206.212:80 7EA6 EAD6 FD83 083C 538F 4403 8BBF A077 587D D755",
|
2009-10-01 04:35:05 +02:00
|
|
|
"Tonga orport=443 bridge no-v2 82.94.251.203:80 "
|
2007-08-26 00:02:55 +02:00
|
|
|
"4A0C CD2D DC79 9508 3D73 F5D6 6710 0C8A 5831 F16D",
|
2007-11-07 22:20:45 +01:00
|
|
|
"ides orport=9090 no-v2 v3ident=27B6B5996C426270A5C95488AA5BCEB6BCC86956 "
|
|
|
|
"216.224.124.114:9030 F397 038A DC51 3361 35E7 B80B D99C A384 4360 292B",
|
2010-12-16 13:10:19 +01:00
|
|
|
"gabelmoo orport=443 no-v2 "
|
2010-01-19 20:12:39 +01:00
|
|
|
"v3ident=ED03BB616EB2F60BEC80151114BB25CEF515B226 "
|
2010-12-16 13:10:19 +01:00
|
|
|
"212.112.245.170:80 F204 4413 DAC2 E02E 3D6B CF47 35A1 9BCA 1DE9 7281",
|
2008-01-22 23:38:38 +01:00
|
|
|
"dannenberg orport=443 no-v2 "
|
|
|
|
"v3ident=585769C78764D58426B8B52B6651A5A71137189A "
|
2010-02-12 20:31:08 +01:00
|
|
|
"193.23.244.244:80 7BE6 83E6 5D48 1413 21C5 ED92 F075 C553 64AC 7123",
|
2009-08-10 07:32:51 +02:00
|
|
|
"urras orport=80 no-v2 v3ident=80550987E1D626E3EBA5E5E75A458DE0626D088C "
|
|
|
|
"208.83.223.34:443 0AD3 FA88 4D18 F89E EA2D 89C0 1937 9E0E 7FD9 4417",
|
2010-06-10 16:56:08 +02:00
|
|
|
"maatuska orport=80 no-v2 "
|
|
|
|
"v3ident=49015F787433103580E3B66A1707A00E60F2D15B "
|
|
|
|
"213.115.239.118:443 BD6A 8292 55CB 08E6 6FBE 7D37 4836 3586 E46B 3810",
|
2006-03-18 23:37:27 +01:00
|
|
|
NULL
|
2005-12-14 21:40:40 +01:00
|
|
|
};
|
2008-01-14 20:00:23 +01:00
|
|
|
for (i=0; dirservers[i]; i++) {
|
|
|
|
if (parse_dir_server_line(dirservers[i], type, 0)<0) {
|
|
|
|
log_err(LD_BUG, "Couldn't parse internal dirserver line %s",
|
|
|
|
dirservers[i]);
|
|
|
|
}
|
|
|
|
}
|
2007-12-12 05:38:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/** Look at all the config options for using alternate directory
|
|
|
|
* authorities, and make sure none of them are broken. Also, warn the
|
|
|
|
* user if we changed any dangerous ones.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
validate_dir_authorities(or_options_t *options, or_options_t *old_options)
|
|
|
|
{
|
|
|
|
config_line_t *cl;
|
|
|
|
|
|
|
|
if (options->DirServers &&
|
|
|
|
(options->AlternateDirAuthority || options->AlternateBridgeAuthority ||
|
|
|
|
options->AlternateHSAuthority)) {
|
|
|
|
log_warn(LD_CONFIG,
|
|
|
|
"You cannot set both DirServers and Alternate*Authority.");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* do we want to complain to the user about being partitionable? */
|
|
|
|
if ((options->DirServers &&
|
|
|
|
(!old_options ||
|
|
|
|
!config_lines_eq(options->DirServers, old_options->DirServers))) ||
|
|
|
|
(options->AlternateDirAuthority &&
|
|
|
|
(!old_options ||
|
|
|
|
!config_lines_eq(options->AlternateDirAuthority,
|
|
|
|
old_options->AlternateDirAuthority)))) {
|
|
|
|
log_warn(LD_CONFIG,
|
|
|
|
"You have used DirServer or AlternateDirAuthority to "
|
|
|
|
"specify alternate directory authorities in "
|
|
|
|
"your configuration. This is potentially dangerous: it can "
|
|
|
|
"make you look different from all other Tor users, and hurt "
|
|
|
|
"your anonymity. Even if you've specified the same "
|
|
|
|
"authorities as Tor uses by default, the defaults could "
|
|
|
|
"change in the future. Be sure you know what you're doing.");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now go through the four ways you can configure an alternate
|
|
|
|
* set of directory authorities, and make sure none are broken. */
|
|
|
|
for (cl = options->DirServers; cl; cl = cl->next)
|
2010-11-08 20:35:02 +01:00
|
|
|
if (parse_dir_server_line(cl->value, NO_DIRINFO, 1)<0)
|
2007-12-12 05:38:54 +01:00
|
|
|
return -1;
|
|
|
|
for (cl = options->AlternateBridgeAuthority; cl; cl = cl->next)
|
2010-11-08 20:35:02 +01:00
|
|
|
if (parse_dir_server_line(cl->value, NO_DIRINFO, 1)<0)
|
2007-12-12 05:38:54 +01:00
|
|
|
return -1;
|
|
|
|
for (cl = options->AlternateDirAuthority; cl; cl = cl->next)
|
2010-11-08 20:35:02 +01:00
|
|
|
if (parse_dir_server_line(cl->value, NO_DIRINFO, 1)<0)
|
2007-12-12 05:38:54 +01:00
|
|
|
return -1;
|
|
|
|
for (cl = options->AlternateHSAuthority; cl; cl = cl->next)
|
2010-11-08 20:35:02 +01:00
|
|
|
if (parse_dir_server_line(cl->value, NO_DIRINFO, 1)<0)
|
2007-12-12 05:38:54 +01:00
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Look at all the config options and assign new dir authorities
|
|
|
|
* as appropriate.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
consider_adding_dir_authorities(or_options_t *options,
|
|
|
|
or_options_t *old_options)
|
|
|
|
{
|
|
|
|
config_line_t *cl;
|
|
|
|
int need_to_update =
|
2007-12-12 05:46:16 +01:00
|
|
|
!smartlist_len(router_get_trusted_dir_servers()) || !old_options ||
|
2007-12-12 05:38:54 +01:00
|
|
|
!config_lines_eq(options->DirServers, old_options->DirServers) ||
|
|
|
|
!config_lines_eq(options->AlternateBridgeAuthority,
|
|
|
|
old_options->AlternateBridgeAuthority) ||
|
|
|
|
!config_lines_eq(options->AlternateDirAuthority,
|
|
|
|
old_options->AlternateDirAuthority) ||
|
|
|
|
!config_lines_eq(options->AlternateHSAuthority,
|
|
|
|
old_options->AlternateHSAuthority);
|
|
|
|
|
|
|
|
if (!need_to_update)
|
|
|
|
return 0; /* all done */
|
|
|
|
|
|
|
|
/* Start from a clean slate. */
|
|
|
|
clear_trusted_dir_servers();
|
|
|
|
|
|
|
|
if (!options->DirServers) {
|
|
|
|
/* then we may want some of the defaults */
|
2010-11-08 20:35:02 +01:00
|
|
|
dirinfo_type_t type = NO_DIRINFO;
|
2007-12-12 05:38:54 +01:00
|
|
|
if (!options->AlternateBridgeAuthority)
|
2010-11-08 20:35:02 +01:00
|
|
|
type |= BRIDGE_DIRINFO;
|
2007-12-12 05:38:54 +01:00
|
|
|
if (!options->AlternateDirAuthority)
|
2010-11-08 20:21:32 +01:00
|
|
|
type |= V1_DIRINFO | V2_DIRINFO | V3_DIRINFO | EXTRAINFO_DIRINFO |
|
|
|
|
MICRODESC_DIRINFO;
|
2007-12-12 05:38:54 +01:00
|
|
|
if (!options->AlternateHSAuthority)
|
2010-11-08 20:35:02 +01:00
|
|
|
type |= HIDSERV_DIRINFO;
|
2007-12-12 05:38:54 +01:00
|
|
|
add_default_trusted_dir_authorities(type);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (cl = options->DirServers; cl; cl = cl->next)
|
2010-11-08 20:35:02 +01:00
|
|
|
if (parse_dir_server_line(cl->value, NO_DIRINFO, 0)<0)
|
2007-12-12 05:38:54 +01:00
|
|
|
return -1;
|
|
|
|
for (cl = options->AlternateBridgeAuthority; cl; cl = cl->next)
|
2010-11-08 20:35:02 +01:00
|
|
|
if (parse_dir_server_line(cl->value, NO_DIRINFO, 0)<0)
|
2007-12-12 05:38:54 +01:00
|
|
|
return -1;
|
|
|
|
for (cl = options->AlternateDirAuthority; cl; cl = cl->next)
|
2010-11-08 20:35:02 +01:00
|
|
|
if (parse_dir_server_line(cl->value, NO_DIRINFO, 0)<0)
|
2007-12-12 05:38:54 +01:00
|
|
|
return -1;
|
|
|
|
for (cl = options->AlternateHSAuthority; cl; cl = cl->next)
|
2010-11-08 20:35:02 +01:00
|
|
|
if (parse_dir_server_line(cl->value, NO_DIRINFO, 0)<0)
|
2007-12-12 05:38:54 +01:00
|
|
|
return -1;
|
|
|
|
return 0;
|
2005-11-18 03:47:09 +01:00
|
|
|
}
|
|
|
|
|
2005-09-14 04:36:29 +02:00
|
|
|
/** Fetch the active option list, and take actions based on it. All of the
|
|
|
|
* things we do should survive being done repeatedly. If present,
|
|
|
|
* <b>old_options</b> contains the previous value of the options.
|
|
|
|
*
|
|
|
|
* Return 0 if all goes well, return -1 if things went badly.
|
|
|
|
*/
|
|
|
|
static int
|
2006-03-26 08:51:26 +02:00
|
|
|
options_act_reversible(or_options_t *old_options, char **msg)
|
2005-09-14 04:36:29 +02:00
|
|
|
{
|
|
|
|
smartlist_t *new_listeners = smartlist_create();
|
|
|
|
smartlist_t *replaced_listeners = smartlist_create();
|
|
|
|
static int libevent_initialized = 0;
|
|
|
|
or_options_t *options = get_options();
|
|
|
|
int running_tor = options->command == CMD_RUN_TOR;
|
|
|
|
int set_conn_limit = 0;
|
|
|
|
int r = -1;
|
2006-01-11 20:40:14 +01:00
|
|
|
int logs_marked = 0;
|
2005-09-14 04:36:29 +02:00
|
|
|
|
2007-06-04 01:00:26 +02:00
|
|
|
/* Daemonize _first_, since we only want to open most of this stuff in
|
2007-08-27 17:33:58 +02:00
|
|
|
* the subprocess. Libevent bases can't be reliably inherited across
|
|
|
|
* processes. */
|
2005-09-14 04:36:29 +02:00
|
|
|
if (running_tor && options->RunAsDaemon) {
|
|
|
|
/* No need to roll back, since you can't change the value. */
|
|
|
|
start_daemon();
|
|
|
|
}
|
|
|
|
|
2007-06-05 22:54:49 +02:00
|
|
|
#ifndef HAVE_SYS_UN_H
|
2011-04-23 02:57:53 +02:00
|
|
|
if (options->ControlSocket || options->ControlSocketsGroupWritable) {
|
|
|
|
*msg = tor_strdup("Unix domain sockets (ControlSocket) not supported "
|
|
|
|
"on this OS/with this build.");
|
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (options->ControlSocketsGroupWritable && !options->ControlSocket) {
|
|
|
|
*msg = tor_strdup("Setting ControlSocketGroupWritable without setting"
|
|
|
|
"a ControlSocket makes no sense.");
|
2007-06-05 22:54:49 +02:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-06-04 01:08:07 +02:00
|
|
|
if (running_tor) {
|
|
|
|
/* We need to set the connection limit before we can open the listeners. */
|
2008-02-20 23:28:26 +01:00
|
|
|
if (set_max_file_descriptors((unsigned)options->ConnLimit,
|
|
|
|
&options->_ConnLimit) < 0) {
|
2007-06-04 01:08:07 +02:00
|
|
|
*msg = tor_strdup("Problem with ConnLimit value. See logs for details.");
|
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
set_conn_limit = 1;
|
2007-06-04 01:00:26 +02:00
|
|
|
|
2007-06-04 01:08:07 +02:00
|
|
|
/* Set up libevent. (We need to do this before we can register the
|
|
|
|
* listeners as listeners.) */
|
|
|
|
if (running_tor && !libevent_initialized) {
|
2010-09-28 20:01:45 +02:00
|
|
|
init_libevent(options);
|
2007-06-04 01:08:07 +02:00
|
|
|
libevent_initialized = 1;
|
|
|
|
}
|
2007-06-04 01:00:26 +02:00
|
|
|
|
2007-06-04 01:08:07 +02:00
|
|
|
/* Launch the listeners. (We do this before we setuid, so we can bind to
|
2010-08-01 04:35:20 +02:00
|
|
|
* ports under 1024.) We don't want to rebind if we're hibernating. */
|
|
|
|
if (!we_are_hibernating()) {
|
|
|
|
if (retry_all_listeners(replaced_listeners, new_listeners) < 0) {
|
|
|
|
*msg = tor_strdup("Failed to bind one of the listener ports.");
|
|
|
|
goto rollback;
|
|
|
|
}
|
2007-06-04 01:08:07 +02:00
|
|
|
}
|
2007-06-04 01:00:26 +02:00
|
|
|
}
|
|
|
|
|
2008-08-06 18:32:17 +02:00
|
|
|
#if defined(HAVE_NET_IF_H) && defined(HAVE_NET_PFVAR_H)
|
|
|
|
/* Open /dev/pf before dropping privileges. */
|
|
|
|
if (options->TransPort) {
|
|
|
|
if (get_pf_socket() < 0) {
|
|
|
|
*msg = tor_strdup("Unable to open /dev/pf for transparent proxy.");
|
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-10-22 06:21:57 +02:00
|
|
|
/* Attempt to lock all current and future memory with mlockall() only once */
|
|
|
|
if (options->DisableAllSwap) {
|
|
|
|
if (tor_mlockall() == -1) {
|
|
|
|
*msg = tor_strdup("DisableAllSwap failure. Do you have proper "
|
|
|
|
"permissions?");
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-14 04:36:29 +02:00
|
|
|
/* Setuid/setgid as appropriate */
|
2008-11-07 03:06:12 +01:00
|
|
|
if (options->User) {
|
|
|
|
if (switch_id(options->User) != 0) {
|
2005-09-14 04:36:29 +02:00
|
|
|
/* No need to roll back, since you can't change the value. */
|
2008-11-07 03:06:12 +01:00
|
|
|
*msg = tor_strdup("Problem with User value. See logs for details.");
|
2005-09-14 04:36:29 +02:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ensure data directory is private; create if possible. */
|
2007-12-20 07:15:09 +01:00
|
|
|
if (check_private_dir(options->DataDirectory,
|
|
|
|
running_tor ? CPD_CREATE : CPD_CHECK)<0) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2006-03-26 08:51:26 +02:00
|
|
|
"Couldn't access/create private data directory \"%s\"",
|
|
|
|
options->DataDirectory);
|
2005-09-14 04:36:29 +02:00
|
|
|
goto done;
|
2006-03-26 08:51:26 +02:00
|
|
|
/* No need to roll back, since you can't change the value. */
|
2005-09-14 04:36:29 +02:00
|
|
|
}
|
|
|
|
|
2008-09-29 12:09:05 +02:00
|
|
|
if (directory_caches_v2_dir_info(options)) {
|
|
|
|
size_t len = strlen(options->DataDirectory)+32;
|
|
|
|
char *fn = tor_malloc(len);
|
|
|
|
tor_snprintf(fn, len, "%s"PATH_SEPARATOR"cached-status",
|
|
|
|
options->DataDirectory);
|
|
|
|
if (check_private_dir(fn, running_tor ? CPD_CREATE : CPD_CHECK) < 0) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2008-09-29 12:09:05 +02:00
|
|
|
"Couldn't access/create private data directory \"%s\"", fn);
|
|
|
|
tor_free(fn);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
tor_free(fn);
|
|
|
|
}
|
|
|
|
|
2005-09-14 04:36:29 +02:00
|
|
|
/* Bail out at this point if we're not going to be a client or server:
|
2006-03-26 08:51:26 +02:00
|
|
|
* we don't run Tor itself. */
|
2007-06-04 01:08:07 +02:00
|
|
|
if (!running_tor)
|
2005-09-14 04:36:29 +02:00
|
|
|
goto commit;
|
|
|
|
|
2006-01-11 20:40:14 +01:00
|
|
|
mark_logs_temp(); /* Close current logs once new logs are open. */
|
|
|
|
logs_marked = 1;
|
2006-03-26 08:51:26 +02:00
|
|
|
if (options_init_logs(options, 0)<0) { /* Configure the log(s) */
|
|
|
|
*msg = tor_strdup("Failed to init Log options. See logs for details.");
|
2006-01-11 20:40:14 +01:00
|
|
|
goto rollback;
|
2006-03-26 08:51:26 +02:00
|
|
|
}
|
2006-01-11 20:40:14 +01:00
|
|
|
|
2005-09-14 04:36:29 +02:00
|
|
|
commit:
|
|
|
|
r = 0;
|
2006-01-11 20:40:14 +01:00
|
|
|
if (logs_marked) {
|
2008-03-05 23:31:39 +01:00
|
|
|
log_severity_list_t *severity =
|
|
|
|
tor_malloc_zero(sizeof(log_severity_list_t));
|
2006-01-11 20:40:14 +01:00
|
|
|
close_temp_logs();
|
2008-03-05 23:31:39 +01:00
|
|
|
add_callback_log(severity, control_event_logmsg);
|
2006-01-11 20:40:14 +01:00
|
|
|
control_adjust_event_log_severity();
|
2008-03-08 02:11:54 +01:00
|
|
|
tor_free(severity);
|
2006-01-11 20:40:14 +01:00
|
|
|
}
|
2005-09-14 04:36:29 +02:00
|
|
|
SMARTLIST_FOREACH(replaced_listeners, connection_t *, conn,
|
|
|
|
{
|
2006-02-13 10:02:35 +01:00
|
|
|
log_notice(LD_NET, "Closing old %s on %s:%d",
|
|
|
|
conn_type_to_string(conn->type), conn->address, conn->port);
|
2005-09-14 04:36:29 +02:00
|
|
|
connection_close_immediate(conn);
|
|
|
|
connection_mark_for_close(conn);
|
|
|
|
});
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
rollback:
|
|
|
|
r = -1;
|
2006-03-26 08:51:26 +02:00
|
|
|
tor_assert(*msg);
|
2005-09-14 04:36:29 +02:00
|
|
|
|
2006-01-11 20:40:14 +01:00
|
|
|
if (logs_marked) {
|
|
|
|
rollback_log_changes();
|
|
|
|
control_adjust_event_log_severity();
|
|
|
|
}
|
|
|
|
|
2005-09-14 04:36:29 +02:00
|
|
|
if (set_conn_limit && old_options)
|
2008-02-20 23:28:26 +01:00
|
|
|
set_max_file_descriptors((unsigned)old_options->ConnLimit,
|
|
|
|
&options->_ConnLimit);
|
2005-09-14 04:36:29 +02:00
|
|
|
|
|
|
|
SMARTLIST_FOREACH(new_listeners, connection_t *, conn,
|
|
|
|
{
|
2006-09-30 00:33:40 +02:00
|
|
|
log_notice(LD_NET, "Closing partially-constructed listener %s on %s:%d",
|
2006-02-13 10:02:35 +01:00
|
|
|
conn_type_to_string(conn->type), conn->address, conn->port);
|
2005-09-14 04:36:29 +02:00
|
|
|
connection_close_immediate(conn);
|
|
|
|
connection_mark_for_close(conn);
|
|
|
|
});
|
|
|
|
|
|
|
|
done:
|
|
|
|
smartlist_free(new_listeners);
|
|
|
|
smartlist_free(replaced_listeners);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2008-12-17 23:58:20 +01:00
|
|
|
/** If we need to have a GEOIP ip-to-country map to run with our configured
|
|
|
|
* options, return 1 and set *<b>reason_out</b> to a description of why. */
|
2008-09-25 23:06:32 +02:00
|
|
|
int
|
|
|
|
options_need_geoip_info(or_options_t *options, const char **reason_out)
|
|
|
|
{
|
|
|
|
int bridge_usage =
|
|
|
|
options->BridgeRelay && options->BridgeRecordUsageByCountry;
|
|
|
|
int routerset_usage =
|
|
|
|
routerset_needs_geoip(options->EntryNodes) ||
|
|
|
|
routerset_needs_geoip(options->ExitNodes) ||
|
|
|
|
routerset_needs_geoip(options->ExcludeExitNodes) ||
|
|
|
|
routerset_needs_geoip(options->ExcludeNodes);
|
|
|
|
|
|
|
|
if (routerset_usage && reason_out) {
|
|
|
|
*reason_out = "We've been configured to use (or avoid) nodes in certain "
|
2009-05-22 07:19:55 +02:00
|
|
|
"countries, and we need GEOIP information to figure out which ones they "
|
2008-09-25 23:06:32 +02:00
|
|
|
"are.";
|
|
|
|
} else if (bridge_usage && reason_out) {
|
|
|
|
*reason_out = "We've been configured to see which countries can access "
|
|
|
|
"us as a bridge, and we need GEOIP information to tell which countries "
|
|
|
|
"clients are in.";
|
|
|
|
}
|
|
|
|
return bridge_usage || routerset_usage;
|
|
|
|
}
|
|
|
|
|
2009-07-07 18:04:00 +02:00
|
|
|
/** Return the bandwidthrate that we are going to report to the authorities
|
|
|
|
* based on the config options. */
|
2009-07-29 00:34:35 +02:00
|
|
|
uint32_t
|
2009-07-07 18:04:00 +02:00
|
|
|
get_effective_bwrate(or_options_t *options)
|
|
|
|
{
|
2009-07-30 15:15:07 +02:00
|
|
|
uint64_t bw = options->BandwidthRate;
|
2009-07-07 18:04:00 +02:00
|
|
|
if (bw > options->MaxAdvertisedBandwidth)
|
2009-07-30 15:15:07 +02:00
|
|
|
bw = options->MaxAdvertisedBandwidth;
|
2009-07-07 18:04:00 +02:00
|
|
|
if (options->RelayBandwidthRate > 0 && bw > options->RelayBandwidthRate)
|
2009-07-30 15:15:07 +02:00
|
|
|
bw = options->RelayBandwidthRate;
|
2009-07-30 16:14:12 +02:00
|
|
|
/* ensure_bandwidth_cap() makes sure that this cast can't overflow. */
|
|
|
|
return (uint32_t)bw;
|
2009-07-07 18:04:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/** Return the bandwidthburst that we are going to report to the authorities
|
|
|
|
* based on the config options. */
|
2009-07-29 00:34:35 +02:00
|
|
|
uint32_t
|
2009-07-07 18:04:00 +02:00
|
|
|
get_effective_bwburst(or_options_t *options)
|
|
|
|
{
|
2009-07-30 15:15:07 +02:00
|
|
|
uint64_t bw = options->BandwidthBurst;
|
2009-07-07 18:04:00 +02:00
|
|
|
if (options->RelayBandwidthBurst > 0 && bw > options->RelayBandwidthBurst)
|
2009-07-30 15:15:07 +02:00
|
|
|
bw = options->RelayBandwidthBurst;
|
2009-07-30 16:14:12 +02:00
|
|
|
/* ensure_bandwidth_cap() makes sure that this cast can't overflow. */
|
|
|
|
return (uint32_t)bw;
|
2009-07-07 18:04:00 +02:00
|
|
|
}
|
|
|
|
|
2005-08-22 02:18:45 +02:00
|
|
|
/** Fetch the active option list, and take actions based on it. All of the
|
|
|
|
* things we do should survive being done repeatedly. If present,
|
|
|
|
* <b>old_options</b> contains the previous value of the options.
|
2004-12-31 22:47:54 +01:00
|
|
|
*
|
2005-08-22 02:18:45 +02:00
|
|
|
* Return 0 if all goes well, return -1 if it's time to die.
|
2004-12-31 22:47:54 +01:00
|
|
|
*
|
2006-03-26 08:51:26 +02:00
|
|
|
* Note: We haven't moved all the "act on new configuration" logic
|
2004-12-31 22:47:54 +01:00
|
|
|
* here yet. Some is still in do_hup() and other places.
|
2004-11-09 05:28:18 +01:00
|
|
|
*/
|
2005-08-22 02:18:45 +02:00
|
|
|
static int
|
|
|
|
options_act(or_options_t *old_options)
|
2005-06-11 20:52:12 +02:00
|
|
|
{
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *cl;
|
2004-11-09 05:28:18 +01:00
|
|
|
or_options_t *options = get_options();
|
2005-08-27 01:22:27 +02:00
|
|
|
int running_tor = options->command == CMD_RUN_TOR;
|
2006-04-18 05:51:18 +02:00
|
|
|
char *msg;
|
2011-05-23 22:38:35 +02:00
|
|
|
const int transition_affects_workers =
|
|
|
|
old_options && options_transition_affects_workers(old_options, options);
|
2004-11-09 00:12:40 +01:00
|
|
|
|
2008-09-01 22:06:26 +02:00
|
|
|
if (running_tor && !have_lockfile()) {
|
|
|
|
if (try_locking(options, 1) < 0)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-12-12 05:38:54 +01:00
|
|
|
if (consider_adding_dir_authorities(options, old_options) < 0)
|
|
|
|
return -1;
|
2004-11-09 00:12:40 +01:00
|
|
|
|
2007-05-08 13:28:05 +02:00
|
|
|
if (options->Bridges) {
|
2011-05-15 18:46:26 +02:00
|
|
|
mark_bridge_list();
|
2007-05-08 13:28:05 +02:00
|
|
|
for (cl = options->Bridges; cl; cl = cl->next) {
|
|
|
|
if (parse_bridge_line(cl->value, 0)<0) {
|
2007-05-13 11:25:06 +02:00
|
|
|
log_warn(LD_BUG,
|
|
|
|
"Previously validated Bridge line could not be added!");
|
2007-05-08 13:28:05 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2011-05-15 18:46:26 +02:00
|
|
|
sweep_bridge_list();
|
2007-05-08 13:28:05 +02:00
|
|
|
}
|
|
|
|
|
2005-08-27 01:22:27 +02:00
|
|
|
if (running_tor && rend_config_services(options, 0)<0) {
|
2007-05-13 11:25:06 +02:00
|
|
|
log_warn(LD_BUG,
|
2007-03-04 21:11:46 +01:00
|
|
|
"Previously validated hidden services line could not be added!");
|
2004-11-09 05:28:18 +01:00
|
|
|
return -1;
|
2004-11-09 00:12:40 +01:00
|
|
|
}
|
2004-11-09 05:28:18 +01:00
|
|
|
|
2008-08-12 18:12:26 +02:00
|
|
|
if (running_tor && rend_parse_service_authorization(options, 0) < 0) {
|
|
|
|
log_warn(LD_BUG, "Previously validated client authorization for "
|
|
|
|
"hidden services could not be added!");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-07-28 21:01:48 +02:00
|
|
|
/* Load state */
|
2008-03-03 13:48:13 +01:00
|
|
|
if (! global_state && running_tor) {
|
2005-07-28 21:01:48 +02:00
|
|
|
if (or_state_load())
|
|
|
|
return -1;
|
2007-09-13 19:01:08 +02:00
|
|
|
rep_hist_load_mtbf_data(time(NULL));
|
2007-08-20 17:59:31 +02:00
|
|
|
}
|
|
|
|
|
2007-01-11 00:48:24 +01:00
|
|
|
/* Bail out at this point if we're not going to be a client or server:
|
|
|
|
* we want to not fork, and to log stuff to stderr. */
|
2007-12-09 04:38:57 +01:00
|
|
|
if (!running_tor)
|
2007-01-11 00:48:24 +01:00
|
|
|
return 0;
|
|
|
|
|
2004-11-09 05:28:18 +01:00
|
|
|
/* Finish backgrounding the process */
|
2009-05-24 23:01:30 +02:00
|
|
|
if (options->RunAsDaemon) {
|
2004-11-09 19:22:17 +01:00
|
|
|
/* We may be calling this for the n'th time (on SIGHUP), but it's safe. */
|
2005-04-06 21:07:38 +02:00
|
|
|
finish_daemon(options->DataDirectory);
|
2004-11-09 05:28:18 +01:00
|
|
|
}
|
|
|
|
|
2011-05-31 05:50:37 +02:00
|
|
|
/* We want to reinit keys as needed before we do much of anything else:
|
|
|
|
keys are important, and other things can depend on them. */
|
|
|
|
if (transition_affects_workers ||
|
|
|
|
(options->V3AuthoritativeDir && (!old_options ||
|
|
|
|
!old_options->V3AuthoritativeDir))) {
|
|
|
|
if (init_keys() < 0) {
|
|
|
|
log_warn(LD_BUG,"Error initializing keys; exiting");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-27 23:55:51 +02:00
|
|
|
/* Write our PID to the PID file. If we do not have write permissions we
|
2004-11-09 05:28:18 +01:00
|
|
|
* will log a warning */
|
2009-05-24 23:01:30 +02:00
|
|
|
if (options->PidFile)
|
2004-11-09 05:28:18 +01:00
|
|
|
write_pidfile(options->PidFile);
|
|
|
|
|
2005-02-22 01:53:08 +01:00
|
|
|
/* Register addressmap directives */
|
|
|
|
config_register_addressmaps(options);
|
2006-04-18 05:36:28 +02:00
|
|
|
parse_virtual_addr_network(options->VirtualAddrNetwork, 0, &msg);
|
2005-02-22 01:53:08 +01:00
|
|
|
|
2004-11-12 20:39:13 +01:00
|
|
|
/* Update address policies. */
|
2008-02-05 22:39:32 +01:00
|
|
|
if (policies_parse_from_options(options) < 0) {
|
|
|
|
/* This should be impossible, but let's be sure. */
|
|
|
|
log_warn(LD_BUG,"Error parsing already-validated policy options.");
|
|
|
|
return -1;
|
|
|
|
}
|
2004-11-12 20:39:13 +01:00
|
|
|
|
2007-08-15 17:26:14 +02:00
|
|
|
if (init_cookie_authentication(options->CookieAuthentication) < 0) {
|
|
|
|
log_warn(LD_CONFIG,"Error creating cookie authentication file.");
|
|
|
|
return -1;
|
|
|
|
}
|
2004-11-12 17:39:03 +01:00
|
|
|
|
2011-05-16 19:25:59 +02:00
|
|
|
monitor_owning_controller_process(options->OwningControllerProcess);
|
2011-05-15 17:23:04 +02:00
|
|
|
|
2004-11-09 05:28:18 +01:00
|
|
|
/* reload keys as needed for rendezvous services. */
|
|
|
|
if (rend_service_load_keys()<0) {
|
2007-05-13 11:25:06 +02:00
|
|
|
log_warn(LD_GENERAL,"Error loading rendezvous service keys");
|
2004-11-09 05:28:18 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2004-11-14 23:21:23 +01:00
|
|
|
/* Set up accounting */
|
2004-11-22 22:56:51 +01:00
|
|
|
if (accounting_parse_options(options, 0)<0) {
|
2007-05-13 11:25:06 +02:00
|
|
|
log_warn(LD_CONFIG,"Error in accounting options");
|
2004-11-22 22:56:51 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2004-11-15 05:01:31 +01:00
|
|
|
if (accounting_is_enabled(options))
|
2004-11-14 23:21:23 +01:00
|
|
|
configure_accounting(time(NULL));
|
|
|
|
|
2010-02-22 19:59:34 +01:00
|
|
|
#ifdef USE_BUFFEREVENTS
|
|
|
|
/* If we're using the bufferevents implementation and our rate limits
|
|
|
|
* changed, we need to tell the rate-limiting system about it. */
|
|
|
|
if (!old_options ||
|
|
|
|
old_options->BandwidthRate != options->BandwidthRate ||
|
|
|
|
old_options->BandwidthBurst != options->BandwidthBurst ||
|
|
|
|
old_options->RelayBandwidthRate != options->RelayBandwidthRate ||
|
|
|
|
old_options->RelayBandwidthBurst != options->RelayBandwidthBurst)
|
|
|
|
connection_bucket_init();
|
|
|
|
#endif
|
|
|
|
|
2009-12-12 06:49:48 +01:00
|
|
|
/* Change the cell EWMA settings */
|
2009-12-15 19:53:53 +01:00
|
|
|
cell_ewma_set_scale_factor(options, networkstatus_get_latest_consensus());
|
2009-12-12 06:49:48 +01:00
|
|
|
|
2005-08-22 02:18:45 +02:00
|
|
|
/* Check for transitions that need action. */
|
|
|
|
if (old_options) {
|
2011-05-13 22:22:58 +02:00
|
|
|
int revise_trackexithosts = 0;
|
2011-05-13 22:59:31 +02:00
|
|
|
int revise_automap_entries = 0;
|
2009-09-20 03:03:49 +02:00
|
|
|
if ((options->UseEntryGuards && !old_options->UseEntryGuards) ||
|
2011-05-18 02:51:47 +02:00
|
|
|
options->UseBridges != old_options->UseBridges ||
|
|
|
|
(options->UseBridges &&
|
|
|
|
!config_lines_eq(options->Bridges, old_options->Bridges)) ||
|
2011-04-04 01:13:36 +02:00
|
|
|
!routerset_equal(old_options->ExcludeNodes,options->ExcludeNodes) ||
|
|
|
|
!routerset_equal(old_options->ExcludeExitNodes,
|
|
|
|
options->ExcludeExitNodes) ||
|
|
|
|
!routerset_equal(old_options->EntryNodes, options->EntryNodes) ||
|
|
|
|
!routerset_equal(old_options->ExitNodes, options->ExitNodes) ||
|
2009-09-20 03:52:57 +02:00
|
|
|
options->StrictNodes != old_options->StrictNodes) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_info(LD_CIRC,
|
2011-05-18 02:51:47 +02:00
|
|
|
"Changed to using entry guards or bridges, or changed "
|
|
|
|
"preferred or excluded node lists. "
|
|
|
|
"Abandoning previous circuits.");
|
2005-10-06 01:02:40 +02:00
|
|
|
circuit_mark_all_unused_circs();
|
|
|
|
circuit_expire_all_dirty_circs();
|
2011-05-13 22:22:58 +02:00
|
|
|
revise_trackexithosts = 1;
|
2005-10-06 01:02:40 +02:00
|
|
|
}
|
|
|
|
|
2011-05-13 22:22:58 +02:00
|
|
|
if (!smartlist_strings_eq(old_options->TrackHostExits,
|
|
|
|
options->TrackHostExits))
|
|
|
|
revise_trackexithosts = 1;
|
|
|
|
|
|
|
|
if (revise_trackexithosts)
|
2011-04-04 01:43:47 +02:00
|
|
|
addressmap_clear_excluded_trackexithosts(options);
|
2011-05-13 22:22:58 +02:00
|
|
|
|
2011-05-16 02:12:01 +02:00
|
|
|
if (!options->AutomapHostsOnResolve) {
|
|
|
|
if (old_options->AutomapHostsOnResolve)
|
|
|
|
revise_automap_entries = 1;
|
|
|
|
} else {
|
2011-05-13 22:59:31 +02:00
|
|
|
if (!smartlist_strings_eq(old_options->AutomapHostsSuffixes,
|
|
|
|
options->AutomapHostsSuffixes))
|
|
|
|
revise_automap_entries = 1;
|
|
|
|
else if (!opt_streq(old_options->VirtualAddrNetwork,
|
|
|
|
options->VirtualAddrNetwork))
|
|
|
|
revise_automap_entries = 1;
|
2005-10-06 01:02:40 +02:00
|
|
|
}
|
|
|
|
|
2011-05-13 22:59:31 +02:00
|
|
|
if (revise_automap_entries)
|
|
|
|
addressmap_clear_invalid_automaps(options);
|
|
|
|
|
2010-07-08 14:29:04 +02:00
|
|
|
/* How long should we delay counting bridge stats after becoming a bridge?
|
|
|
|
* We use this so we don't count people who used our bridge thinking it is
|
|
|
|
* a relay. If you change this, don't forget to change the log message
|
2010-08-18 22:12:44 +02:00
|
|
|
* below. It's 4 hours (the time it takes to stop being used by clients)
|
|
|
|
* plus some extra time for clock skew. */
|
|
|
|
#define RELAY_BRIDGE_STATS_DELAY (6 * 60 * 60)
|
2010-07-08 14:29:04 +02:00
|
|
|
|
2009-05-12 21:35:53 +02:00
|
|
|
if (! bool_eq(options->BridgeRelay, old_options->BridgeRelay)) {
|
2010-07-08 14:29:04 +02:00
|
|
|
int was_relay = 0;
|
2010-06-21 18:52:46 +02:00
|
|
|
if (options->BridgeRelay) {
|
2010-07-08 14:29:04 +02:00
|
|
|
time_t int_start = time(NULL);
|
|
|
|
if (old_options->ORPort == options->ORPort) {
|
|
|
|
int_start += RELAY_BRIDGE_STATS_DELAY;
|
|
|
|
was_relay = 1;
|
|
|
|
}
|
|
|
|
geoip_bridge_stats_init(int_start);
|
2010-06-21 18:52:46 +02:00
|
|
|
log_info(LD_CONFIG, "We are acting as a bridge now. Starting new "
|
2010-08-18 22:12:44 +02:00
|
|
|
"GeoIP stats interval%s.", was_relay ? " in 6 "
|
2010-07-08 14:29:04 +02:00
|
|
|
"hours from now" : "");
|
2010-06-21 18:52:46 +02:00
|
|
|
} else {
|
|
|
|
geoip_bridge_stats_term();
|
|
|
|
log_info(LD_GENERAL, "We are no longer acting as a bridge. "
|
|
|
|
"Forgetting GeoIP stats.");
|
|
|
|
}
|
2009-05-12 21:35:53 +02:00
|
|
|
}
|
|
|
|
|
2011-05-23 22:38:35 +02:00
|
|
|
if (transition_affects_workers) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_info(LD_GENERAL,
|
|
|
|
"Worker-related options changed. Rotating workers.");
|
2011-01-25 15:28:58 +01:00
|
|
|
|
2006-01-17 05:01:32 +01:00
|
|
|
if (server_mode(options) && !server_mode(old_options)) {
|
2006-12-28 22:29:20 +01:00
|
|
|
ip_address_changed(0);
|
2010-09-22 07:52:57 +02:00
|
|
|
if (can_complete_circuit || !any_predicted_circuits(time(NULL)))
|
2006-01-17 05:01:32 +01:00
|
|
|
inform_testing_reachability();
|
|
|
|
}
|
2005-08-22 02:18:45 +02:00
|
|
|
cpuworkers_rotate();
|
2007-02-02 19:58:04 +01:00
|
|
|
if (dns_reset())
|
|
|
|
return -1;
|
2007-03-05 03:40:58 +01:00
|
|
|
} else {
|
2007-02-02 19:58:04 +01:00
|
|
|
if (dns_reset())
|
|
|
|
return -1;
|
2006-08-28 05:15:55 +02:00
|
|
|
}
|
2007-08-14 22:19:40 +02:00
|
|
|
|
2010-08-15 10:01:42 +02:00
|
|
|
if (options->PerConnBWRate != old_options->PerConnBWRate ||
|
|
|
|
options->PerConnBWBurst != old_options->PerConnBWBurst)
|
|
|
|
connection_or_update_token_buckets(get_connection_array(), options);
|
2005-08-22 02:18:45 +02:00
|
|
|
}
|
|
|
|
|
2007-12-17 23:44:11 +01:00
|
|
|
/* Maybe load geoip file */
|
2007-12-18 22:27:08 +01:00
|
|
|
if (options->GeoIPFile &&
|
|
|
|
((!old_options || !opt_streq(old_options->GeoIPFile, options->GeoIPFile))
|
2007-12-17 23:44:11 +01:00
|
|
|
|| !geoip_is_loaded())) {
|
2008-12-18 17:11:24 +01:00
|
|
|
/* XXXX Don't use this "<default>" junk; make our filename options
|
2008-05-29 03:22:30 +02:00
|
|
|
* understand prefixes somehow. -NM */
|
2011-03-25 21:01:16 +01:00
|
|
|
/* XXXX023 Reload GeoIPFile on SIGHUP. -NM */
|
2008-05-29 03:22:30 +02:00
|
|
|
char *actual_fname = tor_strdup(options->GeoIPFile);
|
|
|
|
#ifdef WIN32
|
|
|
|
if (!strcmp(actual_fname, "<default>")) {
|
|
|
|
const char *conf_root = get_windows_conf_root();
|
2008-06-14 17:42:29 +02:00
|
|
|
size_t len = strlen(conf_root)+16;
|
2008-05-29 03:22:30 +02:00
|
|
|
tor_free(actual_fname);
|
|
|
|
actual_fname = tor_malloc(len+1);
|
|
|
|
tor_snprintf(actual_fname, len, "%s\\geoip", conf_root);
|
|
|
|
}
|
|
|
|
#endif
|
2008-06-04 11:02:25 +02:00
|
|
|
geoip_load_file(actual_fname, options);
|
2008-05-29 03:22:30 +02:00
|
|
|
tor_free(actual_fname);
|
2007-12-17 23:44:11 +01:00
|
|
|
}
|
2009-07-15 16:32:40 +02:00
|
|
|
|
2010-06-21 18:52:46 +02:00
|
|
|
if (options->CellStatistics || options->DirReqStatistics ||
|
2010-08-02 15:06:14 +02:00
|
|
|
options->EntryStatistics || options->ExitPortStatistics ||
|
2010-08-15 14:58:35 +02:00
|
|
|
options->ConnDirectionStatistics) {
|
2010-06-21 18:52:46 +02:00
|
|
|
time_t now = time(NULL);
|
2010-11-09 14:18:00 +01:00
|
|
|
int print_notice = 0;
|
2010-06-21 18:52:46 +02:00
|
|
|
if ((!old_options || !old_options->CellStatistics) &&
|
2010-11-09 14:18:00 +01:00
|
|
|
options->CellStatistics) {
|
2010-06-21 18:52:46 +02:00
|
|
|
rep_hist_buffer_stats_init(now);
|
2010-11-09 14:18:00 +01:00
|
|
|
print_notice = 1;
|
|
|
|
}
|
2010-06-21 18:52:46 +02:00
|
|
|
if ((!old_options || !old_options->DirReqStatistics) &&
|
2010-11-09 14:18:00 +01:00
|
|
|
options->DirReqStatistics) {
|
|
|
|
if (geoip_is_loaded()) {
|
|
|
|
geoip_dirreq_stats_init(now);
|
|
|
|
print_notice = 1;
|
|
|
|
} else {
|
2010-12-22 08:34:41 +01:00
|
|
|
options->DirReqStatistics = 0;
|
2011-02-06 00:25:33 +01:00
|
|
|
/* Don't warn Tor clients, they don't use statistics */
|
|
|
|
if (options->ORPort)
|
|
|
|
log_notice(LD_CONFIG, "Configured to measure directory request "
|
|
|
|
"statistics, but no GeoIP database found. "
|
|
|
|
"Please specify a GeoIP database using the "
|
|
|
|
"GeoIPFile option.");
|
2010-11-09 14:18:00 +01:00
|
|
|
}
|
|
|
|
}
|
2010-06-21 18:52:46 +02:00
|
|
|
if ((!old_options || !old_options->EntryStatistics) &&
|
2010-11-09 14:18:00 +01:00
|
|
|
options->EntryStatistics && !should_record_bridge_info(options)) {
|
|
|
|
if (geoip_is_loaded()) {
|
|
|
|
geoip_entry_stats_init(now);
|
|
|
|
print_notice = 1;
|
|
|
|
} else {
|
2010-12-22 08:34:41 +01:00
|
|
|
options->EntryStatistics = 0;
|
2010-11-09 14:18:00 +01:00
|
|
|
log_notice(LD_CONFIG, "Configured to measure entry node "
|
2011-02-06 00:25:33 +01:00
|
|
|
"statistics, but no GeoIP database found. "
|
2010-11-09 14:18:00 +01:00
|
|
|
"Please specify a GeoIP database using the "
|
2011-02-06 00:25:33 +01:00
|
|
|
"GeoIPFile option.");
|
2010-11-09 14:18:00 +01:00
|
|
|
}
|
|
|
|
}
|
2010-06-21 18:52:46 +02:00
|
|
|
if ((!old_options || !old_options->ExitPortStatistics) &&
|
2010-11-09 14:18:00 +01:00
|
|
|
options->ExitPortStatistics) {
|
2010-06-21 18:52:46 +02:00
|
|
|
rep_hist_exit_stats_init(now);
|
2010-11-09 14:18:00 +01:00
|
|
|
print_notice = 1;
|
|
|
|
}
|
2010-08-15 14:58:35 +02:00
|
|
|
if ((!old_options || !old_options->ConnDirectionStatistics) &&
|
2010-12-21 22:01:00 +01:00
|
|
|
options->ConnDirectionStatistics) {
|
2010-08-02 15:06:14 +02:00
|
|
|
rep_hist_conn_stats_init(now);
|
2010-12-21 22:01:00 +01:00
|
|
|
}
|
2010-11-09 14:18:00 +01:00
|
|
|
if (print_notice)
|
2010-06-21 18:52:46 +02:00
|
|
|
log_notice(LD_CONFIG, "Configured to measure statistics. Look for "
|
|
|
|
"the *-stats files that will first be written to the "
|
|
|
|
"data directory in 24 hours from now.");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (old_options && old_options->CellStatistics &&
|
|
|
|
!options->CellStatistics)
|
|
|
|
rep_hist_buffer_stats_term();
|
|
|
|
if (old_options && old_options->DirReqStatistics &&
|
|
|
|
!options->DirReqStatistics)
|
|
|
|
geoip_dirreq_stats_term();
|
|
|
|
if (old_options && old_options->EntryStatistics &&
|
|
|
|
!options->EntryStatistics)
|
|
|
|
geoip_entry_stats_term();
|
|
|
|
if (old_options && old_options->ExitPortStatistics &&
|
|
|
|
!options->ExitPortStatistics)
|
|
|
|
rep_hist_exit_stats_term();
|
2010-08-15 14:58:35 +02:00
|
|
|
if (old_options && old_options->ConnDirectionStatistics &&
|
|
|
|
!options->ConnDirectionStatistics)
|
2010-08-02 15:06:14 +02:00
|
|
|
rep_hist_conn_stats_term();
|
2010-06-21 18:52:46 +02:00
|
|
|
|
2005-12-31 07:32:57 +01:00
|
|
|
/* Check if we need to parse and add the EntryNodes config option. */
|
2006-01-02 06:14:21 +01:00
|
|
|
if (options->EntryNodes &&
|
|
|
|
(!old_options ||
|
2009-10-18 00:54:20 +02:00
|
|
|
!routerset_equal(old_options->EntryNodes,options->EntryNodes) ||
|
|
|
|
!routerset_equal(old_options->ExcludeNodes,options->ExcludeNodes)))
|
2005-12-31 07:32:57 +01:00
|
|
|
entry_nodes_should_be_added();
|
|
|
|
|
2004-11-13 17:53:48 +01:00
|
|
|
/* Since our options changed, we might need to regenerate and upload our
|
2005-08-22 02:18:45 +02:00
|
|
|
* server descriptor.
|
2004-11-13 17:53:48 +01:00
|
|
|
*/
|
2005-12-14 21:40:40 +01:00
|
|
|
if (!old_options ||
|
|
|
|
options_transition_affects_descriptor(old_options, options))
|
2011-05-20 05:36:20 +02:00
|
|
|
mark_my_descriptor_dirty("config change");
|
2004-11-13 17:53:48 +01:00
|
|
|
|
2007-10-22 18:32:04 +02:00
|
|
|
/* We may need to reschedule some directory stuff if our status changed. */
|
2007-10-23 00:54:28 +02:00
|
|
|
if (old_options) {
|
|
|
|
if (authdir_mode_v3(options) && !authdir_mode_v3(old_options))
|
|
|
|
dirvote_recalculate_timing(options, time(NULL));
|
2007-12-21 07:08:00 +01:00
|
|
|
if (!bool_eq(directory_fetches_dir_info_early(options),
|
|
|
|
directory_fetches_dir_info_early(old_options)) ||
|
|
|
|
!bool_eq(directory_fetches_dir_info_later(options),
|
|
|
|
directory_fetches_dir_info_later(old_options))) {
|
2007-10-23 00:54:28 +02:00
|
|
|
/* Make sure update_router_have_min_dir_info gets called. */
|
|
|
|
router_dir_info_changed();
|
|
|
|
/* We might need to download a new consensus status later or sooner than
|
|
|
|
* we had expected. */
|
|
|
|
update_consensus_networkstatus_fetch_time(time(NULL));
|
|
|
|
}
|
2007-10-22 18:32:04 +02:00
|
|
|
}
|
|
|
|
|
2009-05-27 23:55:51 +02:00
|
|
|
/* Load the webpage we're going to serve every time someone asks for '/' on
|
2008-12-07 02:21:19 +01:00
|
|
|
our DirPort. */
|
|
|
|
tor_free(global_dirfrontpagecontents);
|
|
|
|
if (options->DirPortFrontPage) {
|
|
|
|
global_dirfrontpagecontents =
|
|
|
|
read_file_to_str(options->DirPortFrontPage, 0, NULL);
|
2008-12-07 02:51:56 +01:00
|
|
|
if (!global_dirfrontpagecontents) {
|
2008-12-07 02:48:30 +01:00
|
|
|
log_warn(LD_CONFIG,
|
|
|
|
"DirPortFrontPage file '%s' not found. Continuing anyway.",
|
|
|
|
options->DirPortFrontPage);
|
|
|
|
}
|
2008-12-07 02:21:19 +01:00
|
|
|
}
|
|
|
|
|
2004-11-09 05:28:18 +01:00
|
|
|
return 0;
|
2004-11-06 06:18:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functions to parse config options
|
|
|
|
*/
|
|
|
|
|
2004-10-27 05:08:04 +02:00
|
|
|
/** If <b>option</b> is an official abbreviation for a longer option,
|
2004-10-27 19:37:01 +02:00
|
|
|
* return the longer option. Otherwise return <b>option</b>.
|
|
|
|
* If <b>command_line</b> is set, apply all abbreviations. Otherwise, only
|
2005-10-17 05:06:00 +02:00
|
|
|
* apply abbreviations that work for the config file and the command line.
|
|
|
|
* If <b>warn_obsolete</b> is set, warn about deprecated names. */
|
2004-10-27 04:30:28 +02:00
|
|
|
static const char *
|
2005-10-17 05:06:00 +02:00
|
|
|
expand_abbrev(config_format_t *fmt, const char *option, int command_line,
|
|
|
|
int warn_obsolete)
|
2004-10-27 04:30:28 +02:00
|
|
|
{
|
|
|
|
int i;
|
2005-07-22 22:37:42 +02:00
|
|
|
if (! fmt->abbrevs)
|
|
|
|
return option;
|
|
|
|
for (i=0; fmt->abbrevs[i].abbreviated; ++i) {
|
2009-05-27 23:55:51 +02:00
|
|
|
/* Abbreviations are case insensitive. */
|
2005-07-22 22:37:42 +02:00
|
|
|
if (!strcasecmp(option,fmt->abbrevs[i].abbreviated) &&
|
|
|
|
(command_line || !fmt->abbrevs[i].commandline_only)) {
|
2005-10-17 05:06:00 +02:00
|
|
|
if (warn_obsolete && fmt->abbrevs[i].warn) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG,
|
|
|
|
"The configuration option '%s' is deprecated; "
|
|
|
|
"use '%s' instead.",
|
|
|
|
fmt->abbrevs[i].abbreviated,
|
|
|
|
fmt->abbrevs[i].full);
|
2005-10-17 05:06:00 +02:00
|
|
|
}
|
2009-09-18 02:32:42 +02:00
|
|
|
/* Keep going through the list in case we want to rewrite it more.
|
|
|
|
* (We could imagine recursing here, but I don't want to get the
|
|
|
|
* user into an infinite loop if we craft our list wrong.) */
|
|
|
|
option = fmt->abbrevs[i].full;
|
2004-10-27 19:37:01 +02:00
|
|
|
}
|
2004-10-27 04:30:28 +02:00
|
|
|
}
|
|
|
|
return option;
|
|
|
|
}
|
2004-10-17 03:57:34 +02:00
|
|
|
|
2005-09-10 06:40:27 +02:00
|
|
|
/** Helper: Read a list of configuration options from the command line.
|
|
|
|
* If successful, put them in *<b>result</b> and return 0, and return
|
|
|
|
* -1 and leave *<b>result</b> alone. */
|
|
|
|
static int
|
|
|
|
config_get_commandlines(int argc, char **argv, config_line_t **result)
|
2004-10-14 04:47:09 +02:00
|
|
|
{
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *front = NULL;
|
|
|
|
config_line_t **new = &front;
|
2002-11-23 07:49:01 +01:00
|
|
|
char *s;
|
|
|
|
int i = 1;
|
|
|
|
|
2005-09-10 06:40:27 +02:00
|
|
|
while (i < argc) {
|
2004-11-03 20:49:03 +01:00
|
|
|
if (!strcmp(argv[i],"-f") ||
|
|
|
|
!strcmp(argv[i],"--hash-password")) {
|
|
|
|
i += 2; /* command-line option with argument. ignore them. */
|
2002-11-23 07:49:01 +01:00
|
|
|
continue;
|
2006-03-12 21:46:00 +01:00
|
|
|
} else if (!strcmp(argv[i],"--list-fingerprint") ||
|
2007-02-06 19:36:21 +01:00
|
|
|
!strcmp(argv[i],"--verify-config") ||
|
2007-11-01 05:38:43 +01:00
|
|
|
!strcmp(argv[i],"--ignore-missing-torrc") ||
|
2008-03-27 18:25:49 +01:00
|
|
|
!strcmp(argv[i],"--quiet") ||
|
|
|
|
!strcmp(argv[i],"--hush")) {
|
2004-10-30 21:18:37 +02:00
|
|
|
i += 1; /* command-line option. ignore it. */
|
2004-11-03 20:49:03 +01:00
|
|
|
continue;
|
2007-01-15 09:52:01 +01:00
|
|
|
} else if (!strcmp(argv[i],"--nt-service") ||
|
|
|
|
!strcmp(argv[i],"-nt-service")) {
|
2005-02-05 22:40:25 +01:00
|
|
|
i += 1;
|
|
|
|
continue;
|
2002-11-23 07:49:01 +01:00
|
|
|
}
|
2007-11-01 05:38:43 +01:00
|
|
|
|
2005-09-10 06:40:27 +02:00
|
|
|
if (i == argc-1) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG,"Command-line option '%s' with no value. Failing.",
|
|
|
|
argv[i]);
|
2005-09-10 06:40:27 +02:00
|
|
|
config_free_lines(front);
|
|
|
|
return -1;
|
|
|
|
}
|
2002-11-23 07:49:01 +01:00
|
|
|
|
2005-07-22 23:12:10 +02:00
|
|
|
*new = tor_malloc_zero(sizeof(config_line_t));
|
2002-11-23 07:49:01 +01:00
|
|
|
s = argv[i];
|
2004-10-14 04:47:09 +02:00
|
|
|
|
2009-10-27 17:50:24 +01:00
|
|
|
/* Each keyword may be prefixed with one or two dashes. */
|
|
|
|
if (*s == '-')
|
|
|
|
s++;
|
|
|
|
if (*s == '-')
|
2002-11-23 07:49:01 +01:00
|
|
|
s++;
|
2004-10-14 04:47:09 +02:00
|
|
|
|
2005-10-17 05:06:00 +02:00
|
|
|
(*new)->key = tor_strdup(expand_abbrev(&options_format, s, 1, 1));
|
2005-07-11 19:35:36 +02:00
|
|
|
(*new)->value = tor_strdup(argv[i+1]);
|
|
|
|
(*new)->next = NULL;
|
2009-05-27 23:55:51 +02:00
|
|
|
log(LOG_DEBUG, LD_CONFIG, "command line: parsed keyword '%s', value '%s'",
|
2005-07-11 19:35:36 +02:00
|
|
|
(*new)->key, (*new)->value);
|
|
|
|
|
|
|
|
new = &((*new)->next);
|
2002-11-23 07:49:01 +01:00
|
|
|
i += 2;
|
|
|
|
}
|
2005-09-10 06:40:27 +02:00
|
|
|
*result = front;
|
|
|
|
return 0;
|
2002-11-23 07:49:01 +01:00
|
|
|
}
|
|
|
|
|
2004-05-10 06:48:13 +02:00
|
|
|
/** Helper: allocate a new configuration option mapping 'key' to 'val',
|
2005-01-05 07:05:37 +01:00
|
|
|
* append it to *<b>lst</b>. */
|
|
|
|
static void
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_append(config_line_t **lst,
|
2005-01-05 07:05:37 +01:00
|
|
|
const char *key,
|
|
|
|
const char *val)
|
2004-03-31 23:35:23 +02:00
|
|
|
{
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *newline;
|
2004-10-14 04:47:09 +02:00
|
|
|
|
2005-07-22 23:12:10 +02:00
|
|
|
newline = tor_malloc(sizeof(config_line_t));
|
2004-03-31 23:35:23 +02:00
|
|
|
newline->key = tor_strdup(key);
|
|
|
|
newline->value = tor_strdup(val);
|
2005-01-05 07:05:37 +01:00
|
|
|
newline->next = NULL;
|
|
|
|
while (*lst)
|
|
|
|
lst = &((*lst)->next);
|
|
|
|
|
|
|
|
(*lst) = newline;
|
2004-03-31 23:35:23 +02:00
|
|
|
}
|
|
|
|
|
2004-11-06 06:18:11 +01:00
|
|
|
/** Helper: parse the config string and strdup into key/value
|
|
|
|
* strings. Set *result to the list, or NULL if parsing the string
|
2004-09-03 00:08:36 +02:00
|
|
|
* failed. Return 0 on success, -1 on failure. Warn and ignore any
|
2008-01-02 07:59:12 +01:00
|
|
|
* misformatted lines. */
|
2004-11-06 06:18:11 +01:00
|
|
|
int
|
2008-01-02 07:59:12 +01:00
|
|
|
config_get_lines(const char *string, config_line_t **result)
|
2004-10-14 04:47:09 +02:00
|
|
|
{
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *list = NULL, **next;
|
2004-11-06 06:18:11 +01:00
|
|
|
char *k, *v;
|
2002-11-23 07:49:01 +01:00
|
|
|
|
2005-01-05 07:05:37 +01:00
|
|
|
next = &list;
|
2004-11-06 06:18:11 +01:00
|
|
|
do {
|
2008-09-05 22:52:15 +02:00
|
|
|
k = v = NULL;
|
2008-01-02 07:59:12 +01:00
|
|
|
string = parse_config_line_from_str(string, &k, &v);
|
2004-11-06 06:18:11 +01:00
|
|
|
if (!string) {
|
|
|
|
config_free_lines(list);
|
2008-09-05 22:52:15 +02:00
|
|
|
tor_free(k);
|
|
|
|
tor_free(v);
|
2004-11-06 06:18:11 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2005-01-05 07:05:37 +01:00
|
|
|
if (k && v) {
|
|
|
|
/* This list can get long, so we keep a pointer to the end of it
|
2007-11-30 19:53:14 +01:00
|
|
|
* rather than using config_line_append over and over and getting
|
|
|
|
* n^2 performance. */
|
2005-07-22 23:12:10 +02:00
|
|
|
*next = tor_malloc(sizeof(config_line_t));
|
2008-01-02 07:59:12 +01:00
|
|
|
(*next)->key = k;
|
|
|
|
(*next)->value = v;
|
2005-01-05 07:05:37 +01:00
|
|
|
(*next)->next = NULL;
|
|
|
|
next = &((*next)->next);
|
2008-01-02 07:59:12 +01:00
|
|
|
} else {
|
|
|
|
tor_free(k);
|
|
|
|
tor_free(v);
|
2005-01-05 07:05:37 +01:00
|
|
|
}
|
2004-11-06 06:18:11 +01:00
|
|
|
} while (*string);
|
2004-10-14 04:47:09 +02:00
|
|
|
|
2004-11-06 06:18:11 +01:00
|
|
|
*result = list;
|
2004-11-04 09:26:34 +01:00
|
|
|
return 0;
|
2002-06-27 00:45:49 +02:00
|
|
|
}
|
|
|
|
|
2004-05-10 06:48:13 +02:00
|
|
|
/**
|
|
|
|
* Free all the configuration lines on the linked list <b>front</b>.
|
|
|
|
*/
|
2004-11-06 06:18:11 +01:00
|
|
|
void
|
2005-07-22 23:12:10 +02:00
|
|
|
config_free_lines(config_line_t *front)
|
2004-10-14 04:47:09 +02:00
|
|
|
{
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *tmp;
|
2002-11-23 07:49:01 +01:00
|
|
|
|
2004-10-14 04:47:09 +02:00
|
|
|
while (front) {
|
2002-11-23 07:49:01 +01:00
|
|
|
tmp = front;
|
|
|
|
front = tmp->next;
|
|
|
|
|
2004-09-29 08:52:36 +02:00
|
|
|
tor_free(tmp->key);
|
|
|
|
tor_free(tmp->value);
|
|
|
|
tor_free(tmp);
|
2002-11-23 07:49:01 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-10-27 05:08:04 +02:00
|
|
|
/** If <b>key</b> is a configuration option, return the corresponding
|
|
|
|
* config_var_t. Otherwise, if <b>key</b> is a non-standard abbreviation,
|
|
|
|
* warn, and return the corresponding config_var_t. Otherwise return NULL.
|
|
|
|
*/
|
2005-06-11 20:52:12 +02:00
|
|
|
static config_var_t *
|
2005-07-22 22:37:42 +02:00
|
|
|
config_find_option(config_format_t *fmt, const char *key)
|
2004-10-27 04:30:28 +02:00
|
|
|
{
|
|
|
|
int i;
|
2005-02-01 01:05:57 +01:00
|
|
|
size_t keylen = strlen(key);
|
2005-02-05 22:42:46 +01:00
|
|
|
if (!keylen)
|
2009-05-27 23:55:51 +02:00
|
|
|
return NULL; /* if they say "--" on the command line, it's not an option */
|
2004-10-27 05:08:04 +02:00
|
|
|
/* First, check for an exact (case-insensitive) match */
|
2005-07-22 22:37:42 +02:00
|
|
|
for (i=0; fmt->vars[i].name; ++i) {
|
2005-08-04 21:56:41 +02:00
|
|
|
if (!strcasecmp(key, fmt->vars[i].name)) {
|
2005-07-22 22:37:42 +02:00
|
|
|
return &fmt->vars[i];
|
2005-08-04 21:56:41 +02:00
|
|
|
}
|
2004-10-27 05:08:04 +02:00
|
|
|
}
|
|
|
|
/* If none, check for an abbreviated match */
|
2005-07-22 22:37:42 +02:00
|
|
|
for (i=0; fmt->vars[i].name; ++i) {
|
|
|
|
if (!strncasecmp(key, fmt->vars[i].name, keylen)) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG, "The abbreviation '%s' is deprecated. "
|
|
|
|
"Please use '%s' instead",
|
|
|
|
key, fmt->vars[i].name);
|
2005-07-22 22:37:42 +02:00
|
|
|
return &fmt->vars[i];
|
2004-10-27 04:30:28 +02:00
|
|
|
}
|
|
|
|
}
|
2006-03-11 19:40:33 +01:00
|
|
|
/* Okay, unrecognized option */
|
2004-10-27 04:30:28 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
Warn when encounter the same (non-list) option twice in the same place
It's okay to get (say) a SocksPort line in the torrc, and then a
SocksPort on the command line to override it, and then a SocksPort via
a controller to override *that*. But if there are two occurrences of
SocksPort in the torrc, or on the command line, or in a single SETCONF
command, then the user is likely confused. Our old code would not
help unconfuse the user, but would instead silently ignore all but
the last occurrence.
This patch changes the behavior so that if the some option is passed
more than once to any torrc, command line, or SETCONF (each of which
coincidentally corresponds to a call to config_assign()), and the
option is not a type that allows multiple occurrences (LINELIST or
LINELIST_X), then we can warn the user.
This closes trac entry 1384.
2010-07-31 19:16:48 +02:00
|
|
|
/** Return the number of option entries in <b>fmt</b>. */
|
|
|
|
static int
|
|
|
|
config_count_options(config_format_t *fmt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i=0; fmt->vars[i].name; ++i)
|
|
|
|
;
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2005-09-14 04:07:35 +02:00
|
|
|
/*
|
|
|
|
* Functions to assign config options.
|
|
|
|
*/
|
|
|
|
|
2005-09-10 04:42:32 +02:00
|
|
|
/** <b>c</b>-\>key is known to be a real key. Update <b>options</b>
|
|
|
|
* with <b>c</b>-\>value and return 0, or return -1 if bad value.
|
2005-09-14 04:07:35 +02:00
|
|
|
*
|
|
|
|
* Called from config_assign_line() and option_reset().
|
2004-11-04 23:31:50 +01:00
|
|
|
*/
|
2004-10-14 04:47:09 +02:00
|
|
|
static int
|
2005-09-10 04:42:32 +02:00
|
|
|
config_assign_value(config_format_t *fmt, or_options_t *options,
|
2006-03-26 10:09:19 +02:00
|
|
|
config_line_t *c, char **msg)
|
2004-10-14 04:47:09 +02:00
|
|
|
{
|
2010-03-01 03:46:50 +01:00
|
|
|
int i, ok;
|
2004-10-27 04:30:28 +02:00
|
|
|
config_var_t *var;
|
|
|
|
void *lvalue;
|
2002-11-23 07:49:01 +01:00
|
|
|
|
2005-07-22 22:37:42 +02:00
|
|
|
CHECK(fmt, options);
|
|
|
|
|
|
|
|
var = config_find_option(fmt, c->key);
|
2005-09-10 04:42:32 +02:00
|
|
|
tor_assert(var);
|
2004-11-04 23:31:50 +01:00
|
|
|
|
2006-02-12 23:28:30 +01:00
|
|
|
lvalue = STRUCT_VAR_P(options, var->var_offset);
|
2005-09-10 04:42:32 +02:00
|
|
|
|
2004-11-28 10:05:49 +01:00
|
|
|
switch (var->type) {
|
2002-11-23 07:49:01 +01:00
|
|
|
|
2011-05-02 21:05:10 +02:00
|
|
|
case CONFIG_TYPE_PORT:
|
|
|
|
if (!strcasecmp(c->value, "auto")) {
|
|
|
|
*(int *)lvalue = CFG_AUTO_PORT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fall through */
|
2004-10-14 04:47:09 +02:00
|
|
|
case CONFIG_TYPE_UINT:
|
2011-05-02 21:05:10 +02:00
|
|
|
i = (int)tor_parse_long(c->value, 10, 0,
|
|
|
|
var->type==CONFIG_TYPE_PORT ? 65535 : INT_MAX,
|
|
|
|
&ok, NULL);
|
2004-10-14 04:47:09 +02:00
|
|
|
if (!ok) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2005-12-14 21:40:40 +01:00
|
|
|
"Int keyword '%s %s' is malformed or out of bounds.",
|
|
|
|
c->key, c->value);
|
2005-09-10 04:42:32 +02:00
|
|
|
return -1;
|
2004-10-14 04:47:09 +02:00
|
|
|
}
|
2004-10-27 04:30:28 +02:00
|
|
|
*(int *)lvalue = i;
|
2004-10-14 04:47:09 +02:00
|
|
|
break;
|
|
|
|
|
2004-11-20 01:37:00 +01:00
|
|
|
case CONFIG_TYPE_INTERVAL: {
|
|
|
|
i = config_parse_interval(c->value, &ok);
|
|
|
|
if (!ok) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2006-03-26 10:09:19 +02:00
|
|
|
"Interval '%s %s' is malformed or out of bounds.",
|
|
|
|
c->key, c->value);
|
2005-09-10 04:42:32 +02:00
|
|
|
return -1;
|
2004-11-20 01:37:00 +01:00
|
|
|
}
|
|
|
|
*(int *)lvalue = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-08-27 08:13:54 +02:00
|
|
|
case CONFIG_TYPE_MSEC_INTERVAL: {
|
|
|
|
i = config_parse_msec_interval(c->value, &ok);
|
|
|
|
if (!ok) {
|
|
|
|
tor_asprintf(msg,
|
|
|
|
"Msec interval '%s %s' is malformed or out of bounds.",
|
|
|
|
c->key, c->value);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
*(int *)lvalue = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2004-11-20 01:37:00 +01:00
|
|
|
case CONFIG_TYPE_MEMUNIT: {
|
|
|
|
uint64_t u64 = config_parse_memunit(c->value, &ok);
|
|
|
|
if (!ok) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2006-03-26 10:09:19 +02:00
|
|
|
"Value '%s %s' is malformed or out of bounds.",
|
|
|
|
c->key, c->value);
|
2005-09-10 04:42:32 +02:00
|
|
|
return -1;
|
2004-11-20 01:37:00 +01:00
|
|
|
}
|
|
|
|
*(uint64_t *)lvalue = u64;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2004-10-14 04:47:09 +02:00
|
|
|
case CONFIG_TYPE_BOOL:
|
2008-02-22 04:44:36 +01:00
|
|
|
i = (int)tor_parse_long(c->value, 10, 0, 1, &ok, NULL);
|
2004-10-14 04:47:09 +02:00
|
|
|
if (!ok) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2006-03-26 10:09:19 +02:00
|
|
|
"Boolean '%s %s' expects 0 or 1.",
|
|
|
|
c->key, c->value);
|
2005-09-10 04:42:32 +02:00
|
|
|
return -1;
|
2004-10-14 04:47:09 +02:00
|
|
|
}
|
2004-10-27 04:30:28 +02:00
|
|
|
*(int *)lvalue = i;
|
2004-10-14 04:47:09 +02:00
|
|
|
break;
|
|
|
|
|
2010-11-08 19:34:40 +01:00
|
|
|
case CONFIG_TYPE_AUTOBOOL:
|
|
|
|
if (!strcmp(c->value, "auto"))
|
|
|
|
*(int *)lvalue = -1;
|
|
|
|
else if (!strcmp(c->value, "0"))
|
|
|
|
*(int *)lvalue = 0;
|
|
|
|
else if (!strcmp(c->value, "1"))
|
|
|
|
*(int *)lvalue = 1;
|
|
|
|
else {
|
|
|
|
tor_asprintf(msg, "Boolean '%s %s' expects 0, 1, or 'auto'.",
|
|
|
|
c->key, c->value);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2004-10-14 04:47:09 +02:00
|
|
|
case CONFIG_TYPE_STRING:
|
2008-06-16 20:09:53 +02:00
|
|
|
case CONFIG_TYPE_FILENAME:
|
2004-10-27 04:30:28 +02:00
|
|
|
tor_free(*(char **)lvalue);
|
|
|
|
*(char **)lvalue = tor_strdup(c->value);
|
2004-10-14 04:47:09 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case CONFIG_TYPE_DOUBLE:
|
2004-10-27 04:30:28 +02:00
|
|
|
*(double *)lvalue = atof(c->value);
|
2004-10-14 04:47:09 +02:00
|
|
|
break;
|
|
|
|
|
2005-07-28 21:01:48 +02:00
|
|
|
case CONFIG_TYPE_ISOTIME:
|
|
|
|
if (parse_iso_time(c->value, (time_t *)lvalue)) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2005-10-25 09:05:03 +02:00
|
|
|
"Invalid time '%s' for keyword '%s'", c->value, c->key);
|
2005-09-10 04:42:32 +02:00
|
|
|
return -1;
|
2005-07-28 21:01:48 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2008-07-18 20:36:32 +02:00
|
|
|
case CONFIG_TYPE_ROUTERSET:
|
|
|
|
if (*(routerset_t**)lvalue) {
|
|
|
|
routerset_free(*(routerset_t**)lvalue);
|
|
|
|
}
|
|
|
|
*(routerset_t**)lvalue = routerset_new();
|
|
|
|
if (routerset_parse(*(routerset_t**)lvalue, c->value, c->key)<0) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg, "Invalid exit list '%s' for option '%s'",
|
2008-07-18 20:36:32 +02:00
|
|
|
c->value, c->key);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2004-10-14 04:47:09 +02:00
|
|
|
case CONFIG_TYPE_CSV:
|
2005-09-14 04:13:35 +02:00
|
|
|
if (*(smartlist_t**)lvalue) {
|
2005-09-14 04:12:29 +02:00
|
|
|
SMARTLIST_FOREACH(*(smartlist_t**)lvalue, char *, cp, tor_free(cp));
|
|
|
|
smartlist_clear(*(smartlist_t**)lvalue);
|
|
|
|
} else {
|
2004-10-27 04:30:28 +02:00
|
|
|
*(smartlist_t**)lvalue = smartlist_create();
|
2005-01-05 03:51:04 +01:00
|
|
|
}
|
2004-10-14 04:47:09 +02:00
|
|
|
|
2004-10-27 04:30:28 +02:00
|
|
|
smartlist_split_string(*(smartlist_t**)lvalue, c->value, ",",
|
2004-10-14 04:47:09 +02:00
|
|
|
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
|
|
|
|
break;
|
|
|
|
|
2004-11-04 23:31:50 +01:00
|
|
|
case CONFIG_TYPE_LINELIST:
|
|
|
|
case CONFIG_TYPE_LINELIST_S:
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_append((config_line_t**)lvalue, c->key, c->value);
|
2004-11-04 23:31:50 +01:00
|
|
|
break;
|
2004-10-14 04:47:09 +02:00
|
|
|
case CONFIG_TYPE_OBSOLETE:
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG, "Skipping obsolete configuration option '%s'", c->key);
|
2004-10-14 04:47:09 +02:00
|
|
|
break;
|
2004-11-04 23:31:50 +01:00
|
|
|
case CONFIG_TYPE_LINELIST_V:
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2006-03-26 10:09:19 +02:00
|
|
|
"You may not provide a value for virtual option '%s'", c->key);
|
2005-09-10 04:42:32 +02:00
|
|
|
return -1;
|
2004-11-04 23:31:50 +01:00
|
|
|
default:
|
|
|
|
tor_assert(0);
|
|
|
|
break;
|
2002-11-23 07:49:01 +01:00
|
|
|
}
|
2004-10-27 04:30:28 +02:00
|
|
|
return 0;
|
2002-11-23 07:49:01 +01:00
|
|
|
}
|
|
|
|
|
2005-09-10 04:42:32 +02:00
|
|
|
/** If <b>c</b> is a syntactically valid configuration line, update
|
2005-12-14 21:40:40 +01:00
|
|
|
* <b>options</b> with its value and return 0. Otherwise return -1 for bad
|
|
|
|
* key, -2 for bad value.
|
2005-09-10 04:42:32 +02:00
|
|
|
*
|
2005-09-14 04:07:35 +02:00
|
|
|
* If <b>clear_first</b> is set, clear the value first. Then if
|
|
|
|
* <b>use_defaults</b> is set, set the value to the default.
|
|
|
|
*
|
|
|
|
* Called from config_assign().
|
2005-09-10 04:42:32 +02:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
config_assign_line(config_format_t *fmt, or_options_t *options,
|
2006-03-26 10:09:19 +02:00
|
|
|
config_line_t *c, int use_defaults,
|
Warn when encounter the same (non-list) option twice in the same place
It's okay to get (say) a SocksPort line in the torrc, and then a
SocksPort on the command line to override it, and then a SocksPort via
a controller to override *that*. But if there are two occurrences of
SocksPort in the torrc, or on the command line, or in a single SETCONF
command, then the user is likely confused. Our old code would not
help unconfuse the user, but would instead silently ignore all but
the last occurrence.
This patch changes the behavior so that if the some option is passed
more than once to any torrc, command line, or SETCONF (each of which
coincidentally corresponds to a call to config_assign()), and the
option is not a type that allows multiple occurrences (LINELIST or
LINELIST_X), then we can warn the user.
This closes trac entry 1384.
2010-07-31 19:16:48 +02:00
|
|
|
int clear_first, bitarray_t *options_seen, char **msg)
|
2005-09-10 04:42:32 +02:00
|
|
|
{
|
|
|
|
config_var_t *var;
|
|
|
|
|
|
|
|
CHECK(fmt, options);
|
|
|
|
|
|
|
|
var = config_find_option(fmt, c->key);
|
|
|
|
if (!var) {
|
2006-02-12 23:28:30 +01:00
|
|
|
if (fmt->extra) {
|
|
|
|
void *lvalue = STRUCT_VAR_P(options, fmt->extra->var_offset);
|
2006-02-13 10:02:35 +01:00
|
|
|
log_info(LD_CONFIG,
|
|
|
|
"Found unrecognized option '%s'; saving it.", c->key);
|
2006-02-12 23:28:30 +01:00
|
|
|
config_line_append((config_line_t**)lvalue, c->key, c->value);
|
|
|
|
return 0;
|
|
|
|
} else {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2006-03-26 10:09:19 +02:00
|
|
|
"Unknown option '%s'. Failing.", c->key);
|
2006-02-12 23:28:30 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2005-09-10 04:42:32 +02:00
|
|
|
}
|
Warn when encounter the same (non-list) option twice in the same place
It's okay to get (say) a SocksPort line in the torrc, and then a
SocksPort on the command line to override it, and then a SocksPort via
a controller to override *that*. But if there are two occurrences of
SocksPort in the torrc, or on the command line, or in a single SETCONF
command, then the user is likely confused. Our old code would not
help unconfuse the user, but would instead silently ignore all but
the last occurrence.
This patch changes the behavior so that if the some option is passed
more than once to any torrc, command line, or SETCONF (each of which
coincidentally corresponds to a call to config_assign()), and the
option is not a type that allows multiple occurrences (LINELIST or
LINELIST_X), then we can warn the user.
This closes trac entry 1384.
2010-07-31 19:16:48 +02:00
|
|
|
|
2005-09-10 04:42:32 +02:00
|
|
|
/* Put keyword into canonical case. */
|
|
|
|
if (strcmp(var->name, c->key)) {
|
|
|
|
tor_free(c->key);
|
|
|
|
c->key = tor_strdup(var->name);
|
|
|
|
}
|
|
|
|
|
2006-03-11 19:40:33 +01:00
|
|
|
if (!strlen(c->value)) {
|
|
|
|
/* reset or clear it, then return */
|
|
|
|
if (!clear_first) {
|
|
|
|
if (var->type == CONFIG_TYPE_LINELIST ||
|
|
|
|
var->type == CONFIG_TYPE_LINELIST_S) {
|
2009-05-27 23:55:51 +02:00
|
|
|
/* We got an empty linelist from the torrc or command line.
|
2006-03-11 19:40:33 +01:00
|
|
|
As a special case, call this an error. Warn and ignore. */
|
|
|
|
log_warn(LD_CONFIG,
|
|
|
|
"Linelist option '%s' has no value. Skipping.", c->key);
|
|
|
|
} else { /* not already cleared */
|
|
|
|
option_reset(fmt, options, var, use_defaults);
|
|
|
|
}
|
|
|
|
}
|
2005-09-10 04:42:32 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Warn when encounter the same (non-list) option twice in the same place
It's okay to get (say) a SocksPort line in the torrc, and then a
SocksPort on the command line to override it, and then a SocksPort via
a controller to override *that*. But if there are two occurrences of
SocksPort in the torrc, or on the command line, or in a single SETCONF
command, then the user is likely confused. Our old code would not
help unconfuse the user, but would instead silently ignore all but
the last occurrence.
This patch changes the behavior so that if the some option is passed
more than once to any torrc, command line, or SETCONF (each of which
coincidentally corresponds to a call to config_assign()), and the
option is not a type that allows multiple occurrences (LINELIST or
LINELIST_X), then we can warn the user.
This closes trac entry 1384.
2010-07-31 19:16:48 +02:00
|
|
|
if (options_seen && (var->type != CONFIG_TYPE_LINELIST &&
|
|
|
|
var->type != CONFIG_TYPE_LINELIST_S)) {
|
|
|
|
/* We're tracking which options we've seen, and this option is not
|
|
|
|
* supposed to occur more than once. */
|
2010-08-02 18:44:00 +02:00
|
|
|
int var_index = (int)(var - fmt->vars);
|
Warn when encounter the same (non-list) option twice in the same place
It's okay to get (say) a SocksPort line in the torrc, and then a
SocksPort on the command line to override it, and then a SocksPort via
a controller to override *that*. But if there are two occurrences of
SocksPort in the torrc, or on the command line, or in a single SETCONF
command, then the user is likely confused. Our old code would not
help unconfuse the user, but would instead silently ignore all but
the last occurrence.
This patch changes the behavior so that if the some option is passed
more than once to any torrc, command line, or SETCONF (each of which
coincidentally corresponds to a call to config_assign()), and the
option is not a type that allows multiple occurrences (LINELIST or
LINELIST_X), then we can warn the user.
This closes trac entry 1384.
2010-07-31 19:16:48 +02:00
|
|
|
if (bitarray_is_set(options_seen, var_index)) {
|
|
|
|
log_warn(LD_CONFIG, "Option '%s' used more than once; all but the last "
|
|
|
|
"value will be ignored.", var->name);
|
|
|
|
}
|
|
|
|
bitarray_set(options_seen, var_index);
|
|
|
|
}
|
|
|
|
|
2006-03-26 10:09:19 +02:00
|
|
|
if (config_assign_value(fmt, options, c, msg) < 0)
|
2005-09-10 04:42:32 +02:00
|
|
|
return -2;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-09-14 04:07:35 +02:00
|
|
|
/** Restore the option named <b>key</b> in options to its default value.
|
|
|
|
* Called from config_assign(). */
|
2004-11-04 23:31:50 +01:00
|
|
|
static void
|
2005-09-14 04:07:35 +02:00
|
|
|
config_reset_line(config_format_t *fmt, or_options_t *options,
|
|
|
|
const char *key, int use_defaults)
|
2004-11-04 23:31:50 +01:00
|
|
|
{
|
|
|
|
config_var_t *var;
|
|
|
|
|
2005-07-22 22:37:42 +02:00
|
|
|
CHECK(fmt, options);
|
|
|
|
|
|
|
|
var = config_find_option(fmt, key);
|
2004-11-04 23:31:50 +01:00
|
|
|
if (!var)
|
|
|
|
return; /* give error on next pass. */
|
|
|
|
|
2005-09-14 04:07:35 +02:00
|
|
|
option_reset(fmt, options, var, use_defaults);
|
2004-11-04 23:31:50 +01:00
|
|
|
}
|
|
|
|
|
2004-11-09 07:40:32 +01:00
|
|
|
/** Return true iff key is a valid configuration option. */
|
|
|
|
int
|
2005-07-23 03:58:05 +02:00
|
|
|
option_is_recognized(const char *key)
|
2004-11-09 07:40:32 +01:00
|
|
|
{
|
2005-08-04 21:56:41 +02:00
|
|
|
config_var_t *var = config_find_option(&options_format, key);
|
2004-11-09 07:40:32 +01:00
|
|
|
return (var != NULL);
|
|
|
|
}
|
|
|
|
|
2008-01-15 06:57:14 +01:00
|
|
|
/** Return the canonical name of a configuration option, or NULL
|
|
|
|
* if no such option exists. */
|
2005-07-11 19:35:36 +02:00
|
|
|
const char *
|
2005-07-23 03:58:05 +02:00
|
|
|
option_get_canonical_name(const char *key)
|
2005-07-11 19:35:36 +02:00
|
|
|
{
|
2005-08-04 21:56:41 +02:00
|
|
|
config_var_t *var = config_find_option(&options_format, key);
|
2008-01-15 06:57:14 +01:00
|
|
|
return var ? var->name : NULL;
|
2005-07-11 19:35:36 +02:00
|
|
|
}
|
|
|
|
|
2009-05-27 23:55:51 +02:00
|
|
|
/** Return a canonical list of the options assigned for key.
|
2004-11-03 19:29:29 +01:00
|
|
|
*/
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *
|
2005-07-23 03:58:05 +02:00
|
|
|
option_get_assignment(or_options_t *options, const char *key)
|
2005-07-22 22:37:42 +02:00
|
|
|
{
|
2008-01-07 19:54:55 +01:00
|
|
|
return get_assigned_option(&options_format, options, key, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Return true iff value needs to be quoted and escaped to be used in
|
|
|
|
* a configuration file. */
|
|
|
|
static int
|
|
|
|
config_value_needs_escape(const char *value)
|
|
|
|
{
|
|
|
|
if (*value == '\"')
|
|
|
|
return 1;
|
|
|
|
while (*value) {
|
|
|
|
switch (*value)
|
|
|
|
{
|
|
|
|
case '\r':
|
|
|
|
case '\n':
|
|
|
|
case '#':
|
|
|
|
/* Note: quotes and backspaces need special handling when we are using
|
|
|
|
* quotes, not otherwise, so they don't trigger escaping on their
|
|
|
|
* own. */
|
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
if (!TOR_ISPRINT(*value))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
++value;
|
|
|
|
}
|
|
|
|
return 0;
|
2005-07-22 22:37:42 +02:00
|
|
|
}
|
|
|
|
|
2007-02-16 19:12:47 +01:00
|
|
|
/** Return a newly allocated deep copy of the lines in <b>inp</b>. */
|
2005-08-25 22:33:17 +02:00
|
|
|
static config_line_t *
|
|
|
|
config_lines_dup(const config_line_t *inp)
|
|
|
|
{
|
|
|
|
config_line_t *result = NULL;
|
|
|
|
config_line_t **next_out = &result;
|
|
|
|
while (inp) {
|
|
|
|
*next_out = tor_malloc(sizeof(config_line_t));
|
|
|
|
(*next_out)->key = tor_strdup(inp->key);
|
|
|
|
(*next_out)->value = tor_strdup(inp->value);
|
|
|
|
inp = inp->next;
|
|
|
|
next_out = &((*next_out)->next);
|
|
|
|
}
|
|
|
|
(*next_out) = NULL;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2007-02-16 19:12:47 +01:00
|
|
|
/** Return newly allocated line or lines corresponding to <b>key</b> in the
|
2008-01-07 19:54:55 +01:00
|
|
|
* configuration <b>options</b>. If <b>escape_val</b> is true and a
|
|
|
|
* value needs to be quoted before it's put in a config file, quote and
|
|
|
|
* escape that value. Return NULL if no such key exists. */
|
2005-07-22 23:12:10 +02:00
|
|
|
static config_line_t *
|
2008-12-29 21:17:24 +01:00
|
|
|
get_assigned_option(config_format_t *fmt, void *options,
|
2008-01-07 19:54:55 +01:00
|
|
|
const char *key, int escape_val)
|
2004-11-03 19:29:29 +01:00
|
|
|
{
|
|
|
|
config_var_t *var;
|
|
|
|
const void *value;
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *result;
|
2004-11-09 07:40:32 +01:00
|
|
|
tor_assert(options && key);
|
2004-11-03 19:29:29 +01:00
|
|
|
|
2005-07-22 22:37:42 +02:00
|
|
|
CHECK(fmt, options);
|
|
|
|
|
|
|
|
var = config_find_option(fmt, key);
|
2004-11-03 19:29:29 +01:00
|
|
|
if (!var) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG, "Unknown option '%s'. Failing.", key);
|
2004-11-03 19:29:29 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2006-02-12 23:28:30 +01:00
|
|
|
value = STRUCT_VAR_P(options, var->var_offset);
|
2004-11-03 19:29:29 +01:00
|
|
|
|
2005-07-22 23:12:10 +02:00
|
|
|
result = tor_malloc_zero(sizeof(config_line_t));
|
2004-11-03 19:29:29 +01:00
|
|
|
result->key = tor_strdup(var->name);
|
2004-11-28 10:05:49 +01:00
|
|
|
switch (var->type)
|
2004-11-03 19:29:29 +01:00
|
|
|
{
|
|
|
|
case CONFIG_TYPE_STRING:
|
2008-06-16 20:09:53 +02:00
|
|
|
case CONFIG_TYPE_FILENAME:
|
2004-11-09 07:40:32 +01:00
|
|
|
if (*(char**)value) {
|
|
|
|
result->value = tor_strdup(*(char**)value);
|
|
|
|
} else {
|
|
|
|
tor_free(result->key);
|
|
|
|
tor_free(result);
|
|
|
|
return NULL;
|
|
|
|
}
|
2004-11-03 19:29:29 +01:00
|
|
|
break;
|
2005-07-28 21:01:48 +02:00
|
|
|
case CONFIG_TYPE_ISOTIME:
|
|
|
|
if (*(time_t*)value) {
|
|
|
|
result->value = tor_malloc(ISO_TIME_LEN+1);
|
|
|
|
format_iso_time(result->value, *(time_t*)value);
|
|
|
|
} else {
|
|
|
|
tor_free(result->key);
|
|
|
|
tor_free(result);
|
|
|
|
}
|
2008-01-07 19:54:55 +01:00
|
|
|
escape_val = 0; /* Can't need escape. */
|
2005-07-28 21:01:48 +02:00
|
|
|
break;
|
2011-05-02 21:05:10 +02:00
|
|
|
case CONFIG_TYPE_PORT:
|
|
|
|
if (*(int*)value == CFG_AUTO_PORT) {
|
|
|
|
result->value = tor_strdup("auto");
|
|
|
|
escape_val = 0;
|
|
|
|
break;
|
|
|
|
}
|
2011-05-30 21:31:06 +02:00
|
|
|
/* fall through */
|
2004-11-20 01:37:00 +01:00
|
|
|
case CONFIG_TYPE_INTERVAL:
|
2010-08-27 08:13:54 +02:00
|
|
|
case CONFIG_TYPE_MSEC_INTERVAL:
|
2004-11-03 19:29:29 +01:00
|
|
|
case CONFIG_TYPE_UINT:
|
2004-11-09 19:22:17 +01:00
|
|
|
/* This means every or_options_t uint or bool element
|
2004-11-06 06:18:11 +01:00
|
|
|
* needs to be an int. Not, say, a uint16_t or char. */
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(&result->value, "%d", *(int*)value);
|
2008-01-07 19:54:55 +01:00
|
|
|
escape_val = 0; /* Can't need escape. */
|
2004-11-03 19:29:29 +01:00
|
|
|
break;
|
2004-11-20 01:37:00 +01:00
|
|
|
case CONFIG_TYPE_MEMUNIT:
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(&result->value, U64_FORMAT,
|
2004-11-20 01:37:00 +01:00
|
|
|
U64_PRINTF_ARG(*(uint64_t*)value));
|
2008-01-07 19:54:55 +01:00
|
|
|
escape_val = 0; /* Can't need escape. */
|
2004-11-20 01:37:00 +01:00
|
|
|
break;
|
2004-11-03 19:29:29 +01:00
|
|
|
case CONFIG_TYPE_DOUBLE:
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(&result->value, "%f", *(double*)value);
|
2008-01-07 19:54:55 +01:00
|
|
|
escape_val = 0; /* Can't need escape. */
|
2004-11-03 19:29:29 +01:00
|
|
|
break;
|
2010-11-08 19:34:40 +01:00
|
|
|
|
|
|
|
case CONFIG_TYPE_AUTOBOOL:
|
|
|
|
if (*(int*)value == -1) {
|
|
|
|
result->value = tor_strdup("auto");
|
|
|
|
escape_val = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fall through */
|
2004-11-03 19:29:29 +01:00
|
|
|
case CONFIG_TYPE_BOOL:
|
|
|
|
result->value = tor_strdup(*(int*)value ? "1" : "0");
|
2008-01-07 19:54:55 +01:00
|
|
|
escape_val = 0; /* Can't need escape. */
|
2004-11-03 19:29:29 +01:00
|
|
|
break;
|
2008-07-18 20:36:32 +02:00
|
|
|
case CONFIG_TYPE_ROUTERSET:
|
|
|
|
result->value = routerset_to_string(*(routerset_t**)value);
|
|
|
|
break;
|
2004-11-03 19:29:29 +01:00
|
|
|
case CONFIG_TYPE_CSV:
|
2004-11-09 06:59:22 +01:00
|
|
|
if (*(smartlist_t**)value)
|
2005-12-14 21:40:40 +01:00
|
|
|
result->value =
|
|
|
|
smartlist_join_strings(*(smartlist_t**)value, ",", 0, NULL);
|
2004-11-03 19:29:29 +01:00
|
|
|
else
|
|
|
|
result->value = tor_strdup("");
|
|
|
|
break;
|
2004-11-09 07:18:17 +01:00
|
|
|
case CONFIG_TYPE_OBSOLETE:
|
2008-11-07 05:38:58 +01:00
|
|
|
log_fn(LOG_PROTOCOL_WARN, LD_CONFIG,
|
|
|
|
"You asked me for the value of an obsolete config option '%s'.",
|
|
|
|
key);
|
2004-11-09 07:18:17 +01:00
|
|
|
tor_free(result->key);
|
|
|
|
tor_free(result);
|
|
|
|
return NULL;
|
2006-08-11 09:09:17 +02:00
|
|
|
case CONFIG_TYPE_LINELIST_S:
|
|
|
|
log_warn(LD_CONFIG,
|
|
|
|
"Can't return context-sensitive '%s' on its own", key);
|
|
|
|
tor_free(result->key);
|
|
|
|
tor_free(result);
|
|
|
|
return NULL;
|
|
|
|
case CONFIG_TYPE_LINELIST:
|
|
|
|
case CONFIG_TYPE_LINELIST_V:
|
|
|
|
tor_free(result->key);
|
|
|
|
tor_free(result);
|
2008-01-07 19:54:55 +01:00
|
|
|
result = config_lines_dup(*(const config_line_t**)value);
|
|
|
|
break;
|
2004-11-03 19:29:29 +01:00
|
|
|
default:
|
|
|
|
tor_free(result->key);
|
|
|
|
tor_free(result);
|
2007-03-04 21:11:46 +01:00
|
|
|
log_warn(LD_BUG,"Unknown type %d for known key '%s'",
|
2006-02-13 10:02:35 +01:00
|
|
|
var->type, key);
|
2004-11-03 19:29:29 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-01-07 19:54:55 +01:00
|
|
|
if (escape_val) {
|
|
|
|
config_line_t *line;
|
|
|
|
for (line = result; line; line = line->next) {
|
|
|
|
if (line->value && config_value_needs_escape(line->value)) {
|
|
|
|
char *newval = esc_for_log(line->value);
|
|
|
|
tor_free(line->value);
|
|
|
|
line->value = newval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-11-03 19:29:29 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2004-11-04 09:26:34 +01:00
|
|
|
/** Iterate through the linked list of requested options <b>list</b>.
|
2004-05-10 06:48:13 +02:00
|
|
|
* For each item, convert as appropriate and assign to <b>options</b>.
|
2006-03-26 10:09:19 +02:00
|
|
|
* If an item is unrecognized, set *msg and return -1 immediately,
|
2004-11-04 23:31:50 +01:00
|
|
|
* else return 0 for success.
|
|
|
|
*
|
2005-09-14 04:07:35 +02:00
|
|
|
* If <b>clear_first</b>, interpret config options as replacing (not
|
|
|
|
* extending) their previous values. If <b>clear_first</b> is set,
|
|
|
|
* then <b>use_defaults</b> to decide if you set to defaults after
|
|
|
|
* clearing, or make the value 0 or NULL.
|
|
|
|
*
|
|
|
|
* Here are the use cases:
|
2006-03-19 02:21:59 +01:00
|
|
|
* 1. A non-empty AllowInvalid line in your torrc. Appends to current
|
2005-09-14 04:12:29 +02:00
|
|
|
* if linelist, replaces current if csv.
|
2006-03-19 02:21:59 +01:00
|
|
|
* 2. An empty AllowInvalid line in your torrc. Should clear it.
|
|
|
|
* 3. "RESETCONF AllowInvalid" sets it to default.
|
|
|
|
* 4. "SETCONF AllowInvalid" makes it NULL.
|
|
|
|
* 5. "SETCONF AllowInvalid=foo" clears it and sets it to "foo".
|
2005-09-08 08:55:53 +02:00
|
|
|
*
|
2005-09-14 04:07:35 +02:00
|
|
|
* Use_defaults Clear_first
|
|
|
|
* 0 0 "append"
|
|
|
|
* 1 0 undefined, don't use
|
|
|
|
* 0 1 "set to null first"
|
|
|
|
* 1 1 "set to defaults first"
|
2005-09-08 08:55:53 +02:00
|
|
|
* Return 0 on success, -1 on bad key, -2 on bad value.
|
2006-03-11 19:40:33 +01:00
|
|
|
*
|
|
|
|
* As an additional special case, if a LINELIST config option has
|
|
|
|
* no value and clear_first is 0, then warn and ignore it.
|
2004-11-04 23:31:50 +01:00
|
|
|
*/
|
2005-09-14 04:07:35 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
There are three call cases for config_assign() currently.
|
|
|
|
|
|
|
|
Case one: Torrc entry
|
|
|
|
options_init_from_torrc() calls config_assign(0, 0)
|
2005-09-14 04:35:06 +02:00
|
|
|
calls config_assign_line(0, 0).
|
2005-09-14 04:07:35 +02:00
|
|
|
if value is empty, calls option_reset(0) and returns.
|
|
|
|
calls config_assign_value(), appends.
|
|
|
|
|
|
|
|
Case two: setconf
|
|
|
|
options_trial_assign() calls config_assign(0, 1)
|
|
|
|
calls config_reset_line(0)
|
|
|
|
calls option_reset(0)
|
|
|
|
calls option_clear().
|
2005-09-14 04:35:06 +02:00
|
|
|
calls config_assign_line(0, 1).
|
|
|
|
if value is empty, returns.
|
2005-09-14 04:07:35 +02:00
|
|
|
calls config_assign_value(), appends.
|
|
|
|
|
|
|
|
Case three: resetconf
|
|
|
|
options_trial_assign() calls config_assign(1, 1)
|
|
|
|
calls config_reset_line(1)
|
|
|
|
calls option_reset(1)
|
|
|
|
calls option_clear().
|
|
|
|
calls config_assign_value(default)
|
2005-09-14 04:35:06 +02:00
|
|
|
calls config_assign_line(1, 1).
|
|
|
|
returns.
|
2005-09-14 04:07:35 +02:00
|
|
|
*/
|
2004-10-14 04:47:09 +02:00
|
|
|
static int
|
2006-03-26 10:09:19 +02:00
|
|
|
config_assign(config_format_t *fmt, void *options, config_line_t *list,
|
|
|
|
int use_defaults, int clear_first, char **msg)
|
2004-10-14 04:47:09 +02:00
|
|
|
{
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *p;
|
Warn when encounter the same (non-list) option twice in the same place
It's okay to get (say) a SocksPort line in the torrc, and then a
SocksPort on the command line to override it, and then a SocksPort via
a controller to override *that*. But if there are two occurrences of
SocksPort in the torrc, or on the command line, or in a single SETCONF
command, then the user is likely confused. Our old code would not
help unconfuse the user, but would instead silently ignore all but
the last occurrence.
This patch changes the behavior so that if the some option is passed
more than once to any torrc, command line, or SETCONF (each of which
coincidentally corresponds to a call to config_assign()), and the
option is not a type that allows multiple occurrences (LINELIST or
LINELIST_X), then we can warn the user.
This closes trac entry 1384.
2010-07-31 19:16:48 +02:00
|
|
|
bitarray_t *options_seen;
|
|
|
|
const int n_options = config_count_options(fmt);
|
2005-07-22 22:37:42 +02:00
|
|
|
|
|
|
|
CHECK(fmt, options);
|
2004-11-04 23:31:50 +01:00
|
|
|
|
|
|
|
/* pass 1: normalize keys */
|
|
|
|
for (p = list; p; p = p->next) {
|
2005-10-17 05:06:00 +02:00
|
|
|
const char *full = expand_abbrev(fmt, p->key, 0, 1);
|
2004-11-04 23:31:50 +01:00
|
|
|
if (strcmp(full,p->key)) {
|
|
|
|
tor_free(p->key);
|
|
|
|
p->key = tor_strdup(full);
|
2004-10-27 19:37:01 +02:00
|
|
|
}
|
2004-11-04 23:31:50 +01:00
|
|
|
}
|
|
|
|
|
2005-09-14 04:07:35 +02:00
|
|
|
/* pass 2: if we're reading from a resetting source, clear all
|
|
|
|
* mentioned config options, and maybe set to their defaults. */
|
|
|
|
if (clear_first) {
|
2004-11-04 23:31:50 +01:00
|
|
|
for (p = list; p; p = p->next)
|
2005-09-14 04:07:35 +02:00
|
|
|
config_reset_line(fmt, options, p->key, use_defaults);
|
2004-11-04 23:31:50 +01:00
|
|
|
}
|
2004-10-27 19:37:01 +02:00
|
|
|
|
Warn when encounter the same (non-list) option twice in the same place
It's okay to get (say) a SocksPort line in the torrc, and then a
SocksPort on the command line to override it, and then a SocksPort via
a controller to override *that*. But if there are two occurrences of
SocksPort in the torrc, or on the command line, or in a single SETCONF
command, then the user is likely confused. Our old code would not
help unconfuse the user, but would instead silently ignore all but
the last occurrence.
This patch changes the behavior so that if the some option is passed
more than once to any torrc, command line, or SETCONF (each of which
coincidentally corresponds to a call to config_assign()), and the
option is not a type that allows multiple occurrences (LINELIST or
LINELIST_X), then we can warn the user.
This closes trac entry 1384.
2010-07-31 19:16:48 +02:00
|
|
|
options_seen = bitarray_init_zero(n_options);
|
2004-11-04 23:31:50 +01:00
|
|
|
/* pass 3: assign. */
|
|
|
|
while (list) {
|
2004-11-07 23:59:30 +01:00
|
|
|
int r;
|
2006-03-26 10:09:19 +02:00
|
|
|
if ((r=config_assign_line(fmt, options, list, use_defaults,
|
Warn when encounter the same (non-list) option twice in the same place
It's okay to get (say) a SocksPort line in the torrc, and then a
SocksPort on the command line to override it, and then a SocksPort via
a controller to override *that*. But if there are two occurrences of
SocksPort in the torrc, or on the command line, or in a single SETCONF
command, then the user is likely confused. Our old code would not
help unconfuse the user, but would instead silently ignore all but
the last occurrence.
This patch changes the behavior so that if the some option is passed
more than once to any torrc, command line, or SETCONF (each of which
coincidentally corresponds to a call to config_assign()), and the
option is not a type that allows multiple occurrences (LINELIST or
LINELIST_X), then we can warn the user.
This closes trac entry 1384.
2010-07-31 19:16:48 +02:00
|
|
|
clear_first, options_seen, msg))) {
|
|
|
|
bitarray_free(options_seen);
|
2004-11-07 23:59:30 +01:00
|
|
|
return r;
|
Warn when encounter the same (non-list) option twice in the same place
It's okay to get (say) a SocksPort line in the torrc, and then a
SocksPort on the command line to override it, and then a SocksPort via
a controller to override *that*. But if there are two occurrences of
SocksPort in the torrc, or on the command line, or in a single SETCONF
command, then the user is likely confused. Our old code would not
help unconfuse the user, but would instead silently ignore all but
the last occurrence.
This patch changes the behavior so that if the some option is passed
more than once to any torrc, command line, or SETCONF (each of which
coincidentally corresponds to a call to config_assign()), and the
option is not a type that allows multiple occurrences (LINELIST or
LINELIST_X), then we can warn the user.
This closes trac entry 1384.
2010-07-31 19:16:48 +02:00
|
|
|
}
|
2002-11-23 07:49:01 +01:00
|
|
|
list = list->next;
|
2003-12-17 22:09:31 +01:00
|
|
|
}
|
Warn when encounter the same (non-list) option twice in the same place
It's okay to get (say) a SocksPort line in the torrc, and then a
SocksPort on the command line to override it, and then a SocksPort via
a controller to override *that*. But if there are two occurrences of
SocksPort in the torrc, or on the command line, or in a single SETCONF
command, then the user is likely confused. Our old code would not
help unconfuse the user, but would instead silently ignore all but
the last occurrence.
This patch changes the behavior so that if the some option is passed
more than once to any torrc, command line, or SETCONF (each of which
coincidentally corresponds to a call to config_assign()), and the
option is not a type that allows multiple occurrences (LINELIST or
LINELIST_X), then we can warn the user.
This closes trac entry 1384.
2010-07-31 19:16:48 +02:00
|
|
|
bitarray_free(options_seen);
|
2004-03-02 06:00:50 +01:00
|
|
|
return 0;
|
2002-11-23 07:49:01 +01:00
|
|
|
}
|
|
|
|
|
2004-11-09 18:15:17 +01:00
|
|
|
/** Try assigning <b>list</b> to the global options. You do this by duping
|
2004-11-06 06:18:11 +01:00
|
|
|
* options, assigning list to the new one, then validating it. If it's
|
2004-11-10 01:11:37 +01:00
|
|
|
* ok, then throw out the old one and stick with the new one. Else,
|
2008-03-13 16:11:56 +01:00
|
|
|
* revert to old and return failure. Return SETOPT_OK on success, or
|
|
|
|
* a setopt_err_t on failure.
|
2006-04-08 07:43:52 +02:00
|
|
|
*
|
2006-03-26 08:51:26 +02:00
|
|
|
* If not success, point *<b>msg</b> to a newly allocated string describing
|
|
|
|
* what went wrong.
|
2004-11-06 06:18:11 +01:00
|
|
|
*/
|
2008-03-13 16:11:56 +01:00
|
|
|
setopt_err_t
|
2006-03-26 08:51:26 +02:00
|
|
|
options_trial_assign(config_line_t *list, int use_defaults,
|
|
|
|
int clear_first, char **msg)
|
2004-11-06 06:18:11 +01:00
|
|
|
{
|
2004-11-07 23:59:30 +01:00
|
|
|
int r;
|
2005-08-04 21:56:41 +02:00
|
|
|
or_options_t *trial_options = options_dup(&options_format, get_options());
|
2004-11-06 06:18:11 +01:00
|
|
|
|
2005-09-14 04:07:35 +02:00
|
|
|
if ((r=config_assign(&options_format, trial_options,
|
2006-03-26 10:09:19 +02:00
|
|
|
list, use_defaults, clear_first, msg)) < 0) {
|
2005-08-04 21:56:41 +02:00
|
|
|
config_free(&options_format, trial_options);
|
2004-11-07 23:59:30 +01:00
|
|
|
return r;
|
2004-11-06 06:18:11 +01:00
|
|
|
}
|
|
|
|
|
2006-03-26 08:51:26 +02:00
|
|
|
if (options_validate(get_options(), trial_options, 1, msg) < 0) {
|
2005-08-04 21:56:41 +02:00
|
|
|
config_free(&options_format, trial_options);
|
2008-12-18 17:11:24 +01:00
|
|
|
return SETOPT_ERR_PARSE; /*XXX make this a separate return value. */
|
2004-11-06 06:18:11 +01:00
|
|
|
}
|
|
|
|
|
2006-03-26 08:51:26 +02:00
|
|
|
if (options_transition_allowed(get_options(), trial_options, msg) < 0) {
|
2005-08-04 21:56:41 +02:00
|
|
|
config_free(&options_format, trial_options);
|
2008-03-13 16:11:56 +01:00
|
|
|
return SETOPT_ERR_TRANSITION;
|
2004-11-06 06:18:11 +01:00
|
|
|
}
|
|
|
|
|
2006-03-26 08:51:26 +02:00
|
|
|
if (set_options(trial_options, msg)<0) {
|
2005-09-14 04:36:29 +02:00
|
|
|
config_free(&options_format, trial_options);
|
2008-03-13 16:11:56 +01:00
|
|
|
return SETOPT_ERR_SETTING;
|
2005-09-14 04:36:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* we liked it. put it in place. */
|
2008-03-13 16:11:56 +01:00
|
|
|
return SETOPT_OK;
|
2004-11-06 06:18:11 +01:00
|
|
|
}
|
|
|
|
|
2005-09-14 04:07:35 +02:00
|
|
|
/** Reset config option <b>var</b> to 0, 0.0, NULL, or the equivalent.
|
|
|
|
* Called from option_reset() and config_free(). */
|
2004-11-06 06:18:11 +01:00
|
|
|
static void
|
2005-09-08 08:55:53 +02:00
|
|
|
option_clear(config_format_t *fmt, or_options_t *options, config_var_t *var)
|
2004-11-06 06:18:11 +01:00
|
|
|
{
|
2006-02-12 23:28:30 +01:00
|
|
|
void *lvalue = STRUCT_VAR_P(options, var->var_offset);
|
2006-06-05 00:42:13 +02:00
|
|
|
(void)fmt; /* unused */
|
2004-11-06 06:18:11 +01:00
|
|
|
switch (var->type) {
|
|
|
|
case CONFIG_TYPE_STRING:
|
2008-06-16 20:09:53 +02:00
|
|
|
case CONFIG_TYPE_FILENAME:
|
2004-11-06 06:18:11 +01:00
|
|
|
tor_free(*(char**)lvalue);
|
|
|
|
break;
|
|
|
|
case CONFIG_TYPE_DOUBLE:
|
|
|
|
*(double*)lvalue = 0.0;
|
|
|
|
break;
|
2005-07-28 21:01:48 +02:00
|
|
|
case CONFIG_TYPE_ISOTIME:
|
|
|
|
*(time_t*)lvalue = 0;
|
2009-10-27 02:35:26 +01:00
|
|
|
break;
|
2004-11-20 01:37:00 +01:00
|
|
|
case CONFIG_TYPE_INTERVAL:
|
2010-08-27 08:13:54 +02:00
|
|
|
case CONFIG_TYPE_MSEC_INTERVAL:
|
2004-11-06 06:18:11 +01:00
|
|
|
case CONFIG_TYPE_UINT:
|
2011-05-02 21:05:10 +02:00
|
|
|
case CONFIG_TYPE_PORT:
|
2004-11-06 06:18:11 +01:00
|
|
|
case CONFIG_TYPE_BOOL:
|
|
|
|
*(int*)lvalue = 0;
|
|
|
|
break;
|
2010-11-08 19:34:40 +01:00
|
|
|
case CONFIG_TYPE_AUTOBOOL:
|
|
|
|
*(int*)lvalue = -1;
|
|
|
|
break;
|
2004-11-20 01:37:00 +01:00
|
|
|
case CONFIG_TYPE_MEMUNIT:
|
|
|
|
*(uint64_t*)lvalue = 0;
|
|
|
|
break;
|
2008-07-18 20:36:32 +02:00
|
|
|
case CONFIG_TYPE_ROUTERSET:
|
|
|
|
if (*(routerset_t**)lvalue) {
|
|
|
|
routerset_free(*(routerset_t**)lvalue);
|
|
|
|
*(routerset_t**)lvalue = NULL;
|
|
|
|
}
|
2009-10-27 02:35:26 +01:00
|
|
|
break;
|
2004-11-06 06:18:11 +01:00
|
|
|
case CONFIG_TYPE_CSV:
|
|
|
|
if (*(smartlist_t**)lvalue) {
|
|
|
|
SMARTLIST_FOREACH(*(smartlist_t **)lvalue, char *, cp, tor_free(cp));
|
|
|
|
smartlist_free(*(smartlist_t **)lvalue);
|
|
|
|
*(smartlist_t **)lvalue = NULL;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CONFIG_TYPE_LINELIST:
|
|
|
|
case CONFIG_TYPE_LINELIST_S:
|
2005-07-22 23:12:10 +02:00
|
|
|
config_free_lines(*(config_line_t **)lvalue);
|
|
|
|
*(config_line_t **)lvalue = NULL;
|
2004-11-06 06:18:11 +01:00
|
|
|
break;
|
|
|
|
case CONFIG_TYPE_LINELIST_V:
|
|
|
|
/* handled by linelist_s. */
|
|
|
|
break;
|
|
|
|
case CONFIG_TYPE_OBSOLETE:
|
|
|
|
break;
|
|
|
|
}
|
2005-09-08 08:59:58 +02:00
|
|
|
}
|
2005-09-08 08:55:53 +02:00
|
|
|
|
2005-09-14 04:07:35 +02:00
|
|
|
/** Clear the option indexed by <b>var</b> in <b>options</b>. Then if
|
|
|
|
* <b>use_defaults</b>, set it to its default value.
|
|
|
|
* Called by config_init() and option_reset_line() and option_assign_line(). */
|
2005-09-08 08:55:53 +02:00
|
|
|
static void
|
2005-09-14 04:07:35 +02:00
|
|
|
option_reset(config_format_t *fmt, or_options_t *options,
|
|
|
|
config_var_t *var, int use_defaults)
|
2005-09-08 08:55:53 +02:00
|
|
|
{
|
|
|
|
config_line_t *c;
|
2006-03-26 10:09:19 +02:00
|
|
|
char *msg = NULL;
|
2005-09-08 08:55:53 +02:00
|
|
|
CHECK(fmt, options);
|
|
|
|
option_clear(fmt, options, var); /* clear it first */
|
2005-09-14 04:07:35 +02:00
|
|
|
if (!use_defaults)
|
|
|
|
return; /* all done */
|
2004-11-06 06:18:11 +01:00
|
|
|
if (var->initvalue) {
|
2005-07-22 23:12:10 +02:00
|
|
|
c = tor_malloc_zero(sizeof(config_line_t));
|
2004-11-06 06:18:11 +01:00
|
|
|
c->key = tor_strdup(var->name);
|
|
|
|
c->value = tor_strdup(var->initvalue);
|
2006-03-26 10:09:19 +02:00
|
|
|
if (config_assign_value(fmt, options, c, &msg) < 0) {
|
|
|
|
log_warn(LD_BUG, "Failed to assign default: %s", msg);
|
|
|
|
tor_free(msg); /* if this happens it's a bug */
|
|
|
|
}
|
2004-11-06 06:18:11 +01:00
|
|
|
config_free_lines(c);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-05-10 06:48:13 +02:00
|
|
|
/** Print a usage message for tor. */
|
2004-10-14 04:47:09 +02:00
|
|
|
static void
|
|
|
|
print_usage(void)
|
|
|
|
{
|
2004-11-15 08:29:27 +01:00
|
|
|
printf(
|
2008-02-04 17:54:14 +01:00
|
|
|
"Copyright (c) 2001-2004, Roger Dingledine\n"
|
|
|
|
"Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson\n"
|
2011-01-03 17:50:39 +01:00
|
|
|
"Copyright (c) 2007-2011, The Tor Project, Inc.\n\n"
|
2004-11-15 08:29:27 +01:00
|
|
|
"tor -f <torrc> [args]\n"
|
2007-12-07 22:27:58 +01:00
|
|
|
"See man page for options, or https://www.torproject.org/ for "
|
|
|
|
"documentation.\n");
|
2003-10-20 03:19:54 +02:00
|
|
|
}
|
|
|
|
|
2006-12-20 18:05:48 +01:00
|
|
|
/** Print all non-obsolete torrc options. */
|
|
|
|
static void
|
|
|
|
list_torrc_options(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
smartlist_t *lines = smartlist_create();
|
|
|
|
for (i = 0; _option_vars[i].name; ++i) {
|
|
|
|
config_var_t *var = &_option_vars[i];
|
|
|
|
if (var->type == CONFIG_TYPE_OBSOLETE ||
|
|
|
|
var->type == CONFIG_TYPE_LINELIST_V)
|
|
|
|
continue;
|
|
|
|
printf("%s\n", var->name);
|
|
|
|
}
|
2008-01-16 06:27:19 +01:00
|
|
|
smartlist_free(lines);
|
2006-12-20 18:05:48 +01:00
|
|
|
}
|
|
|
|
|
2006-10-02 23:00:35 +02:00
|
|
|
/** Last value actually set by resolve_my_address. */
|
|
|
|
static uint32_t last_resolved_addr = 0;
|
2004-05-10 06:48:13 +02:00
|
|
|
/**
|
2005-06-08 22:32:22 +02:00
|
|
|
* Based on <b>options-\>Address</b>, guess our public IP address and put it
|
2005-12-14 21:40:40 +01:00
|
|
|
* (in host order) into *<b>addr_out</b>. If <b>hostname_out</b> is provided,
|
|
|
|
* set *<b>hostname_out</b> to a new string holding the hostname we used to
|
|
|
|
* get the address. Return 0 if all is well, or -1 if we can't find a suitable
|
2005-08-25 22:33:17 +02:00
|
|
|
* public IP address.
|
2004-05-10 06:48:13 +02:00
|
|
|
*/
|
2004-10-14 04:47:09 +02:00
|
|
|
int
|
2006-07-15 22:26:05 +02:00
|
|
|
resolve_my_address(int warn_severity, or_options_t *options,
|
|
|
|
uint32_t *addr_out, char **hostname_out)
|
2004-10-14 04:47:09 +02:00
|
|
|
{
|
2004-03-14 19:12:59 +01:00
|
|
|
struct in_addr in;
|
2010-03-05 22:04:01 +01:00
|
|
|
uint32_t addr; /* host order */
|
2004-08-16 13:43:18 +02:00
|
|
|
char hostname[256];
|
2004-03-15 05:57:24 +01:00
|
|
|
int explicit_ip=1;
|
2006-03-14 23:51:15 +01:00
|
|
|
int explicit_hostname=1;
|
2007-01-06 06:42:31 +01:00
|
|
|
int from_interface=0;
|
2010-10-15 23:07:27 +02:00
|
|
|
char *addr_string = NULL;
|
2005-05-09 06:31:00 +02:00
|
|
|
const char *address = options->Address;
|
2006-07-15 22:26:05 +02:00
|
|
|
int notice_severity = warn_severity <= LOG_NOTICE ?
|
|
|
|
LOG_NOTICE : warn_severity;
|
2004-03-14 19:12:59 +01:00
|
|
|
|
2005-08-25 22:33:17 +02:00
|
|
|
tor_assert(addr_out);
|
2004-08-16 13:43:18 +02:00
|
|
|
|
2005-04-29 20:52:05 +02:00
|
|
|
if (address && *address) {
|
2004-10-14 04:47:09 +02:00
|
|
|
strlcpy(hostname, address, sizeof(hostname));
|
2004-08-16 13:43:18 +02:00
|
|
|
} else { /* then we need to guess our address */
|
2004-03-15 05:57:24 +01:00
|
|
|
explicit_ip = 0; /* it's implicit */
|
2006-03-14 23:51:15 +01:00
|
|
|
explicit_hostname = 0; /* it's implicit */
|
2004-03-14 19:12:59 +01:00
|
|
|
|
2004-10-14 04:47:09 +02:00
|
|
|
if (gethostname(hostname, sizeof(hostname)) < 0) {
|
2006-07-15 22:26:05 +02:00
|
|
|
log_fn(warn_severity, LD_NET,"Error obtaining local hostname");
|
2004-03-14 19:12:59 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2006-02-13 10:02:35 +01:00
|
|
|
log_debug(LD_CONFIG,"Guessed local host name as '%s'",hostname);
|
2004-03-14 19:12:59 +01:00
|
|
|
}
|
|
|
|
|
2006-07-15 22:26:05 +02:00
|
|
|
/* now we know hostname. resolve it and keep only the IP address */
|
2004-03-14 19:12:59 +01:00
|
|
|
|
2004-10-14 04:47:09 +02:00
|
|
|
if (tor_inet_aton(hostname, &in) == 0) {
|
2004-03-15 05:57:24 +01:00
|
|
|
/* then we have to resolve it */
|
|
|
|
explicit_ip = 0;
|
2010-03-05 22:04:01 +01:00
|
|
|
if (tor_lookup_hostname(hostname, &addr)) { /* failed to resolve */
|
|
|
|
uint32_t interface_ip; /* host order */
|
2006-03-14 23:51:15 +01:00
|
|
|
|
|
|
|
if (explicit_hostname) {
|
2006-07-15 22:26:05 +02:00
|
|
|
log_fn(warn_severity, LD_CONFIG,
|
|
|
|
"Could not resolve local Address '%s'. Failing.", hostname);
|
2006-03-14 23:51:15 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2006-07-15 22:26:05 +02:00
|
|
|
log_fn(notice_severity, LD_CONFIG,
|
|
|
|
"Could not resolve guessed local hostname '%s'. "
|
|
|
|
"Trying something else.", hostname);
|
2006-09-09 21:20:27 +02:00
|
|
|
if (get_interface_address(warn_severity, &interface_ip)) {
|
2006-07-15 22:26:05 +02:00
|
|
|
log_fn(warn_severity, LD_CONFIG,
|
|
|
|
"Could not get local interface IP address. Failing.");
|
2006-03-14 23:51:15 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2007-01-06 06:42:31 +01:00
|
|
|
from_interface = 1;
|
2010-10-02 03:31:09 +02:00
|
|
|
addr = interface_ip;
|
2006-07-15 22:26:05 +02:00
|
|
|
log_fn(notice_severity, LD_CONFIG, "Learned IP address '%s' for "
|
2010-10-02 03:31:09 +02:00
|
|
|
"local interface. Using that.", fmt_addr32(addr));
|
2006-03-14 23:51:15 +01:00
|
|
|
strlcpy(hostname, "<guessed from interfaces>", sizeof(hostname));
|
2010-03-05 22:04:01 +01:00
|
|
|
} else { /* resolved hostname into addr */
|
2006-03-14 23:51:15 +01:00
|
|
|
if (!explicit_hostname &&
|
2010-10-02 03:31:09 +02:00
|
|
|
is_internal_IP(addr, 0)) {
|
2006-03-14 23:51:15 +01:00
|
|
|
uint32_t interface_ip;
|
|
|
|
|
2006-07-15 22:26:05 +02:00
|
|
|
log_fn(notice_severity, LD_CONFIG, "Guessed local hostname '%s' "
|
2010-10-02 03:31:09 +02:00
|
|
|
"resolves to a private IP address (%s). Trying something "
|
|
|
|
"else.", hostname, fmt_addr32(addr));
|
2006-03-14 23:51:15 +01:00
|
|
|
|
2006-09-09 21:20:27 +02:00
|
|
|
if (get_interface_address(warn_severity, &interface_ip)) {
|
2006-07-15 22:26:05 +02:00
|
|
|
log_fn(warn_severity, LD_CONFIG,
|
|
|
|
"Could not get local interface IP address. Too bad.");
|
2006-03-14 23:51:15 +01:00
|
|
|
} else if (is_internal_IP(interface_ip, 0)) {
|
2006-07-15 22:26:05 +02:00
|
|
|
log_fn(notice_severity, LD_CONFIG,
|
|
|
|
"Interface IP address '%s' is a private address too. "
|
2010-10-02 03:31:09 +02:00
|
|
|
"Ignoring.", fmt_addr32(interface_ip));
|
2006-03-14 23:51:15 +01:00
|
|
|
} else {
|
2007-01-06 06:42:31 +01:00
|
|
|
from_interface = 1;
|
2010-10-02 03:31:09 +02:00
|
|
|
addr = interface_ip;
|
2006-07-15 22:26:05 +02:00
|
|
|
log_fn(notice_severity, LD_CONFIG,
|
|
|
|
"Learned IP address '%s' for local interface."
|
2010-10-02 03:31:09 +02:00
|
|
|
" Using that.", fmt_addr32(addr));
|
2006-03-14 23:51:15 +01:00
|
|
|
strlcpy(hostname, "<guessed from interfaces>", sizeof(hostname));
|
|
|
|
}
|
|
|
|
}
|
2004-03-15 05:57:24 +01:00
|
|
|
}
|
2010-11-01 20:52:43 +01:00
|
|
|
} else {
|
|
|
|
addr = ntohl(in.s_addr); /* set addr so that addr_string is not
|
|
|
|
* illformed */
|
2004-03-14 19:12:59 +01:00
|
|
|
}
|
2004-10-14 04:47:09 +02:00
|
|
|
|
2010-10-15 23:07:27 +02:00
|
|
|
addr_string = tor_dup_ip(addr);
|
2010-11-11 18:19:37 +01:00
|
|
|
if (is_internal_IP(addr, 0)) {
|
2005-06-08 22:32:22 +02:00
|
|
|
/* make sure we're ok with publishing an internal IP */
|
2007-12-12 05:38:54 +01:00
|
|
|
if (!options->DirServers && !options->AlternateDirAuthority) {
|
2005-12-14 21:40:40 +01:00
|
|
|
/* if they are using the default dirservers, disallow internal IPs
|
|
|
|
* always. */
|
2006-07-15 22:26:05 +02:00
|
|
|
log_fn(warn_severity, LD_CONFIG,
|
|
|
|
"Address '%s' resolves to private IP address '%s'. "
|
|
|
|
"Tor servers that use the default DirServers must have public "
|
2010-10-15 23:07:27 +02:00
|
|
|
"IP addresses.", hostname, addr_string);
|
|
|
|
tor_free(addr_string);
|
2005-05-09 06:31:00 +02:00
|
|
|
return -1;
|
2005-06-08 22:32:22 +02:00
|
|
|
}
|
|
|
|
if (!explicit_ip) {
|
|
|
|
/* even if they've set their own dirservers, require an explicit IP if
|
|
|
|
* they're using an internal address. */
|
2006-07-15 22:26:05 +02:00
|
|
|
log_fn(warn_severity, LD_CONFIG, "Address '%s' resolves to private "
|
|
|
|
"IP address '%s'. Please set the Address config option to be "
|
2010-10-15 23:07:27 +02:00
|
|
|
"the IP address you want to use.", hostname, addr_string);
|
|
|
|
tor_free(addr_string);
|
2005-06-08 22:32:22 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2004-03-14 19:12:59 +01:00
|
|
|
}
|
2004-10-14 04:47:09 +02:00
|
|
|
|
2010-10-02 03:31:09 +02:00
|
|
|
log_debug(LD_CONFIG, "Resolved Address to '%s'.", fmt_addr32(addr));
|
|
|
|
*addr_out = addr;
|
2006-10-02 23:00:35 +02:00
|
|
|
if (last_resolved_addr && last_resolved_addr != *addr_out) {
|
2006-07-15 22:26:05 +02:00
|
|
|
/* Leave this as a notice, regardless of the requested severity,
|
|
|
|
* at least until dynamic IP address support becomes bulletproof. */
|
2007-11-22 02:38:54 +01:00
|
|
|
log_notice(LD_NET,
|
|
|
|
"Your IP address seems to have changed to %s. Updating.",
|
2010-10-15 23:07:27 +02:00
|
|
|
addr_string);
|
2006-12-28 22:29:20 +01:00
|
|
|
ip_address_changed(0);
|
2005-02-27 10:47:01 +01:00
|
|
|
}
|
2007-01-06 06:42:31 +01:00
|
|
|
if (last_resolved_addr != *addr_out) {
|
|
|
|
const char *method;
|
|
|
|
const char *h = hostname;
|
|
|
|
if (explicit_ip) {
|
|
|
|
method = "CONFIGURED";
|
|
|
|
h = NULL;
|
|
|
|
} else if (explicit_hostname) {
|
|
|
|
method = "RESOLVED";
|
|
|
|
} else if (from_interface) {
|
|
|
|
method = "INTERFACE";
|
|
|
|
h = NULL;
|
|
|
|
} else {
|
|
|
|
method = "GETHOSTNAME";
|
|
|
|
}
|
|
|
|
control_event_server_status(LOG_NOTICE,
|
|
|
|
"EXTERNAL_ADDRESS ADDRESS=%s METHOD=%s %s%s",
|
2010-10-15 23:07:27 +02:00
|
|
|
addr_string, method, h?"HOSTNAME=":"", h);
|
2007-01-06 06:42:31 +01:00
|
|
|
}
|
2006-10-02 23:00:35 +02:00
|
|
|
last_resolved_addr = *addr_out;
|
2005-08-25 22:33:17 +02:00
|
|
|
if (hostname_out)
|
|
|
|
*hostname_out = tor_strdup(hostname);
|
2010-10-15 23:07:27 +02:00
|
|
|
tor_free(addr_string);
|
2004-03-14 19:12:59 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-05 22:08:19 +02:00
|
|
|
/** Return true iff <b>addr</b> is judged to be on the same network as us, or
|
|
|
|
* on a private network.
|
2006-10-02 23:00:35 +02:00
|
|
|
*/
|
|
|
|
int
|
2008-08-05 22:08:19 +02:00
|
|
|
is_local_addr(const tor_addr_t *addr)
|
2006-10-02 23:00:35 +02:00
|
|
|
{
|
2008-08-05 22:08:19 +02:00
|
|
|
if (tor_addr_is_internal(addr, 0))
|
2006-10-02 23:00:35 +02:00
|
|
|
return 1;
|
2006-10-03 07:45:58 +02:00
|
|
|
/* Check whether ip is on the same /24 as we are. */
|
|
|
|
if (get_options()->EnforceDistinctSubnets == 0)
|
|
|
|
return 0;
|
2008-08-05 22:08:19 +02:00
|
|
|
if (tor_addr_family(addr) == AF_INET) {
|
2011-03-25 21:01:16 +01:00
|
|
|
/*XXXX023 IP6 what corresponds to an /24? */
|
2008-08-05 22:08:19 +02:00
|
|
|
uint32_t ip = tor_addr_to_ipv4h(addr);
|
|
|
|
|
|
|
|
/* It's possible that this next check will hit before the first time
|
|
|
|
* resolve_my_address actually succeeds. (For clients, it is likely that
|
|
|
|
* resolve_my_address will never be called at all). In those cases,
|
|
|
|
* last_resolved_addr will be 0, and so checking to see whether ip is on
|
|
|
|
* the same /24 as last_resolved_addr will be the same as checking whether
|
|
|
|
* it was on net 0, which is already done by is_internal_IP.
|
|
|
|
*/
|
2009-09-01 05:23:47 +02:00
|
|
|
if ((last_resolved_addr & (uint32_t)0xffffff00ul)
|
|
|
|
== (ip & (uint32_t)0xffffff00ul))
|
2008-08-05 22:08:19 +02:00
|
|
|
return 1;
|
|
|
|
}
|
2006-10-02 23:00:35 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-05-25 21:41:31 +02:00
|
|
|
/** Release storage held by <b>options</b>. */
|
2004-10-14 04:47:09 +02:00
|
|
|
static void
|
2005-07-28 21:01:48 +02:00
|
|
|
config_free(config_format_t *fmt, void *options)
|
2004-10-14 04:47:09 +02:00
|
|
|
{
|
2004-11-04 09:26:34 +01:00
|
|
|
int i;
|
|
|
|
|
2009-09-28 16:37:01 +02:00
|
|
|
if (!options)
|
|
|
|
return;
|
|
|
|
|
|
|
|
tor_assert(fmt);
|
2004-12-07 10:11:38 +01:00
|
|
|
|
2005-09-14 04:07:35 +02:00
|
|
|
for (i=0; fmt->vars[i].name; ++i)
|
|
|
|
option_clear(fmt, options, &(fmt->vars[i]));
|
2006-02-12 23:28:30 +01:00
|
|
|
if (fmt->extra) {
|
|
|
|
config_line_t **linep = STRUCT_VAR_P(options, fmt->extra->var_offset);
|
|
|
|
config_free_lines(*linep);
|
|
|
|
*linep = NULL;
|
|
|
|
}
|
2004-12-07 10:11:38 +01:00
|
|
|
tor_free(options);
|
2003-10-21 11:48:17 +02:00
|
|
|
}
|
2002-11-23 07:49:01 +01:00
|
|
|
|
2005-09-14 04:07:35 +02:00
|
|
|
/** Return true iff a and b contain identical keys and values in identical
|
|
|
|
* order. */
|
|
|
|
static int
|
|
|
|
config_lines_eq(config_line_t *a, config_line_t *b)
|
|
|
|
{
|
|
|
|
while (a && b) {
|
|
|
|
if (strcasecmp(a->key, b->key) || strcmp(a->value, b->value))
|
|
|
|
return 0;
|
|
|
|
a = a->next;
|
|
|
|
b = b->next;
|
|
|
|
}
|
|
|
|
if (a || b)
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-12-22 10:04:46 +01:00
|
|
|
/** Return true iff the option <b>name</b> has the same value in <b>o1</b>
|
2004-11-12 21:09:54 +01:00
|
|
|
* and <b>o2</b>. Must not be called for LINELIST_S or OBSOLETE options.
|
|
|
|
*/
|
|
|
|
static int
|
2005-07-22 22:37:42 +02:00
|
|
|
option_is_same(config_format_t *fmt,
|
|
|
|
or_options_t *o1, or_options_t *o2, const char *name)
|
2004-11-12 21:09:54 +01:00
|
|
|
{
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *c1, *c2;
|
2004-11-14 21:51:28 +01:00
|
|
|
int r = 1;
|
2005-07-22 22:37:42 +02:00
|
|
|
CHECK(fmt, o1);
|
|
|
|
CHECK(fmt, o2);
|
|
|
|
|
2008-01-07 19:54:55 +01:00
|
|
|
c1 = get_assigned_option(fmt, o1, name, 0);
|
|
|
|
c2 = get_assigned_option(fmt, o2, name, 0);
|
2005-09-14 04:07:35 +02:00
|
|
|
r = config_lines_eq(c1, c2);
|
2004-11-14 21:51:28 +01:00
|
|
|
config_free_lines(c1);
|
|
|
|
config_free_lines(c2);
|
|
|
|
return r;
|
2004-11-12 21:09:54 +01:00
|
|
|
}
|
|
|
|
|
2004-11-06 06:18:11 +01:00
|
|
|
/** Copy storage held by <b>old</b> into a new or_options_t and return it. */
|
|
|
|
static or_options_t *
|
2005-07-22 22:37:42 +02:00
|
|
|
options_dup(config_format_t *fmt, or_options_t *old)
|
2004-11-04 23:31:50 +01:00
|
|
|
{
|
2004-11-09 06:59:22 +01:00
|
|
|
or_options_t *newopts;
|
2004-11-06 06:18:11 +01:00
|
|
|
int i;
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *line;
|
2004-11-04 23:31:50 +01:00
|
|
|
|
2005-07-22 22:37:42 +02:00
|
|
|
newopts = config_alloc(fmt);
|
|
|
|
for (i=0; fmt->vars[i].name; ++i) {
|
|
|
|
if (fmt->vars[i].type == CONFIG_TYPE_LINELIST_S)
|
2004-11-09 07:18:17 +01:00
|
|
|
continue;
|
2005-07-22 22:37:42 +02:00
|
|
|
if (fmt->vars[i].type == CONFIG_TYPE_OBSOLETE)
|
2004-11-09 07:18:17 +01:00
|
|
|
continue;
|
2008-01-07 19:54:55 +01:00
|
|
|
line = get_assigned_option(fmt, old, fmt->vars[i].name, 0);
|
2004-11-06 06:18:11 +01:00
|
|
|
if (line) {
|
2006-03-26 10:09:19 +02:00
|
|
|
char *msg = NULL;
|
|
|
|
if (config_assign(fmt, newopts, line, 0, 0, &msg) < 0) {
|
2007-03-04 21:11:46 +01:00
|
|
|
log_err(LD_BUG, "Config_get_assigned_option() generated "
|
2006-03-26 10:09:19 +02:00
|
|
|
"something we couldn't config_assign(): %s", msg);
|
|
|
|
tor_free(msg);
|
2004-11-06 06:18:11 +01:00
|
|
|
tor_assert(0);
|
2004-11-04 23:31:50 +01:00
|
|
|
}
|
2004-11-06 06:18:11 +01:00
|
|
|
}
|
|
|
|
config_free_lines(line);
|
2004-11-04 23:31:50 +01:00
|
|
|
}
|
2004-11-09 06:59:22 +01:00
|
|
|
return newopts;
|
2004-11-04 23:31:50 +01:00
|
|
|
}
|
|
|
|
|
2005-08-09 20:49:43 +02:00
|
|
|
/** Return a new empty or_options_t. Used for testing. */
|
|
|
|
or_options_t *
|
|
|
|
options_new(void)
|
|
|
|
{
|
|
|
|
return config_alloc(&options_format);
|
|
|
|
}
|
|
|
|
|
2004-10-14 04:47:09 +02:00
|
|
|
/** Set <b>options</b> to hold reasonable defaults for most options.
|
|
|
|
* Each option defaults to zero. */
|
2004-11-06 06:18:11 +01:00
|
|
|
void
|
|
|
|
options_init(or_options_t *options)
|
2005-07-22 22:37:42 +02:00
|
|
|
{
|
2005-08-04 21:56:41 +02:00
|
|
|
config_init(&options_format, options);
|
2005-07-22 22:37:42 +02:00
|
|
|
}
|
|
|
|
|
2009-05-26 12:41:45 +02:00
|
|
|
/* Check if the port number given in <b>port_option</b> in combination with
|
|
|
|
* the specified port in <b>listen_options</b> will result in Tor actually
|
|
|
|
* opening a low port (meaning a port lower than 1024). Return 1 if
|
|
|
|
* it is, or 0 if it isn't or the concept of a low port isn't applicable for
|
|
|
|
* the platform we're on. */
|
|
|
|
static int
|
2011-05-02 21:31:49 +02:00
|
|
|
is_listening_on_low_port(int port_option,
|
2009-05-26 12:41:45 +02:00
|
|
|
const config_line_t *listen_options)
|
|
|
|
{
|
|
|
|
#ifdef MS_WINDOWS
|
2009-09-29 01:52:56 +02:00
|
|
|
(void) port_option;
|
|
|
|
(void) listen_options;
|
2009-05-26 12:41:45 +02:00
|
|
|
return 0; /* No port is too low for windows. */
|
|
|
|
#else
|
|
|
|
const config_line_t *l;
|
|
|
|
uint16_t p;
|
2009-05-30 05:28:01 +02:00
|
|
|
if (port_option == 0)
|
|
|
|
return 0; /* We're not listening */
|
|
|
|
if (listen_options == NULL)
|
|
|
|
return (port_option < 1024);
|
|
|
|
|
2009-05-26 12:41:45 +02:00
|
|
|
for (l = listen_options; l; l = l->next) {
|
|
|
|
parse_addr_port(LOG_WARN, l->value, NULL, NULL, &p);
|
|
|
|
if (p<1024) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-02-21 10:01:32 +01:00
|
|
|
/** Set all vars in the configuration object <b>options</b> to their default
|
2006-03-17 06:50:41 +01:00
|
|
|
* values. */
|
2005-07-22 22:37:42 +02:00
|
|
|
static void
|
2005-07-28 21:01:48 +02:00
|
|
|
config_init(config_format_t *fmt, void *options)
|
2004-10-14 04:47:09 +02:00
|
|
|
{
|
2004-11-04 09:26:34 +01:00
|
|
|
int i;
|
|
|
|
config_var_t *var;
|
2005-07-22 22:37:42 +02:00
|
|
|
CHECK(fmt, options);
|
2004-11-04 09:26:34 +01:00
|
|
|
|
2005-07-22 22:37:42 +02:00
|
|
|
for (i=0; fmt->vars[i].name; ++i) {
|
|
|
|
var = &fmt->vars[i];
|
2004-11-28 10:05:49 +01:00
|
|
|
if (!var->initvalue)
|
2004-11-04 09:26:34 +01:00
|
|
|
continue; /* defaults to NULL or 0 */
|
2005-09-14 04:07:35 +02:00
|
|
|
option_reset(fmt, options, var, 1);
|
2004-11-04 09:26:34 +01:00
|
|
|
}
|
2003-10-21 11:48:17 +02:00
|
|
|
}
|
|
|
|
|
2007-02-02 21:06:43 +01:00
|
|
|
/** Allocate and return a new string holding the written-out values of the vars
|
2006-12-15 22:27:19 +01:00
|
|
|
* in 'options'. If 'minimal', do not write out any default-valued vars.
|
|
|
|
* Else, if comment_defaults, write default values as comments.
|
|
|
|
*/
|
2005-07-22 22:37:42 +02:00
|
|
|
static char *
|
2006-12-15 22:27:19 +01:00
|
|
|
config_dump(config_format_t *fmt, void *options, int minimal,
|
|
|
|
int comment_defaults)
|
2004-11-12 21:09:54 +01:00
|
|
|
{
|
|
|
|
smartlist_t *elements;
|
|
|
|
or_options_t *defaults;
|
2006-01-11 05:09:40 +01:00
|
|
|
config_line_t *line, *assigned;
|
2004-11-12 21:09:54 +01:00
|
|
|
char *result;
|
2005-08-04 21:56:41 +02:00
|
|
|
int i;
|
2006-03-26 08:51:26 +02:00
|
|
|
char *msg = NULL;
|
2004-11-12 21:09:54 +01:00
|
|
|
|
2005-07-22 22:37:42 +02:00
|
|
|
defaults = config_alloc(fmt);
|
|
|
|
config_init(fmt, defaults);
|
2006-03-26 08:51:26 +02:00
|
|
|
|
|
|
|
/* XXX use a 1 here so we don't add a new log line while dumping */
|
|
|
|
if (fmt->validate_fn(NULL,defaults, 1, &msg) < 0) {
|
|
|
|
log_err(LD_BUG, "Failed to validate default config.");
|
|
|
|
tor_free(msg);
|
|
|
|
tor_assert(0);
|
|
|
|
}
|
2004-11-12 21:09:54 +01:00
|
|
|
|
|
|
|
elements = smartlist_create();
|
2005-07-22 22:37:42 +02:00
|
|
|
for (i=0; fmt->vars[i].name; ++i) {
|
2006-12-15 22:27:19 +01:00
|
|
|
int comment_option = 0;
|
2005-07-22 22:37:42 +02:00
|
|
|
if (fmt->vars[i].type == CONFIG_TYPE_OBSOLETE ||
|
|
|
|
fmt->vars[i].type == CONFIG_TYPE_LINELIST_S)
|
2004-11-12 21:09:54 +01:00
|
|
|
continue;
|
2005-03-12 05:22:01 +01:00
|
|
|
/* Don't save 'hidden' control variables. */
|
2005-07-22 22:37:42 +02:00
|
|
|
if (!strcmpstart(fmt->vars[i].name, "__"))
|
2005-03-12 05:22:01 +01:00
|
|
|
continue;
|
2005-07-22 22:37:42 +02:00
|
|
|
if (minimal && option_is_same(fmt, options, defaults, fmt->vars[i].name))
|
2004-11-12 21:09:54 +01:00
|
|
|
continue;
|
2006-12-15 22:27:19 +01:00
|
|
|
else if (comment_defaults &&
|
|
|
|
option_is_same(fmt, options, defaults, fmt->vars[i].name))
|
|
|
|
comment_option = 1;
|
2005-07-28 21:01:48 +02:00
|
|
|
|
2008-01-07 19:54:55 +01:00
|
|
|
line = assigned = get_assigned_option(fmt, options, fmt->vars[i].name, 1);
|
2006-01-11 20:43:14 +01:00
|
|
|
|
2004-11-12 21:09:54 +01:00
|
|
|
for (; line; line = line->next) {
|
|
|
|
char *tmp;
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(&tmp, "%s%s %s\n",
|
|
|
|
comment_option ? "# " : "",
|
|
|
|
line->key, line->value);
|
2004-11-12 21:09:54 +01:00
|
|
|
smartlist_add(elements, tmp);
|
|
|
|
}
|
2006-01-11 05:09:40 +01:00
|
|
|
config_free_lines(assigned);
|
2004-11-12 21:09:54 +01:00
|
|
|
}
|
|
|
|
|
2006-02-12 23:28:30 +01:00
|
|
|
if (fmt->extra) {
|
|
|
|
line = *(config_line_t**)STRUCT_VAR_P(options, fmt->extra->var_offset);
|
|
|
|
for (; line; line = line->next) {
|
|
|
|
char *tmp;
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(&tmp, "%s %s\n", line->key, line->value);
|
2006-02-12 23:28:30 +01:00
|
|
|
smartlist_add(elements, tmp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-11-12 21:09:54 +01:00
|
|
|
result = smartlist_join_strings(elements, "", 0, NULL);
|
|
|
|
SMARTLIST_FOREACH(elements, char *, cp, tor_free(cp));
|
|
|
|
smartlist_free(elements);
|
2006-01-11 04:20:53 +01:00
|
|
|
config_free(fmt, defaults);
|
2004-11-12 21:09:54 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2005-07-22 22:37:42 +02:00
|
|
|
/** Return a string containing a possible configuration file that would give
|
|
|
|
* the configuration in <b>options</b>. If <b>minimal</b> is true, do not
|
|
|
|
* include options that are the same as Tor's defaults.
|
|
|
|
*/
|
2009-12-14 01:21:06 +01:00
|
|
|
char *
|
2005-07-23 03:58:05 +02:00
|
|
|
options_dump(or_options_t *options, int minimal)
|
2005-07-22 22:37:42 +02:00
|
|
|
{
|
2006-12-15 22:27:19 +01:00
|
|
|
return config_dump(&options_format, options, minimal, 0);
|
2005-07-22 22:37:42 +02:00
|
|
|
}
|
|
|
|
|
2007-02-02 21:06:43 +01:00
|
|
|
/** Return 0 if every element of sl is a string holding a decimal
|
2005-08-07 23:58:23 +02:00
|
|
|
* representation of a port number, or if sl is NULL.
|
2006-03-26 08:51:26 +02:00
|
|
|
* Otherwise set *msg and return -1. */
|
2005-01-12 05:58:23 +01:00
|
|
|
static int
|
2006-03-26 08:51:26 +02:00
|
|
|
validate_ports_csv(smartlist_t *sl, const char *name, char **msg)
|
2005-06-11 20:52:12 +02:00
|
|
|
{
|
2005-01-12 05:58:23 +01:00
|
|
|
int i;
|
|
|
|
tor_assert(name);
|
|
|
|
|
2005-02-05 22:42:46 +01:00
|
|
|
if (!sl)
|
2005-01-12 05:58:23 +01:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
SMARTLIST_FOREACH(sl, const char *, cp,
|
|
|
|
{
|
|
|
|
i = atoi(cp);
|
|
|
|
if (i < 1 || i > 65535) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg, "Port '%s' out of range in %s", cp, name);
|
2006-03-26 08:51:26 +02:00
|
|
|
return -1;
|
2005-01-12 05:58:23 +01:00
|
|
|
}
|
|
|
|
});
|
2006-03-26 08:51:26 +02:00
|
|
|
return 0;
|
2005-01-12 05:58:23 +01:00
|
|
|
}
|
|
|
|
|
2007-05-04 11:20:13 +02:00
|
|
|
/** If <b>value</b> exceeds ROUTER_MAX_DECLARED_BANDWIDTH, write
|
|
|
|
* a complaint into *<b>msg</b> using string <b>desc</b>, and return -1.
|
|
|
|
* Else return 0.
|
|
|
|
*/
|
|
|
|
static int
|
2007-05-30 09:18:00 +02:00
|
|
|
ensure_bandwidth_cap(uint64_t *value, const char *desc, char **msg)
|
2007-05-04 11:20:13 +02:00
|
|
|
{
|
2007-05-31 20:48:31 +02:00
|
|
|
if (*value > ROUTER_MAX_DECLARED_BANDWIDTH) {
|
2007-05-30 09:18:00 +02:00
|
|
|
/* This handles an understandable special case where somebody says "2gb"
|
|
|
|
* whereas our actual maximum is 2gb-1 (INT_MAX) */
|
|
|
|
--*value;
|
|
|
|
}
|
|
|
|
if (*value > ROUTER_MAX_DECLARED_BANDWIDTH) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg, "%s ("U64_FORMAT") must be at most %d",
|
|
|
|
desc, U64_PRINTF_ARG(*value),
|
|
|
|
ROUTER_MAX_DECLARED_BANDWIDTH);
|
2007-05-04 11:20:13 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-22 10:04:46 +01:00
|
|
|
/** Parse an authority type from <b>options</b>-\>PublishServerDescriptor
|
|
|
|
* and write it to <b>options</b>-\>_PublishServerDescriptor. Treat "1"
|
|
|
|
* as "v2,v3" unless BridgeRelay is 1, in which case treat it as "bridge".
|
|
|
|
* Treat "0" as "".
|
2007-10-16 05:26:39 +02:00
|
|
|
* Return 0 on success or -1 if not a recognized authority type (in which
|
2007-12-22 10:04:46 +01:00
|
|
|
* case the value of _PublishServerDescriptor is undefined). */
|
2007-05-08 11:09:26 +02:00
|
|
|
static int
|
2007-12-22 10:04:46 +01:00
|
|
|
compute_publishserverdescriptor(or_options_t *options)
|
2007-05-08 11:09:26 +02:00
|
|
|
{
|
2007-12-22 10:04:46 +01:00
|
|
|
smartlist_t *list = options->PublishServerDescriptor;
|
2010-11-08 20:27:36 +01:00
|
|
|
dirinfo_type_t *auth = &options->_PublishServerDescriptor;
|
2010-11-08 20:35:02 +01:00
|
|
|
*auth = NO_DIRINFO;
|
2007-07-30 10:42:47 +02:00
|
|
|
if (!list) /* empty list, answer is none */
|
|
|
|
return 0;
|
2007-05-09 06:15:46 +02:00
|
|
|
SMARTLIST_FOREACH(list, const char *, string, {
|
|
|
|
if (!strcasecmp(string, "v1"))
|
2010-11-08 20:35:02 +01:00
|
|
|
*auth |= V1_DIRINFO;
|
2007-12-22 10:04:46 +01:00
|
|
|
else if (!strcmp(string, "1"))
|
|
|
|
if (options->BridgeRelay)
|
2010-11-08 20:35:02 +01:00
|
|
|
*auth |= BRIDGE_DIRINFO;
|
2007-12-22 10:04:46 +01:00
|
|
|
else
|
2010-11-08 20:35:02 +01:00
|
|
|
*auth |= V2_DIRINFO | V3_DIRINFO;
|
2007-05-09 06:15:46 +02:00
|
|
|
else if (!strcasecmp(string, "v2"))
|
2010-11-08 20:35:02 +01:00
|
|
|
*auth |= V2_DIRINFO;
|
2007-05-22 19:58:25 +02:00
|
|
|
else if (!strcasecmp(string, "v3"))
|
2010-11-08 20:35:02 +01:00
|
|
|
*auth |= V3_DIRINFO;
|
2007-05-09 06:15:46 +02:00
|
|
|
else if (!strcasecmp(string, "bridge"))
|
2010-11-08 20:35:02 +01:00
|
|
|
*auth |= BRIDGE_DIRINFO;
|
2007-05-09 06:15:46 +02:00
|
|
|
else if (!strcasecmp(string, "hidserv"))
|
2011-01-18 12:54:56 +01:00
|
|
|
log_warn(LD_CONFIG,
|
|
|
|
"PublishServerDescriptor hidserv is invalid. See "
|
|
|
|
"PublishHidServDescriptors.");
|
2007-12-22 10:04:46 +01:00
|
|
|
else if (!strcasecmp(string, "") || !strcmp(string, "0"))
|
2007-05-09 06:15:46 +02:00
|
|
|
/* no authority */;
|
|
|
|
else
|
2007-10-16 05:26:39 +02:00
|
|
|
return -1;
|
2007-05-09 06:15:46 +02:00
|
|
|
});
|
2007-05-08 11:09:26 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-03-12 23:48:18 +01:00
|
|
|
/** Lowest allowable value for RendPostPeriod; if this is too low, hidden
|
|
|
|
* services can overload the directory system. */
|
2007-03-01 01:41:28 +01:00
|
|
|
#define MIN_REND_POST_PERIOD (10*60)
|
2006-03-12 23:48:18 +01:00
|
|
|
|
2006-12-15 22:27:19 +01:00
|
|
|
/** Highest allowable value for RendPostPeriod. */
|
2006-03-12 23:48:18 +01:00
|
|
|
#define MAX_DIR_PERIOD (MIN_ONION_KEY_LIFETIME/2)
|
|
|
|
|
2008-12-17 23:32:17 +01:00
|
|
|
/** Lowest allowable value for MaxCircuitDirtiness; if this is too low, Tor
|
|
|
|
* will generate too many circuits and potentially overload the network. */
|
|
|
|
#define MIN_MAX_CIRCUIT_DIRTINESS 10
|
|
|
|
|
2009-11-22 13:15:30 +01:00
|
|
|
/** Lowest allowable value for CircuitStreamTimeout; if this is too low, Tor
|
|
|
|
* will generate too many circuits and potentially overload the network. */
|
|
|
|
#define MIN_CIRCUIT_STREAM_TIMEOUT 10
|
|
|
|
|
2010-12-01 02:24:03 +01:00
|
|
|
/** Lowest allowable value for HeartbeatPeriod; if this is too low, we might
|
|
|
|
* expose more information than we're comfortable with. */
|
|
|
|
#define MIN_HEARTBEAT_PERIOD (30*60)
|
|
|
|
|
2006-03-17 06:50:41 +01:00
|
|
|
/** Return 0 if every setting in <b>options</b> is reasonable, and a
|
2006-03-26 08:51:26 +02:00
|
|
|
* permissible transition from <b>old_options</b>. Else return -1.
|
2006-03-17 06:50:41 +01:00
|
|
|
* Should have no side effects, except for normalizing the contents of
|
|
|
|
* <b>options</b>.
|
2006-01-10 21:27:47 +01:00
|
|
|
*
|
2006-03-26 08:51:26 +02:00
|
|
|
* On error, tor_strdup an error explanation into *<b>msg</b>.
|
|
|
|
*
|
2006-01-10 21:27:47 +01:00
|
|
|
* XXX
|
|
|
|
* If <b>from_setconf</b>, we were called by the controller, and our
|
|
|
|
* Log line should stay empty. If it's 0, then give us a default log
|
|
|
|
* if there are no logs defined.
|
2005-12-08 19:56:32 +01:00
|
|
|
*/
|
2004-11-04 11:23:30 +01:00
|
|
|
static int
|
2006-01-10 21:27:47 +01:00
|
|
|
options_validate(or_options_t *old_options, or_options_t *options,
|
2006-03-26 08:51:26 +02:00
|
|
|
int from_setconf, char **msg)
|
2004-11-04 11:23:30 +01:00
|
|
|
{
|
2010-03-01 03:46:50 +01:00
|
|
|
int i;
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *cl;
|
2007-01-03 11:30:26 +01:00
|
|
|
const char *uname = get_uname();
|
2005-12-14 21:40:40 +01:00
|
|
|
#define REJECT(arg) \
|
2007-06-17 20:22:39 +02:00
|
|
|
STMT_BEGIN *msg = tor_strdup(arg); return -1; STMT_END
|
|
|
|
#define COMPLAIN(arg) STMT_BEGIN log(LOG_WARN, LD_CONFIG, arg); STMT_END
|
2004-02-29 00:30:41 +01:00
|
|
|
|
2006-03-26 08:51:26 +02:00
|
|
|
tor_assert(msg);
|
|
|
|
*msg = NULL;
|
|
|
|
|
2006-02-11 22:26:40 +01:00
|
|
|
if (server_mode(options) &&
|
|
|
|
(!strcmpstart(uname, "Windows 95") ||
|
|
|
|
!strcmpstart(uname, "Windows 98") ||
|
|
|
|
!strcmpstart(uname, "Windows Me"))) {
|
|
|
|
log(LOG_WARN, LD_CONFIG, "Tor is running as a server, but you are "
|
2006-02-12 23:28:30 +01:00
|
|
|
"running %s; this probably won't work. See "
|
2009-06-20 09:21:52 +02:00
|
|
|
"https://wiki.torproject.org/TheOnionRouter/TorFAQ#ServerOS "
|
2007-01-03 11:30:26 +01:00
|
|
|
"for details.", uname);
|
2006-02-11 22:26:40 +01:00
|
|
|
}
|
|
|
|
|
2005-10-25 09:05:03 +02:00
|
|
|
if (options->ORPort == 0 && options->ORListenAddress != NULL)
|
|
|
|
REJECT("ORPort must be defined if ORListenAddress is defined.");
|
2004-12-07 07:51:46 +01:00
|
|
|
|
2005-10-25 09:05:03 +02:00
|
|
|
if (options->DirPort == 0 && options->DirListenAddress != NULL)
|
|
|
|
REJECT("DirPort must be defined if DirListenAddress is defined.");
|
|
|
|
|
2007-05-24 22:31:30 +02:00
|
|
|
if (options->DNSPort == 0 && options->DNSListenAddress != NULL)
|
2007-07-10 19:13:24 +02:00
|
|
|
REJECT("DNSPort must be defined if DNSListenAddress is defined.");
|
2007-05-24 22:31:30 +02:00
|
|
|
|
2006-02-13 07:25:16 +01:00
|
|
|
if (options->ControlPort == 0 && options->ControlListenAddress != NULL)
|
|
|
|
REJECT("ControlPort must be defined if ControlListenAddress is defined.");
|
|
|
|
|
2006-09-05 16:30:06 +02:00
|
|
|
if (options->TransPort == 0 && options->TransListenAddress != NULL)
|
|
|
|
REJECT("TransPort must be defined if TransListenAddress is defined.");
|
|
|
|
|
2010-10-30 06:08:47 +02:00
|
|
|
if (options->NATDPort == 0 && options->NATDListenAddress != NULL)
|
|
|
|
REJECT("NATDPort must be defined if NATDListenAddress is defined.");
|
2006-11-14 01:06:31 +01:00
|
|
|
|
2006-12-29 06:51:50 +01:00
|
|
|
/* Don't gripe about SocksPort 0 with SocksListenAddress set; a standard
|
|
|
|
* configuration does this. */
|
2005-10-25 09:05:03 +02:00
|
|
|
|
2006-11-14 01:06:31 +01:00
|
|
|
for (i = 0; i < 3; ++i) {
|
2006-08-10 11:02:02 +02:00
|
|
|
int is_socks = i==0;
|
2006-11-14 01:06:31 +01:00
|
|
|
int is_trans = i==1;
|
2006-08-10 11:02:02 +02:00
|
|
|
config_line_t *line, *opt, *old;
|
2006-11-14 01:06:45 +01:00
|
|
|
const char *tp;
|
2006-08-10 11:02:02 +02:00
|
|
|
if (is_socks) {
|
|
|
|
opt = options->SocksListenAddress;
|
2006-08-10 21:56:10 +02:00
|
|
|
old = old_options ? old_options->SocksListenAddress : NULL;
|
2006-11-14 01:06:45 +01:00
|
|
|
tp = "SOCKS proxy";
|
2006-11-14 01:06:31 +01:00
|
|
|
} else if (is_trans) {
|
2006-08-10 11:02:02 +02:00
|
|
|
opt = options->TransListenAddress;
|
2006-08-10 21:56:10 +02:00
|
|
|
old = old_options ? old_options->TransListenAddress : NULL;
|
2006-11-14 01:06:45 +01:00
|
|
|
tp = "transparent proxy";
|
2006-11-14 01:06:31 +01:00
|
|
|
} else {
|
2010-10-30 06:08:47 +02:00
|
|
|
opt = options->NATDListenAddress;
|
|
|
|
old = old_options ? old_options->NATDListenAddress : NULL;
|
2006-11-14 01:06:45 +01:00
|
|
|
tp = "natd proxy";
|
2006-08-10 11:02:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (line = opt; line; line = line->next) {
|
|
|
|
char *address = NULL;
|
2005-12-08 19:56:32 +01:00
|
|
|
uint16_t port;
|
|
|
|
uint32_t addr;
|
2006-07-06 04:44:07 +02:00
|
|
|
if (parse_addr_port(LOG_WARN, line->value, &address, &addr, &port)<0)
|
2005-12-08 19:56:32 +01:00
|
|
|
continue; /* We'll warn about this later. */
|
2005-12-09 03:46:46 +01:00
|
|
|
if (!is_internal_IP(addr, 1) &&
|
2006-08-10 11:02:02 +02:00
|
|
|
(!old_options || !config_lines_eq(old, opt))) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG,
|
2006-08-14 12:00:15 +02:00
|
|
|
"You specified a public address '%s' for a %s. Other "
|
2005-12-09 06:20:02 +01:00
|
|
|
"people on the Internet might find your computer and use it as "
|
2006-08-14 12:00:15 +02:00
|
|
|
"an open %s. Please don't allow this unless you have "
|
2006-08-10 11:02:02 +02:00
|
|
|
"a good reason.", address, tp, tp);
|
2005-12-09 03:46:46 +01:00
|
|
|
}
|
|
|
|
tor_free(address);
|
2005-12-08 19:56:32 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-10-25 09:05:03 +02:00
|
|
|
if (validate_data_directory(options)<0)
|
|
|
|
REJECT("Invalid DataDirectory");
|
2004-11-09 06:26:49 +01:00
|
|
|
|
2004-07-18 23:47:04 +02:00
|
|
|
if (options->Nickname == NULL) {
|
2004-11-06 06:18:11 +01:00
|
|
|
if (server_mode(options)) {
|
2006-09-29 06:51:28 +02:00
|
|
|
options->Nickname = tor_strdup(UNNAMED_ROUTER_NICKNAME);
|
2004-08-04 04:15:22 +02:00
|
|
|
}
|
2004-07-18 23:47:04 +02:00
|
|
|
} else {
|
2005-08-15 10:51:20 +02:00
|
|
|
if (!is_legal_nickname(options->Nickname)) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2005-12-14 21:40:40 +01:00
|
|
|
"Nickname '%s' is wrong length or contains illegal characters.",
|
|
|
|
options->Nickname);
|
2006-03-26 08:51:26 +02:00
|
|
|
return -1;
|
2004-03-20 21:28:53 +01:00
|
|
|
}
|
2002-11-23 07:49:01 +01:00
|
|
|
}
|
|
|
|
|
2005-05-04 22:45:38 +02:00
|
|
|
if (server_mode(options) && !options->ContactInfo)
|
2005-12-09 06:37:26 +01:00
|
|
|
log(LOG_NOTICE, LD_CONFIG, "Your ContactInfo config option is not set. "
|
|
|
|
"Please consider setting it, so we can contact you if your server is "
|
|
|
|
"misconfigured or something else goes wrong.");
|
2005-05-04 22:45:38 +02:00
|
|
|
|
2005-12-11 11:01:21 +01:00
|
|
|
/* Special case on first boot if no Log options are given. */
|
2006-06-12 08:03:15 +02:00
|
|
|
if (!options->Logs && !options->RunAsDaemon && !from_setconf)
|
2005-01-05 07:05:37 +01:00
|
|
|
config_line_append(&options->Logs, "Log", "notice stdout");
|
2004-11-09 00:12:40 +01:00
|
|
|
|
2005-07-23 03:58:05 +02:00
|
|
|
if (options_init_logs(options, 1)<0) /* Validate the log(s) */
|
2006-03-26 08:51:26 +02:00
|
|
|
REJECT("Failed to validate Log options. See logs for details.");
|
2004-11-10 04:40:30 +01:00
|
|
|
|
2006-07-17 08:35:06 +02:00
|
|
|
if (authdir_mode(options)) {
|
2004-08-16 13:43:18 +02:00
|
|
|
/* confirm that our address isn't broken, so we can complain now */
|
|
|
|
uint32_t tmp;
|
2006-07-15 22:26:05 +02:00
|
|
|
if (resolve_my_address(LOG_WARN, options, &tmp, NULL) < 0)
|
2006-03-26 08:51:26 +02:00
|
|
|
REJECT("Failed to resolve/guess local address. See logs for details.");
|
2004-03-04 02:53:56 +01:00
|
|
|
}
|
|
|
|
|
2006-01-10 21:00:20 +01:00
|
|
|
#ifndef MS_WINDOWS
|
|
|
|
if (options->RunAsDaemon && torrc_fname && path_is_relative(torrc_fname))
|
|
|
|
REJECT("Can't use a relative path to torrc when RunAsDaemon is set.");
|
|
|
|
#endif
|
|
|
|
|
2006-08-10 11:01:37 +02:00
|
|
|
if (options->SocksPort == 0 && options->TransPort == 0 &&
|
2010-10-30 06:08:47 +02:00
|
|
|
options->NATDPort == 0 && options->ORPort == 0 &&
|
2008-01-06 02:14:11 +01:00
|
|
|
options->DNSPort == 0 && !options->RendConfigLines)
|
|
|
|
log(LOG_WARN, LD_CONFIG,
|
2010-10-30 06:08:47 +02:00
|
|
|
"SocksPort, TransPort, NATDPort, DNSPort, and ORPort are all "
|
2008-01-06 02:14:11 +01:00
|
|
|
"undefined, and there aren't any hidden services configured. "
|
|
|
|
"Tor will still run, but probably won't do anything.");
|
2003-11-10 09:06:55 +01:00
|
|
|
|
2006-08-10 11:01:37 +02:00
|
|
|
#ifndef USE_TRANSPARENT
|
|
|
|
if (options->TransPort || options->TransListenAddress)
|
|
|
|
REJECT("TransPort and TransListenAddress are disabled in this build.");
|
|
|
|
#endif
|
|
|
|
|
2009-05-26 12:41:45 +02:00
|
|
|
if (options->AccountingMax &&
|
|
|
|
(is_listening_on_low_port(options->ORPort, options->ORListenAddress) ||
|
|
|
|
is_listening_on_low_port(options->DirPort, options->DirListenAddress)))
|
|
|
|
{
|
|
|
|
log(LOG_WARN, LD_CONFIG,
|
2009-05-12 19:48:08 +02:00
|
|
|
"You have set AccountingMax to use hibernation. You have also "
|
|
|
|
"chosen a low DirPort or OrPort. This combination can make Tor stop "
|
|
|
|
"working when it tries to re-attach the port after a period of "
|
|
|
|
"hibernation. Please choose a different port or turn off "
|
|
|
|
"hibernation unless you know this combination will work on your "
|
|
|
|
"platform.");
|
2009-05-26 12:41:45 +02:00
|
|
|
}
|
2009-05-12 19:48:08 +02:00
|
|
|
|
2008-07-18 20:36:32 +02:00
|
|
|
if (options->ExcludeExitNodes || options->ExcludeNodes) {
|
|
|
|
options->_ExcludeExitNodesUnion = routerset_new();
|
|
|
|
routerset_union(options->_ExcludeExitNodesUnion,options->ExcludeExitNodes);
|
|
|
|
routerset_union(options->_ExcludeExitNodesUnion,options->ExcludeNodes);
|
|
|
|
}
|
|
|
|
|
2010-10-01 00:25:25 +02:00
|
|
|
if (options->NodeFamilies) {
|
|
|
|
options->NodeFamilySets = smartlist_create();
|
|
|
|
for (cl = options->NodeFamilies; cl; cl = cl->next) {
|
|
|
|
routerset_t *rs = routerset_new();
|
|
|
|
if (routerset_parse(rs, cl->value, cl->key) == 0) {
|
|
|
|
smartlist_add(options->NodeFamilySets, rs);
|
|
|
|
} else {
|
|
|
|
routerset_free(rs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-18 04:45:54 +02:00
|
|
|
if (options->ExcludeNodes && options->StrictNodes) {
|
|
|
|
COMPLAIN("You have asked to exclude certain relays from all positions "
|
|
|
|
"in your circuits. Expect hidden services and other Tor "
|
|
|
|
"features to be broken in unpredictable ways.");
|
|
|
|
}
|
|
|
|
|
2005-08-25 22:33:17 +02:00
|
|
|
if (options->AuthoritativeDir) {
|
2009-04-10 09:02:19 +02:00
|
|
|
if (!options->ContactInfo && !options->TestingTorNetwork)
|
2005-10-25 09:05:03 +02:00
|
|
|
REJECT("Authoritative directory servers must set ContactInfo");
|
2006-03-18 00:25:40 +01:00
|
|
|
if (options->V1AuthoritativeDir && !options->RecommendedVersions)
|
2009-05-27 23:55:51 +02:00
|
|
|
REJECT("V1 authoritative dir servers must set RecommendedVersions.");
|
2005-08-25 22:33:17 +02:00
|
|
|
if (!options->RecommendedClientVersions)
|
|
|
|
options->RecommendedClientVersions =
|
|
|
|
config_lines_dup(options->RecommendedVersions);
|
|
|
|
if (!options->RecommendedServerVersions)
|
|
|
|
options->RecommendedServerVersions =
|
|
|
|
config_lines_dup(options->RecommendedVersions);
|
2006-03-18 00:25:40 +01:00
|
|
|
if (options->VersioningAuthoritativeDir &&
|
|
|
|
(!options->RecommendedClientVersions ||
|
|
|
|
!options->RecommendedServerVersions))
|
2009-05-28 17:54:56 +02:00
|
|
|
REJECT("Versioning authoritative dir servers must set "
|
|
|
|
"Recommended*Versions.");
|
2006-01-10 23:42:44 +01:00
|
|
|
if (options->UseEntryGuards) {
|
2006-03-18 00:19:51 +01:00
|
|
|
log_info(LD_CONFIG, "Authoritative directory servers can't set "
|
|
|
|
"UseEntryGuards. Disabling.");
|
2006-01-10 23:42:44 +01:00
|
|
|
options->UseEntryGuards = 0;
|
2006-01-02 09:40:58 +01:00
|
|
|
}
|
2007-12-21 07:33:02 +01:00
|
|
|
if (!options->DownloadExtraInfo && authdir_mode_any_main(options)) {
|
2007-05-18 23:19:19 +02:00
|
|
|
log_info(LD_CONFIG, "Authoritative directories always try to download "
|
|
|
|
"extra-info documents. Setting DownloadExtraInfo.");
|
|
|
|
options->DownloadExtraInfo = 1;
|
|
|
|
}
|
2007-08-14 22:19:46 +02:00
|
|
|
if (!(options->BridgeAuthoritativeDir || options->HSAuthoritativeDir ||
|
|
|
|
options->V1AuthoritativeDir || options->V2AuthoritativeDir ||
|
|
|
|
options->V3AuthoritativeDir))
|
|
|
|
REJECT("AuthoritativeDir is set, but none of "
|
2008-02-04 17:58:50 +01:00
|
|
|
"(Bridge/HS/V1/V2/V3)AuthoritativeDir is set.");
|
2009-07-06 04:47:36 +02:00
|
|
|
/* If we have a v3bandwidthsfile and it's broken, complain on startup */
|
|
|
|
if (options->V3BandwidthsFile && !old_options) {
|
|
|
|
dirserv_read_measured_bandwidths(options->V3BandwidthsFile, NULL);
|
|
|
|
}
|
2004-03-10 08:44:31 +01:00
|
|
|
}
|
|
|
|
|
2005-10-25 09:05:03 +02:00
|
|
|
if (options->AuthoritativeDir && !options->DirPort)
|
|
|
|
REJECT("Running as authoritative directory, but no DirPort set.");
|
2004-06-21 06:37:27 +02:00
|
|
|
|
2005-10-25 09:05:03 +02:00
|
|
|
if (options->AuthoritativeDir && !options->ORPort)
|
|
|
|
REJECT("Running as authoritative directory, but no ORPort set.");
|
2004-07-13 09:42:20 +02:00
|
|
|
|
2006-01-10 21:06:24 +01:00
|
|
|
if (options->AuthoritativeDir && options->ClientOnly)
|
2005-10-25 09:05:03 +02:00
|
|
|
REJECT("Running as authoritative directory, but ClientOnly also set.");
|
2004-07-13 09:42:20 +02:00
|
|
|
|
2009-07-12 03:43:33 +02:00
|
|
|
if (options->FetchDirInfoExtraEarly && !options->FetchDirInfoEarly)
|
|
|
|
REJECT("FetchDirInfoExtraEarly requires that you also set "
|
|
|
|
"FetchDirInfoEarly");
|
|
|
|
|
2011-04-21 00:20:10 +02:00
|
|
|
if (options->HSAuthoritativeDir && proxy_mode(options))
|
|
|
|
REJECT("Running as authoritative v0 HS directory, but also configured "
|
|
|
|
"as a client.");
|
|
|
|
|
2005-03-14 04:28:46 +01:00
|
|
|
if (options->ConnLimit <= 0) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2005-12-14 21:40:40 +01:00
|
|
|
"ConnLimit must be greater than 0, but was set to %d",
|
2005-03-14 04:28:46 +01:00
|
|
|
options->ConnLimit);
|
2006-03-26 08:51:26 +02:00
|
|
|
return -1;
|
2005-03-14 04:28:46 +01:00
|
|
|
}
|
|
|
|
|
2006-03-26 08:51:26 +02:00
|
|
|
if (validate_ports_csv(options->FirewallPorts, "FirewallPorts", msg) < 0)
|
|
|
|
return -1;
|
2005-01-12 05:58:23 +01:00
|
|
|
|
2006-03-26 08:51:26 +02:00
|
|
|
if (validate_ports_csv(options->LongLivedPorts, "LongLivedPorts", msg) < 0)
|
|
|
|
return -1;
|
2005-08-07 23:24:00 +02:00
|
|
|
|
2008-01-20 06:54:15 +01:00
|
|
|
if (validate_ports_csv(options->RejectPlaintextPorts,
|
|
|
|
"RejectPlaintextPorts", msg) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (validate_ports_csv(options->WarnPlaintextPorts,
|
|
|
|
"WarnPlaintextPorts", msg) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2005-12-11 10:18:25 +01:00
|
|
|
if (options->FascistFirewall && !options->ReachableAddresses) {
|
2006-07-08 19:38:46 +02:00
|
|
|
if (options->FirewallPorts && smartlist_len(options->FirewallPorts)) {
|
2006-02-13 22:17:20 +01:00
|
|
|
/* We already have firewall ports set, so migrate them to
|
2006-02-19 09:31:47 +01:00
|
|
|
* ReachableAddresses, which will set ReachableORAddresses and
|
|
|
|
* ReachableDirAddresses if they aren't set explicitly. */
|
2006-02-13 22:17:20 +01:00
|
|
|
smartlist_t *instead = smartlist_create();
|
|
|
|
config_line_t *new_line = tor_malloc_zero(sizeof(config_line_t));
|
|
|
|
new_line->key = tor_strdup("ReachableAddresses");
|
|
|
|
/* If we're configured with the old format, we need to prepend some
|
|
|
|
* open ports. */
|
|
|
|
SMARTLIST_FOREACH(options->FirewallPorts, const char *, portno,
|
2005-08-08 23:58:48 +02:00
|
|
|
{
|
|
|
|
int p = atoi(portno);
|
|
|
|
char *s;
|
|
|
|
if (p<0) continue;
|
|
|
|
s = tor_malloc(16);
|
|
|
|
tor_snprintf(s, 16, "*:%d", p);
|
|
|
|
smartlist_add(instead, s);
|
|
|
|
});
|
2006-02-13 22:17:20 +01:00
|
|
|
new_line->value = smartlist_join_strings(instead,",",0,NULL);
|
|
|
|
/* These have been deprecated since 0.1.1.5-alpha-cvs */
|
2006-02-19 09:31:47 +01:00
|
|
|
log(LOG_NOTICE, LD_CONFIG,
|
|
|
|
"Converting FascistFirewall and FirewallPorts "
|
2006-02-13 22:17:20 +01:00
|
|
|
"config options to new format: \"ReachableAddresses %s\"",
|
|
|
|
new_line->value);
|
|
|
|
options->ReachableAddresses = new_line;
|
|
|
|
SMARTLIST_FOREACH(instead, char *, cp, tor_free(cp));
|
|
|
|
smartlist_free(instead);
|
|
|
|
} else {
|
2006-02-19 09:31:47 +01:00
|
|
|
/* We do not have FirewallPorts set, so add 80 to
|
|
|
|
* ReachableDirAddresses, and 443 to ReachableORAddresses. */
|
2006-02-13 22:17:20 +01:00
|
|
|
if (!options->ReachableDirAddresses) {
|
|
|
|
config_line_t *new_line = tor_malloc_zero(sizeof(config_line_t));
|
|
|
|
new_line->key = tor_strdup("ReachableDirAddresses");
|
|
|
|
new_line->value = tor_strdup("*:80");
|
|
|
|
options->ReachableDirAddresses = new_line;
|
|
|
|
log(LOG_NOTICE, LD_CONFIG, "Converting FascistFirewall config option "
|
|
|
|
"to new format: \"ReachableDirAddresses *:80\"");
|
|
|
|
}
|
|
|
|
if (!options->ReachableORAddresses) {
|
|
|
|
config_line_t *new_line = tor_malloc_zero(sizeof(config_line_t));
|
|
|
|
new_line->key = tor_strdup("ReachableORAddresses");
|
|
|
|
new_line->value = tor_strdup("*:443");
|
|
|
|
options->ReachableORAddresses = new_line;
|
|
|
|
log(LOG_NOTICE, LD_CONFIG, "Converting FascistFirewall config option "
|
|
|
|
"to new format: \"ReachableORAddresses *:443\"");
|
|
|
|
}
|
|
|
|
}
|
2005-08-07 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
2006-02-19 09:31:47 +01:00
|
|
|
for (i=0; i<3; i++) {
|
|
|
|
config_line_t **linep =
|
2006-02-13 22:17:20 +01:00
|
|
|
(i==0) ? &options->ReachableAddresses :
|
2006-02-19 09:31:47 +01:00
|
|
|
(i==1) ? &options->ReachableORAddresses :
|
|
|
|
&options->ReachableDirAddresses;
|
2006-02-13 22:17:20 +01:00
|
|
|
if (!*linep)
|
|
|
|
continue;
|
2005-08-08 23:58:48 +02:00
|
|
|
/* We need to end with a reject *:*, not an implicit accept *:* */
|
2005-12-14 21:40:40 +01:00
|
|
|
for (;;) {
|
2005-12-11 10:18:25 +01:00
|
|
|
if (!strcmp((*linep)->value, "reject *:*")) /* already there */
|
|
|
|
break;
|
2005-08-08 23:58:48 +02:00
|
|
|
linep = &((*linep)->next);
|
2005-12-11 10:18:25 +01:00
|
|
|
if (!*linep) {
|
|
|
|
*linep = tor_malloc_zero(sizeof(config_line_t));
|
2006-02-19 09:31:47 +01:00
|
|
|
(*linep)->key = tor_strdup(
|
|
|
|
(i==0) ? "ReachableAddresses" :
|
|
|
|
(i==1) ? "ReachableORAddresses" :
|
|
|
|
"ReachableDirAddresses");
|
2005-12-11 10:18:25 +01:00
|
|
|
(*linep)->value = tor_strdup("reject *:*");
|
|
|
|
break;
|
|
|
|
}
|
2005-08-08 23:58:48 +02:00
|
|
|
}
|
|
|
|
}
|
2005-01-12 05:58:23 +01:00
|
|
|
|
2006-02-13 22:17:20 +01:00
|
|
|
if ((options->ReachableAddresses ||
|
|
|
|
options->ReachableORAddresses ||
|
|
|
|
options->ReachableDirAddresses) &&
|
|
|
|
server_mode(options))
|
2006-01-10 21:06:24 +01:00
|
|
|
REJECT("Servers must be able to freely connect to the rest "
|
2006-02-13 22:17:20 +01:00
|
|
|
"of the Internet, so they must not set Reachable*Addresses "
|
2006-01-10 21:06:24 +01:00
|
|
|
"or FascistFirewall.");
|
|
|
|
|
2011-06-03 17:17:15 +02:00
|
|
|
if (options->UseBridges_ == -1) {
|
2011-05-31 05:32:38 +02:00
|
|
|
options->UseBridges = (options->Bridges &&
|
|
|
|
!server_mode(options) &&
|
|
|
|
!options->EntryNodes);
|
|
|
|
} else {
|
2011-06-03 17:17:15 +02:00
|
|
|
options->UseBridges = options->UseBridges_;
|
2011-05-31 05:32:38 +02:00
|
|
|
}
|
|
|
|
|
2007-10-25 06:40:27 +02:00
|
|
|
if (options->UseBridges &&
|
|
|
|
server_mode(options))
|
|
|
|
REJECT("Servers must be able to freely connect to the rest "
|
|
|
|
"of the Internet, so they must not set UseBridges.");
|
|
|
|
|
2011-03-11 11:39:26 +01:00
|
|
|
/* If both of these are set, we'll end up with funny behavior where we
|
|
|
|
* demand enough entrynodes be up and running else we won't build
|
|
|
|
* circuits, yet we never actually use them. */
|
|
|
|
if (options->UseBridges && options->EntryNodes)
|
|
|
|
REJECT("You cannot set both UseBridges and EntryNodes.");
|
|
|
|
|
2006-03-19 02:21:59 +01:00
|
|
|
options->_AllowInvalid = 0;
|
|
|
|
if (options->AllowInvalidNodes) {
|
|
|
|
SMARTLIST_FOREACH(options->AllowInvalidNodes, const char *, cp, {
|
2004-10-14 04:47:09 +02:00
|
|
|
if (!strcasecmp(cp, "entry"))
|
2006-03-19 02:21:59 +01:00
|
|
|
options->_AllowInvalid |= ALLOW_INVALID_ENTRY;
|
2004-10-14 04:47:09 +02:00
|
|
|
else if (!strcasecmp(cp, "exit"))
|
2006-03-19 02:21:59 +01:00
|
|
|
options->_AllowInvalid |= ALLOW_INVALID_EXIT;
|
2004-10-14 04:47:09 +02:00
|
|
|
else if (!strcasecmp(cp, "middle"))
|
2006-03-19 02:21:59 +01:00
|
|
|
options->_AllowInvalid |= ALLOW_INVALID_MIDDLE;
|
2004-10-14 04:47:09 +02:00
|
|
|
else if (!strcasecmp(cp, "introduction"))
|
2006-03-19 02:21:59 +01:00
|
|
|
options->_AllowInvalid |= ALLOW_INVALID_INTRODUCTION;
|
2004-10-14 04:47:09 +02:00
|
|
|
else if (!strcasecmp(cp, "rendezvous"))
|
2006-03-19 02:21:59 +01:00
|
|
|
options->_AllowInvalid |= ALLOW_INVALID_RENDEZVOUS;
|
2004-10-14 04:47:09 +02:00
|
|
|
else {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2006-03-19 02:21:59 +01:00
|
|
|
"Unrecognized value '%s' in AllowInvalidNodes", cp);
|
2006-03-26 08:51:26 +02:00
|
|
|
return -1;
|
2004-10-14 04:47:09 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2009-12-12 07:12:47 +01:00
|
|
|
if (!options->SafeLogging ||
|
|
|
|
!strcasecmp(options->SafeLogging, "0")) {
|
|
|
|
options->_SafeLogging = SAFELOG_SCRUB_NONE;
|
|
|
|
} else if (!strcasecmp(options->SafeLogging, "relay")) {
|
|
|
|
options->_SafeLogging = SAFELOG_SCRUB_RELAY;
|
|
|
|
} else if (!strcasecmp(options->SafeLogging, "1")) {
|
|
|
|
options->_SafeLogging = SAFELOG_SCRUB_ALL;
|
|
|
|
} else {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2009-09-28 15:08:32 +02:00
|
|
|
"Unrecognized value '%s' in SafeLogging",
|
2009-12-12 07:12:47 +01:00
|
|
|
escaped(options->SafeLogging));
|
2009-09-28 15:08:32 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-12-22 10:04:46 +01:00
|
|
|
if (compute_publishserverdescriptor(options) < 0) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg, "Unrecognized value in PublishServerDescriptor");
|
2007-05-08 11:09:26 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-05-13 18:14:29 +02:00
|
|
|
if ((options->BridgeRelay
|
2010-11-08 20:35:02 +01:00
|
|
|
|| options->_PublishServerDescriptor & BRIDGE_DIRINFO)
|
2009-05-13 22:43:51 +02:00
|
|
|
&& (options->_PublishServerDescriptor
|
2010-11-08 20:35:02 +01:00
|
|
|
& (V1_DIRINFO|V2_DIRINFO|V3_DIRINFO))) {
|
2009-05-13 18:14:29 +02:00
|
|
|
REJECT("Bridges are not supposed to publish router descriptors to the "
|
|
|
|
"directory authorities. Please correct your "
|
|
|
|
"PublishServerDescriptor line.");
|
|
|
|
}
|
|
|
|
|
2010-11-22 19:12:48 +01:00
|
|
|
if (options->BridgeRelay && options->DirPort) {
|
|
|
|
log_warn(LD_CONFIG, "Can't set a DirPort on a bridge relay; disabling "
|
|
|
|
"DirPort");
|
|
|
|
options->DirPort = 0;
|
|
|
|
}
|
|
|
|
|
2007-11-29 16:25:04 +01:00
|
|
|
if (options->MinUptimeHidServDirectoryV2 < 0) {
|
|
|
|
log_warn(LD_CONFIG, "MinUptimeHidServDirectoryV2 option must be at "
|
2007-10-29 20:10:42 +01:00
|
|
|
"least 0 seconds. Changing to 0.");
|
2007-11-29 16:25:04 +01:00
|
|
|
options->MinUptimeHidServDirectoryV2 = 0;
|
2007-10-29 20:10:42 +01:00
|
|
|
}
|
|
|
|
|
2004-11-30 03:23:51 +01:00
|
|
|
if (options->RendPostPeriod < MIN_REND_POST_PERIOD) {
|
2009-11-22 13:15:30 +01:00
|
|
|
log_warn(LD_CONFIG, "RendPostPeriod option is too short; "
|
|
|
|
"raising to %d seconds.", MIN_REND_POST_PERIOD);
|
2004-11-30 03:23:51 +01:00
|
|
|
options->RendPostPeriod = MIN_REND_POST_PERIOD;
|
2004-11-15 10:05:54 +01:00
|
|
|
}
|
2004-11-30 03:23:51 +01:00
|
|
|
|
|
|
|
if (options->RendPostPeriod > MAX_DIR_PERIOD) {
|
2009-11-22 13:15:30 +01:00
|
|
|
log_warn(LD_CONFIG, "RendPostPeriod is too large; clipping to %ds.",
|
|
|
|
MAX_DIR_PERIOD);
|
2004-11-30 03:23:51 +01:00
|
|
|
options->RendPostPeriod = MAX_DIR_PERIOD;
|
2004-04-25 00:17:50 +02:00
|
|
|
}
|
2002-11-23 07:49:01 +01:00
|
|
|
|
2008-12-17 23:32:17 +01:00
|
|
|
if (options->MaxCircuitDirtiness < MIN_MAX_CIRCUIT_DIRTINESS) {
|
2009-11-22 13:15:30 +01:00
|
|
|
log_warn(LD_CONFIG, "MaxCircuitDirtiness option is too short; "
|
|
|
|
"raising to %d seconds.", MIN_MAX_CIRCUIT_DIRTINESS);
|
2008-12-17 23:32:17 +01:00
|
|
|
options->MaxCircuitDirtiness = MIN_MAX_CIRCUIT_DIRTINESS;
|
|
|
|
}
|
|
|
|
|
2009-11-22 13:15:30 +01:00
|
|
|
if (options->CircuitStreamTimeout &&
|
|
|
|
options->CircuitStreamTimeout < MIN_CIRCUIT_STREAM_TIMEOUT) {
|
|
|
|
log_warn(LD_CONFIG, "CircuitStreamTimeout option is too short; "
|
|
|
|
"raising to %d seconds.", MIN_CIRCUIT_STREAM_TIMEOUT);
|
|
|
|
options->CircuitStreamTimeout = MIN_CIRCUIT_STREAM_TIMEOUT;
|
|
|
|
}
|
2010-12-01 02:32:42 +01:00
|
|
|
|
2010-12-01 02:24:03 +01:00
|
|
|
if (options->HeartbeatPeriod &&
|
|
|
|
options->HeartbeatPeriod < MIN_HEARTBEAT_PERIOD) {
|
|
|
|
log_warn(LD_CONFIG, "HeartbeatPeriod option is too short; "
|
|
|
|
"raising to %d seconds.", MIN_HEARTBEAT_PERIOD);
|
|
|
|
options->HeartbeatPeriod = MIN_HEARTBEAT_PERIOD;
|
|
|
|
}
|
|
|
|
|
2005-10-25 09:05:03 +02:00
|
|
|
if (options->KeepalivePeriod < 1)
|
|
|
|
REJECT("KeepalivePeriod option must be positive.");
|
2002-11-23 07:49:01 +01:00
|
|
|
|
2007-05-30 09:18:00 +02:00
|
|
|
if (ensure_bandwidth_cap(&options->BandwidthRate,
|
2007-05-04 11:20:13 +02:00
|
|
|
"BandwidthRate", msg) < 0)
|
2006-03-26 08:51:26 +02:00
|
|
|
return -1;
|
2007-05-30 09:18:00 +02:00
|
|
|
if (ensure_bandwidth_cap(&options->BandwidthBurst,
|
2007-05-04 11:20:13 +02:00
|
|
|
"BandwidthBurst", msg) < 0)
|
2006-03-26 08:51:26 +02:00
|
|
|
return -1;
|
2007-05-30 09:18:00 +02:00
|
|
|
if (ensure_bandwidth_cap(&options->MaxAdvertisedBandwidth,
|
2007-05-04 11:20:13 +02:00
|
|
|
"MaxAdvertisedBandwidth", msg) < 0)
|
|
|
|
return -1;
|
2007-05-30 09:18:00 +02:00
|
|
|
if (ensure_bandwidth_cap(&options->RelayBandwidthRate,
|
2007-05-04 11:20:13 +02:00
|
|
|
"RelayBandwidthRate", msg) < 0)
|
|
|
|
return -1;
|
2007-05-30 09:18:00 +02:00
|
|
|
if (ensure_bandwidth_cap(&options->RelayBandwidthBurst,
|
2007-05-04 11:20:13 +02:00
|
|
|
"RelayBandwidthBurst", msg) < 0)
|
|
|
|
return -1;
|
2010-02-25 12:25:57 +01:00
|
|
|
if (ensure_bandwidth_cap(&options->PerConnBWRate,
|
|
|
|
"PerConnBWRate", msg) < 0)
|
|
|
|
return -1;
|
|
|
|
if (ensure_bandwidth_cap(&options->PerConnBWBurst,
|
|
|
|
"PerConnBWBurst", msg) < 0)
|
|
|
|
return -1;
|
2007-05-04 11:20:13 +02:00
|
|
|
|
2011-02-08 05:22:45 +01:00
|
|
|
if (options->RelayBandwidthRate && !options->RelayBandwidthBurst)
|
|
|
|
options->RelayBandwidthBurst = options->RelayBandwidthRate;
|
|
|
|
if (options->RelayBandwidthBurst && !options->RelayBandwidthRate)
|
|
|
|
options->RelayBandwidthRate = options->RelayBandwidthBurst;
|
|
|
|
|
2007-02-25 20:43:23 +01:00
|
|
|
if (server_mode(options)) {
|
2009-04-12 09:56:58 +02:00
|
|
|
if (options->BandwidthRate < ROUTER_REQUIRED_MIN_BANDWIDTH) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2007-02-25 20:43:23 +01:00
|
|
|
"BandwidthRate is set to %d bytes/second. "
|
|
|
|
"For servers, it must be at least %d.",
|
|
|
|
(int)options->BandwidthRate,
|
2009-04-12 09:56:58 +02:00
|
|
|
ROUTER_REQUIRED_MIN_BANDWIDTH);
|
2007-02-25 20:43:23 +01:00
|
|
|
return -1;
|
|
|
|
} else if (options->MaxAdvertisedBandwidth <
|
2009-04-12 09:56:58 +02:00
|
|
|
ROUTER_REQUIRED_MIN_BANDWIDTH/2) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2007-02-25 20:43:23 +01:00
|
|
|
"MaxAdvertisedBandwidth is set to %d bytes/second. "
|
|
|
|
"For servers, it must be at least %d.",
|
|
|
|
(int)options->MaxAdvertisedBandwidth,
|
2009-04-12 09:56:58 +02:00
|
|
|
ROUTER_REQUIRED_MIN_BANDWIDTH/2);
|
2007-02-25 20:43:23 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2007-03-20 03:55:31 +01:00
|
|
|
if (options->RelayBandwidthRate &&
|
|
|
|
options->RelayBandwidthRate < ROUTER_REQUIRED_MIN_BANDWIDTH) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2007-03-20 03:55:31 +01:00
|
|
|
"RelayBandwidthRate is set to %d bytes/second. "
|
|
|
|
"For servers, it must be at least %d.",
|
|
|
|
(int)options->RelayBandwidthRate,
|
|
|
|
ROUTER_REQUIRED_MIN_BANDWIDTH);
|
|
|
|
return -1;
|
|
|
|
}
|
2005-01-18 20:34:22 +01:00
|
|
|
}
|
2007-02-25 20:43:23 +01:00
|
|
|
|
2007-11-17 03:22:56 +01:00
|
|
|
if (options->RelayBandwidthRate > options->RelayBandwidthBurst)
|
|
|
|
REJECT("RelayBandwidthBurst must be at least equal "
|
|
|
|
"to RelayBandwidthRate.");
|
|
|
|
|
2005-10-25 09:05:03 +02:00
|
|
|
if (options->BandwidthRate > options->BandwidthBurst)
|
|
|
|
REJECT("BandwidthBurst must be at least equal to BandwidthRate.");
|
2004-11-09 02:24:10 +01:00
|
|
|
|
2008-03-10 08:50:09 +01:00
|
|
|
/* if they set relaybandwidth* really high but left bandwidth*
|
|
|
|
* at the default, raise the defaults. */
|
|
|
|
if (options->RelayBandwidthRate > options->BandwidthRate)
|
|
|
|
options->BandwidthRate = options->RelayBandwidthRate;
|
|
|
|
if (options->RelayBandwidthBurst > options->BandwidthBurst)
|
|
|
|
options->BandwidthBurst = options->RelayBandwidthBurst;
|
|
|
|
|
2006-03-26 08:51:26 +02:00
|
|
|
if (accounting_parse_options(options, 1)<0)
|
|
|
|
REJECT("Failed to parse accounting options. See logs for details.");
|
2004-11-03 00:47:32 +01:00
|
|
|
|
2010-10-29 19:41:24 +02:00
|
|
|
if (options->HTTPProxy) { /* parse it now */
|
|
|
|
if (tor_addr_port_parse(options->HTTPProxy,
|
|
|
|
&options->HTTPProxyAddr, &options->HTTPProxyPort) < 0)
|
|
|
|
REJECT("HTTPProxy failed to parse or resolve. Please fix.");
|
|
|
|
if (options->HTTPProxyPort == 0) { /* give it a default */
|
|
|
|
options->HTTPProxyPort = 80;
|
2004-10-12 22:22:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-29 19:41:24 +02:00
|
|
|
if (options->HTTPProxyAuthenticator) {
|
2011-05-16 22:09:35 +02:00
|
|
|
if (strlen(options->HTTPProxyAuthenticator) >= 512)
|
|
|
|
REJECT("HTTPProxyAuthenticator is too long (>= 512 chars).");
|
2005-05-20 10:51:45 +02:00
|
|
|
}
|
|
|
|
|
2010-10-29 19:41:24 +02:00
|
|
|
if (options->HTTPSProxy) { /* parse it now */
|
|
|
|
if (tor_addr_port_parse(options->HTTPSProxy,
|
|
|
|
&options->HTTPSProxyAddr, &options->HTTPSProxyPort) <0)
|
|
|
|
REJECT("HTTPSProxy failed to parse or resolve. Please fix.");
|
|
|
|
if (options->HTTPSProxyPort == 0) { /* give it a default */
|
|
|
|
options->HTTPSProxyPort = 443;
|
2005-02-24 11:56:55 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-29 19:41:24 +02:00
|
|
|
if (options->HTTPSProxyAuthenticator) {
|
2011-05-16 22:09:35 +02:00
|
|
|
if (strlen(options->HTTPSProxyAuthenticator) >= 512)
|
|
|
|
REJECT("HTTPSProxyAuthenticator is too long (>= 512 chars).");
|
2005-04-26 20:33:33 +02:00
|
|
|
}
|
|
|
|
|
2009-06-19 01:59:18 +02:00
|
|
|
if (options->Socks4Proxy) { /* parse it now */
|
2009-06-19 18:48:00 +02:00
|
|
|
if (tor_addr_port_parse(options->Socks4Proxy,
|
2009-06-19 01:59:18 +02:00
|
|
|
&options->Socks4ProxyAddr,
|
|
|
|
&options->Socks4ProxyPort) <0)
|
|
|
|
REJECT("Socks4Proxy failed to parse or resolve. Please fix.");
|
|
|
|
if (options->Socks4ProxyPort == 0) { /* give it a default */
|
|
|
|
options->Socks4ProxyPort = 1080;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (options->Socks5Proxy) { /* parse it now */
|
2009-06-19 18:48:00 +02:00
|
|
|
if (tor_addr_port_parse(options->Socks5Proxy,
|
|
|
|
&options->Socks5ProxyAddr,
|
|
|
|
&options->Socks5ProxyPort) <0)
|
2009-06-19 01:59:18 +02:00
|
|
|
REJECT("Socks5Proxy failed to parse or resolve. Please fix.");
|
|
|
|
if (options->Socks5ProxyPort == 0) { /* give it a default */
|
|
|
|
options->Socks5ProxyPort = 1080;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-26 17:34:45 +02:00
|
|
|
if (options->Socks4Proxy && options->Socks5Proxy)
|
|
|
|
REJECT("You cannot specify both Socks4Proxy and SOCKS5Proxy");
|
|
|
|
|
2009-06-19 01:59:18 +02:00
|
|
|
if (options->Socks5ProxyUsername) {
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
len = strlen(options->Socks5ProxyUsername);
|
|
|
|
if (len < 1 || len > 255)
|
|
|
|
REJECT("Socks5ProxyUsername must be between 1 and 255 characters.");
|
|
|
|
|
|
|
|
if (!options->Socks5ProxyPassword)
|
|
|
|
REJECT("Socks5ProxyPassword must be included with Socks5ProxyUsername.");
|
|
|
|
|
|
|
|
len = strlen(options->Socks5ProxyPassword);
|
|
|
|
if (len < 1 || len > 255)
|
|
|
|
REJECT("Socks5ProxyPassword must be between 1 and 255 characters.");
|
|
|
|
} else if (options->Socks5ProxyPassword)
|
|
|
|
REJECT("Socks5ProxyPassword must be included with Socks5ProxyUsername.");
|
|
|
|
|
2004-11-12 17:39:03 +01:00
|
|
|
if (options->HashedControlPassword) {
|
2007-12-09 05:59:27 +01:00
|
|
|
smartlist_t *sl = decode_hashed_passwords(options->HashedControlPassword);
|
|
|
|
if (!sl) {
|
2005-10-25 09:05:03 +02:00
|
|
|
REJECT("Bad HashedControlPassword: wrong length or bad encoding");
|
2007-12-09 05:59:27 +01:00
|
|
|
} else {
|
|
|
|
SMARTLIST_FOREACH(sl, char*, cp, tor_free(cp));
|
|
|
|
smartlist_free(sl);
|
|
|
|
}
|
2004-11-13 18:17:04 +01:00
|
|
|
}
|
|
|
|
|
2008-02-17 19:45:07 +01:00
|
|
|
if (options->HashedControlSessionPassword) {
|
|
|
|
smartlist_t *sl = decode_hashed_passwords(
|
|
|
|
options->HashedControlSessionPassword);
|
|
|
|
if (!sl) {
|
|
|
|
REJECT("Bad HashedControlSessionPassword: wrong length or bad encoding");
|
|
|
|
} else {
|
|
|
|
SMARTLIST_FOREACH(sl, char*, cp, tor_free(cp));
|
|
|
|
smartlist_free(sl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-15 17:23:04 +02:00
|
|
|
if (options->OwningControllerProcess) {
|
|
|
|
const char *validate_pspec_msg = NULL;
|
|
|
|
if (tor_validate_process_specifier(options->OwningControllerProcess,
|
|
|
|
&validate_pspec_msg)) {
|
|
|
|
tor_asprintf(msg, "Bad OwningControllerProcess: %s",
|
|
|
|
validate_pspec_msg);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-02 23:03:40 +02:00
|
|
|
if (options->ControlListenAddress) {
|
|
|
|
int all_are_local = 1;
|
|
|
|
config_line_t *ln;
|
|
|
|
for (ln = options->ControlListenAddress; ln; ln = ln->next) {
|
|
|
|
if (strcmpstart(ln->value, "127."))
|
|
|
|
all_are_local = 0;
|
|
|
|
}
|
|
|
|
if (!all_are_local) {
|
2008-02-17 19:45:07 +01:00
|
|
|
if (!options->HashedControlPassword &&
|
|
|
|
!options->HashedControlSessionPassword &&
|
|
|
|
!options->CookieAuthentication) {
|
2009-01-06 17:57:42 +01:00
|
|
|
log_warn(LD_CONFIG,
|
|
|
|
"You have a ControlListenAddress set to accept "
|
|
|
|
"unauthenticated connections from a non-local address. "
|
|
|
|
"This means that programs not running on your computer "
|
|
|
|
"can reconfigure your Tor, without even having to guess a "
|
|
|
|
"password. That's so bad that I'm closing your ControlPort "
|
|
|
|
"for you. If you need to control your Tor remotely, try "
|
|
|
|
"enabling authentication and using a tool like stunnel or "
|
|
|
|
"ssh to encrypt remote access.");
|
2007-08-02 23:03:40 +02:00
|
|
|
options->ControlPort = 0;
|
|
|
|
} else {
|
|
|
|
log_warn(LD_CONFIG, "You have a ControlListenAddress set to accept "
|
|
|
|
"connections from a non-local address. This means that "
|
|
|
|
"programs not running on your computer can reconfigure your "
|
2009-01-06 17:57:42 +01:00
|
|
|
"Tor. That's pretty bad, since the controller "
|
|
|
|
"protocol isn't encrypted! Maybe you should just listen on "
|
|
|
|
"127.0.0.1 and use a tool like stunnel or ssh to encrypt "
|
|
|
|
"remote connections to your control port.");
|
2007-08-02 23:03:40 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (options->ControlPort && !options->HashedControlPassword &&
|
2008-02-17 19:45:07 +01:00
|
|
|
!options->HashedControlSessionPassword &&
|
2007-08-02 23:03:40 +02:00
|
|
|
!options->CookieAuthentication) {
|
|
|
|
log_warn(LD_CONFIG, "ControlPort is open, but no authentication method "
|
|
|
|
"has been configured. This means that any program on your "
|
|
|
|
"computer can reconfigure your Tor. That's bad! You should "
|
|
|
|
"upgrade your Tor controller as soon as possible.");
|
|
|
|
}
|
|
|
|
|
2010-08-20 02:42:17 +02:00
|
|
|
if (options->CookieAuthFileGroupReadable && !options->CookieAuthFile) {
|
2011-04-29 17:14:53 +02:00
|
|
|
log_warn(LD_CONFIG, "CookieAuthFileGroupReadable is set, but will have "
|
|
|
|
"no effect: you must specify an explicit CookieAuthFile to "
|
|
|
|
"have it group-readable.");
|
2010-08-20 02:42:17 +02:00
|
|
|
}
|
|
|
|
|
2006-01-10 23:42:44 +01:00
|
|
|
if (options->UseEntryGuards && ! options->NumEntryGuards)
|
|
|
|
REJECT("Cannot enable UseEntryGuards with NumEntryGuards set to 0");
|
2005-07-22 16:55:09 +02:00
|
|
|
|
2006-03-26 08:51:26 +02:00
|
|
|
if (check_nickname_list(options->MyFamily, "MyFamily", msg))
|
|
|
|
return -1;
|
2004-10-15 22:52:09 +02:00
|
|
|
for (cl = options->NodeFamilies; cl; cl = cl->next) {
|
2010-10-01 00:25:25 +02:00
|
|
|
routerset_t *rs = routerset_new();
|
|
|
|
if (routerset_parse(rs, cl->value, cl->key)) {
|
|
|
|
routerset_free(rs);
|
2006-03-26 08:51:26 +02:00
|
|
|
return -1;
|
2010-10-01 00:25:25 +02:00
|
|
|
}
|
|
|
|
routerset_free(rs);
|
2004-10-15 22:52:09 +02:00
|
|
|
}
|
|
|
|
|
2006-03-27 04:25:34 +02:00
|
|
|
if (validate_addr_policies(options, msg) < 0)
|
|
|
|
return -1;
|
2004-11-12 20:39:13 +01:00
|
|
|
|
2007-12-12 05:38:54 +01:00
|
|
|
if (validate_dir_authorities(options, old_options) < 0)
|
|
|
|
REJECT("Directory authority line did not parse. See logs for details.");
|
2004-10-12 17:55:20 +02:00
|
|
|
|
2007-06-12 11:17:23 +02:00
|
|
|
if (options->UseBridges && !options->TunnelDirConns)
|
2011-05-31 05:32:38 +02:00
|
|
|
REJECT("TunnelDirConns set to 0 only works with UseBridges set to 0");
|
2007-05-08 13:28:05 +02:00
|
|
|
if (options->Bridges) {
|
|
|
|
for (cl = options->Bridges; cl; cl = cl->next) {
|
|
|
|
if (parse_bridge_line(cl->value, 1)<0)
|
|
|
|
REJECT("Bridge line did not parse. See logs for details.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-16 18:23:34 +02:00
|
|
|
if (options->ConstrainedSockets) {
|
|
|
|
/* If the user wants to constrain socket buffer use, make sure the desired
|
|
|
|
* limit is between MIN|MAX_TCPSOCK_BUFFER in k increments. */
|
2007-07-16 18:23:36 +02:00
|
|
|
if (options->ConstrainedSockSize < MIN_CONSTRAINED_TCP_BUFFER ||
|
|
|
|
options->ConstrainedSockSize > MAX_CONSTRAINED_TCP_BUFFER ||
|
|
|
|
options->ConstrainedSockSize % 1024) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2007-07-16 18:23:34 +02:00
|
|
|
"ConstrainedSockSize is invalid. Must be a value between %d and %d "
|
|
|
|
"in 1024 byte increments.",
|
2007-07-16 18:23:36 +02:00
|
|
|
MIN_CONSTRAINED_TCP_BUFFER, MAX_CONSTRAINED_TCP_BUFFER);
|
2007-07-16 18:23:34 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (options->DirPort) {
|
|
|
|
/* Providing cached directory entries while system TCP buffers are scarce
|
|
|
|
* will exacerbate the socket errors. Suggest that this be disabled. */
|
|
|
|
COMPLAIN("You have requested constrained socket buffers while also "
|
|
|
|
"serving directory entries via DirPort. It is strongly "
|
|
|
|
"suggested that you disable serving directory requests when "
|
|
|
|
"system TCP buffer resources are scarce.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-14 22:19:40 +02:00
|
|
|
if (options->V3AuthVoteDelay + options->V3AuthDistDelay >=
|
|
|
|
options->V3AuthVotingInterval/2) {
|
2008-02-06 13:46:17 +01:00
|
|
|
REJECT("V3AuthVoteDelay plus V3AuthDistDelay must be less than half "
|
2007-08-14 22:19:40 +02:00
|
|
|
"V3AuthVotingInterval");
|
|
|
|
}
|
2007-08-15 17:38:58 +02:00
|
|
|
if (options->V3AuthVoteDelay < MIN_VOTE_SECONDS)
|
|
|
|
REJECT("V3AuthVoteDelay is way too low.");
|
|
|
|
if (options->V3AuthDistDelay < MIN_DIST_SECONDS)
|
|
|
|
REJECT("V3AuthDistDelay is way too low.");
|
|
|
|
|
|
|
|
if (options->V3AuthNIntervalsValid < 2)
|
2007-08-14 22:19:40 +02:00
|
|
|
REJECT("V3AuthNIntervalsValid must be at least 2.");
|
|
|
|
|
2007-10-11 18:06:42 +02:00
|
|
|
if (options->V3AuthVotingInterval < MIN_VOTE_INTERVAL) {
|
2007-08-14 22:19:40 +02:00
|
|
|
REJECT("V3AuthVotingInterval is insanely low.");
|
|
|
|
} else if (options->V3AuthVotingInterval > 24*60*60) {
|
|
|
|
REJECT("V3AuthVotingInterval is insanely high.");
|
|
|
|
} else if (((24*60*60) % options->V3AuthVotingInterval) != 0) {
|
|
|
|
COMPLAIN("V3AuthVotingInterval does not divide evenly into 24 hours.");
|
|
|
|
}
|
|
|
|
|
2004-11-09 00:12:40 +01:00
|
|
|
if (rend_config_services(options, 1) < 0)
|
2006-03-26 08:51:26 +02:00
|
|
|
REJECT("Failed to configure rendezvous options. See logs for details.");
|
2004-11-09 00:12:40 +01:00
|
|
|
|
2008-08-12 18:12:26 +02:00
|
|
|
/* Parse client-side authorization for hidden services. */
|
|
|
|
if (rend_parse_service_authorization(options, 1) < 0)
|
|
|
|
REJECT("Failed to configure client authorization for hidden services. "
|
|
|
|
"See logs for details.");
|
|
|
|
|
2006-04-18 05:51:18 +02:00
|
|
|
if (parse_virtual_addr_network(options->VirtualAddrNetwork, 1, NULL)<0)
|
2006-04-18 05:36:28 +02:00
|
|
|
return -1;
|
|
|
|
|
2007-01-03 07:33:03 +01:00
|
|
|
if (options->PreferTunneledDirConns && !options->TunnelDirConns)
|
|
|
|
REJECT("Must set TunnelDirConns if PreferTunneledDirConns is set.");
|
|
|
|
|
2009-06-19 01:59:18 +02:00
|
|
|
if ((options->Socks4Proxy || options->Socks5Proxy) &&
|
2010-10-29 19:41:24 +02:00
|
|
|
!options->HTTPProxy && !options->PreferTunneledDirConns)
|
2009-06-19 01:59:18 +02:00
|
|
|
REJECT("When Socks4Proxy or Socks5Proxy is configured, "
|
|
|
|
"PreferTunneledDirConns and TunnelDirConns must both be "
|
2010-10-29 19:41:24 +02:00
|
|
|
"set to 1, or HTTPProxy must be configured.");
|
2009-06-19 01:59:18 +02:00
|
|
|
|
2007-05-25 16:48:16 +02:00
|
|
|
if (options->AutomapHostsSuffixes) {
|
|
|
|
SMARTLIST_FOREACH(options->AutomapHostsSuffixes, char *, suf,
|
|
|
|
{
|
|
|
|
size_t len = strlen(suf);
|
|
|
|
if (len && suf[len-1] == '.')
|
|
|
|
suf[len-1] = '\0';
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2008-06-14 18:01:29 +02:00
|
|
|
if (options->TestingTorNetwork && !options->DirServers) {
|
|
|
|
REJECT("TestingTorNetwork may only be configured in combination with "
|
|
|
|
"a non-default set of DirServers.");
|
|
|
|
}
|
|
|
|
|
2010-11-16 06:13:25 +01:00
|
|
|
if (options->AllowSingleHopExits && !options->DirServers) {
|
|
|
|
COMPLAIN("You have set AllowSingleHopExits; now your relay will allow "
|
|
|
|
"others to make one-hop exits. However, since by default most "
|
|
|
|
"clients avoid relays that set this option, most clients will "
|
|
|
|
"ignore you.");
|
|
|
|
}
|
|
|
|
|
2011-03-25 21:01:16 +01:00
|
|
|
/*XXXX023 checking for defaults manually like this is a bit fragile.*/
|
2008-06-14 18:11:37 +02:00
|
|
|
|
2008-06-14 18:01:29 +02:00
|
|
|
/* Keep changes to hard-coded values synchronous to man page and default
|
|
|
|
* values table. */
|
2008-06-20 19:03:13 +02:00
|
|
|
if (options->TestingV3AuthInitialVotingInterval != 30*60 &&
|
2011-03-01 10:05:18 +01:00
|
|
|
!options->TestingTorNetwork && !options->_UsingTestNetworkDefaults) {
|
2008-06-20 19:03:13 +02:00
|
|
|
REJECT("TestingV3AuthInitialVotingInterval may only be changed in testing "
|
2008-06-14 18:01:29 +02:00
|
|
|
"Tor networks!");
|
2008-06-20 19:03:13 +02:00
|
|
|
} else if (options->TestingV3AuthInitialVotingInterval < MIN_VOTE_INTERVAL) {
|
|
|
|
REJECT("TestingV3AuthInitialVotingInterval is insanely low.");
|
|
|
|
} else if (((30*60) % options->TestingV3AuthInitialVotingInterval) != 0) {
|
|
|
|
REJECT("TestingV3AuthInitialVotingInterval does not divide evenly into "
|
2008-06-14 18:01:29 +02:00
|
|
|
"30 minutes.");
|
|
|
|
}
|
|
|
|
|
2008-06-20 19:03:13 +02:00
|
|
|
if (options->TestingV3AuthInitialVoteDelay != 5*60 &&
|
2011-03-01 10:05:18 +01:00
|
|
|
!options->TestingTorNetwork && !options->_UsingTestNetworkDefaults) {
|
2011-02-26 09:06:09 +01:00
|
|
|
|
2008-06-20 19:03:13 +02:00
|
|
|
REJECT("TestingV3AuthInitialVoteDelay may only be changed in testing "
|
2008-06-14 18:01:29 +02:00
|
|
|
"Tor networks!");
|
2008-06-20 19:03:13 +02:00
|
|
|
} else if (options->TestingV3AuthInitialVoteDelay < MIN_VOTE_SECONDS) {
|
|
|
|
REJECT("TestingV3AuthInitialVoteDelay is way too low.");
|
2008-06-14 18:01:29 +02:00
|
|
|
}
|
|
|
|
|
2008-06-20 19:03:13 +02:00
|
|
|
if (options->TestingV3AuthInitialDistDelay != 5*60 &&
|
2011-03-01 10:05:18 +01:00
|
|
|
!options->TestingTorNetwork && !options->_UsingTestNetworkDefaults) {
|
2008-06-20 19:03:13 +02:00
|
|
|
REJECT("TestingV3AuthInitialDistDelay may only be changed in testing "
|
2008-06-14 18:01:29 +02:00
|
|
|
"Tor networks!");
|
2008-06-20 19:03:13 +02:00
|
|
|
} else if (options->TestingV3AuthInitialDistDelay < MIN_DIST_SECONDS) {
|
|
|
|
REJECT("TestingV3AuthInitialDistDelay is way too low.");
|
2008-06-14 18:01:29 +02:00
|
|
|
}
|
|
|
|
|
2008-06-20 19:03:13 +02:00
|
|
|
if (options->TestingV3AuthInitialVoteDelay +
|
|
|
|
options->TestingV3AuthInitialDistDelay >=
|
|
|
|
options->TestingV3AuthInitialVotingInterval/2) {
|
|
|
|
REJECT("TestingV3AuthInitialVoteDelay plus TestingV3AuthInitialDistDelay "
|
|
|
|
"must be less than half TestingV3AuthInitialVotingInterval");
|
2008-06-14 18:01:29 +02:00
|
|
|
}
|
|
|
|
|
2008-06-20 19:03:13 +02:00
|
|
|
if (options->TestingAuthDirTimeToLearnReachability != 30*60 &&
|
2011-03-01 10:05:18 +01:00
|
|
|
!options->TestingTorNetwork && !options->_UsingTestNetworkDefaults) {
|
2008-06-20 19:03:13 +02:00
|
|
|
REJECT("TestingAuthDirTimeToLearnReachability may only be changed in "
|
|
|
|
"testing Tor networks!");
|
|
|
|
} else if (options->TestingAuthDirTimeToLearnReachability < 0) {
|
|
|
|
REJECT("TestingAuthDirTimeToLearnReachability must be non-negative.");
|
|
|
|
} else if (options->TestingAuthDirTimeToLearnReachability > 2*60*60) {
|
|
|
|
COMPLAIN("TestingAuthDirTimeToLearnReachability is insanely high.");
|
2008-06-14 18:01:29 +02:00
|
|
|
}
|
|
|
|
|
2008-06-20 19:03:13 +02:00
|
|
|
if (options->TestingEstimatedDescriptorPropagationTime != 10*60 &&
|
2011-03-01 10:05:18 +01:00
|
|
|
!options->TestingTorNetwork && !options->_UsingTestNetworkDefaults) {
|
2008-06-20 19:03:13 +02:00
|
|
|
REJECT("TestingEstimatedDescriptorPropagationTime may only be changed in "
|
2008-06-14 18:01:29 +02:00
|
|
|
"testing Tor networks!");
|
2008-06-20 19:03:13 +02:00
|
|
|
} else if (options->TestingEstimatedDescriptorPropagationTime < 0) {
|
|
|
|
REJECT("TestingEstimatedDescriptorPropagationTime must be non-negative.");
|
|
|
|
} else if (options->TestingEstimatedDescriptorPropagationTime > 60*60) {
|
|
|
|
COMPLAIN("TestingEstimatedDescriptorPropagationTime is insanely high.");
|
2008-06-14 18:01:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (options->TestingTorNetwork) {
|
|
|
|
log_warn(LD_CONFIG, "TestingTorNetwork is set. This will make your node "
|
|
|
|
"almost unusable in the public Tor network, and is "
|
|
|
|
"therefore only advised if you are building a "
|
|
|
|
"testing Tor network!");
|
|
|
|
}
|
|
|
|
|
2009-05-24 01:42:44 +02:00
|
|
|
if (options->AccelName && !options->HardwareAccel)
|
|
|
|
options->HardwareAccel = 1;
|
|
|
|
if (options->AccelDir && !options->AccelName)
|
|
|
|
REJECT("Can't use hardware crypto accelerator dir without engine name.");
|
|
|
|
|
2010-08-01 00:06:40 +02:00
|
|
|
if (options->PublishServerDescriptor)
|
|
|
|
SMARTLIST_FOREACH(options->PublishServerDescriptor, const char *, pubdes, {
|
|
|
|
if (!strcmp(pubdes, "1") || !strcmp(pubdes, "0"))
|
|
|
|
if (smartlist_len(options->PublishServerDescriptor) > 1) {
|
|
|
|
COMPLAIN("You have passed a list of multiple arguments to the "
|
|
|
|
"PublishServerDescriptor option that includes 0 or 1. "
|
|
|
|
"0 or 1 should only be used as the sole argument. "
|
|
|
|
"This configuration will be rejected in a future release.");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2010-08-01 01:42:29 +02:00
|
|
|
if (options->BridgeRelay == 1 && options->ORPort == 0)
|
|
|
|
REJECT("BridgeRelay is 1, ORPort is 0. This is an invalid combination.");
|
|
|
|
|
2006-03-26 08:51:26 +02:00
|
|
|
return 0;
|
2005-10-25 09:05:03 +02:00
|
|
|
#undef REJECT
|
|
|
|
#undef COMPLAIN
|
2004-11-04 11:23:30 +01:00
|
|
|
}
|
|
|
|
|
2004-11-10 04:40:30 +01:00
|
|
|
/** Helper: return true iff s1 and s2 are both NULL, or both non-NULL
|
|
|
|
* equal strings. */
|
|
|
|
static int
|
|
|
|
opt_streq(const char *s1, const char *s2)
|
|
|
|
{
|
|
|
|
if (!s1 && !s2)
|
|
|
|
return 1;
|
|
|
|
else if (s1 && s2 && !strcmp(s1,s2))
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-11-06 06:18:11 +01:00
|
|
|
/** Check if any of the previous options have changed but aren't allowed to. */
|
|
|
|
static int
|
2006-03-26 08:51:26 +02:00
|
|
|
options_transition_allowed(or_options_t *old, or_options_t *new_val,
|
|
|
|
char **msg)
|
2005-06-11 20:52:12 +02:00
|
|
|
{
|
2004-11-28 10:05:49 +01:00
|
|
|
if (!old)
|
2004-11-06 06:18:11 +01:00
|
|
|
return 0;
|
|
|
|
|
2004-11-10 04:40:30 +01:00
|
|
|
if (!opt_streq(old->PidFile, new_val->PidFile)) {
|
2006-03-26 08:51:26 +02:00
|
|
|
*msg = tor_strdup("PidFile is not allowed to change.");
|
2004-11-06 06:18:11 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-05-03 12:04:08 +02:00
|
|
|
if (old->RunAsDaemon != new_val->RunAsDaemon) {
|
2006-03-26 08:51:26 +02:00
|
|
|
*msg = tor_strdup("While Tor is running, changing RunAsDaemon "
|
|
|
|
"is not allowed.");
|
2004-11-06 06:18:11 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2004-11-09 08:20:21 +01:00
|
|
|
if (strcmp(old->DataDirectory,new_val->DataDirectory)!=0) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg,
|
2006-03-26 08:51:26 +02:00
|
|
|
"While Tor is running, changing DataDirectory "
|
|
|
|
"(\"%s\"->\"%s\") is not allowed.",
|
|
|
|
old->DataDirectory, new_val->DataDirectory);
|
2004-11-09 05:46:24 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2004-11-10 04:40:30 +01:00
|
|
|
if (!opt_streq(old->User, new_val->User)) {
|
2006-03-26 08:51:26 +02:00
|
|
|
*msg = tor_strdup("While Tor is running, changing User is not allowed.");
|
2004-11-10 04:40:30 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-05-24 01:42:44 +02:00
|
|
|
if ((old->HardwareAccel != new_val->HardwareAccel)
|
2009-05-31 19:36:18 +02:00
|
|
|
|| !opt_streq(old->AccelName, new_val->AccelName)
|
|
|
|
|| !opt_streq(old->AccelDir, new_val->AccelDir)) {
|
2009-05-24 01:42:44 +02:00
|
|
|
*msg = tor_strdup("While Tor is running, changing OpenSSL hardware "
|
|
|
|
"acceleration engine is not allowed.");
|
2005-06-20 20:56:35 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-06-14 18:01:29 +02:00
|
|
|
if (old->TestingTorNetwork != new_val->TestingTorNetwork) {
|
|
|
|
*msg = tor_strdup("While Tor is running, changing TestingTorNetwork "
|
|
|
|
"is not allowed.");
|
2009-08-19 15:41:12 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-10-22 06:21:57 +02:00
|
|
|
if (old->DisableAllSwap != new_val->DisableAllSwap) {
|
|
|
|
*msg = tor_strdup("While Tor is running, changing DisableAllSwap "
|
|
|
|
"is not allowed.");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2004-11-06 06:18:11 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-08-22 08:45:18 +02:00
|
|
|
/** Return 1 if any change from <b>old_options</b> to <b>new_options</b>
|
2009-05-27 23:55:51 +02:00
|
|
|
* will require us to rotate the CPU and DNS workers; else return 0. */
|
2005-08-22 02:18:45 +02:00
|
|
|
static int
|
|
|
|
options_transition_affects_workers(or_options_t *old_options,
|
|
|
|
or_options_t *new_options)
|
2005-08-16 01:46:18 +02:00
|
|
|
{
|
2005-08-22 02:18:45 +02:00
|
|
|
if (!opt_streq(old_options->DataDirectory, new_options->DataDirectory) ||
|
2010-10-29 19:41:24 +02:00
|
|
|
old_options->NumCPUs != new_options->NumCPUs ||
|
2005-08-22 02:18:45 +02:00
|
|
|
old_options->ORPort != new_options->ORPort ||
|
2006-09-21 23:48:16 +02:00
|
|
|
old_options->ServerDNSSearchDomains !=
|
|
|
|
new_options->ServerDNSSearchDomains ||
|
2011-05-21 19:10:11 +02:00
|
|
|
old_options->_SafeLogging != new_options->_SafeLogging ||
|
2007-02-09 01:22:43 +01:00
|
|
|
old_options->ClientOnly != new_options->ClientOnly ||
|
2011-01-25 15:28:58 +01:00
|
|
|
public_server_mode(old_options) != public_server_mode(new_options) ||
|
2011-01-25 21:53:15 +01:00
|
|
|
!config_lines_eq(old_options->Logs, new_options->Logs) ||
|
|
|
|
old_options->LogMessageDomains != new_options->LogMessageDomains)
|
2005-08-22 02:18:45 +02:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* Check whether log options match. */
|
|
|
|
|
|
|
|
/* Nothing that changed matters. */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-08-22 08:45:18 +02:00
|
|
|
/** Return 1 if any change from <b>old_options</b> to <b>new_options</b>
|
|
|
|
* will require us to generate a new descriptor; else return 0. */
|
2005-08-22 02:18:45 +02:00
|
|
|
static int
|
|
|
|
options_transition_affects_descriptor(or_options_t *old_options,
|
|
|
|
or_options_t *new_options)
|
|
|
|
{
|
2008-12-18 17:11:24 +01:00
|
|
|
/* XXX We can be smarter here. If your DirPort isn't being
|
2009-07-07 18:04:00 +02:00
|
|
|
* published and you just turned it off, no need to republish. Etc. */
|
2005-08-22 02:18:45 +02:00
|
|
|
if (!opt_streq(old_options->DataDirectory, new_options->DataDirectory) ||
|
|
|
|
!opt_streq(old_options->Nickname,new_options->Nickname) ||
|
|
|
|
!opt_streq(old_options->Address,new_options->Address) ||
|
|
|
|
!config_lines_eq(old_options->ExitPolicy,new_options->ExitPolicy) ||
|
2007-11-17 03:22:56 +01:00
|
|
|
old_options->ExitPolicyRejectPrivate !=
|
|
|
|
new_options->ExitPolicyRejectPrivate ||
|
2005-08-22 02:18:45 +02:00
|
|
|
old_options->ORPort != new_options->ORPort ||
|
|
|
|
old_options->DirPort != new_options->DirPort ||
|
|
|
|
old_options->ClientOnly != new_options->ClientOnly ||
|
2007-05-08 11:09:26 +02:00
|
|
|
old_options->_PublishServerDescriptor !=
|
|
|
|
new_options->_PublishServerDescriptor ||
|
2009-07-07 18:04:00 +02:00
|
|
|
get_effective_bwrate(old_options) != get_effective_bwrate(new_options) ||
|
|
|
|
get_effective_bwburst(old_options) !=
|
|
|
|
get_effective_bwburst(new_options) ||
|
2005-08-22 02:18:45 +02:00
|
|
|
!opt_streq(old_options->ContactInfo, new_options->ContactInfo) ||
|
|
|
|
!opt_streq(old_options->MyFamily, new_options->MyFamily) ||
|
|
|
|
!opt_streq(old_options->AccountingStart, new_options->AccountingStart) ||
|
|
|
|
old_options->AccountingMax != new_options->AccountingMax)
|
|
|
|
return 1;
|
|
|
|
|
2005-08-16 01:46:18 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-11-06 06:18:11 +01:00
|
|
|
#ifdef MS_WINDOWS
|
2004-11-09 00:12:40 +01:00
|
|
|
/** Return the directory on windows where we expect to find our application
|
|
|
|
* data. */
|
2005-06-11 20:52:12 +02:00
|
|
|
static char *
|
|
|
|
get_windows_conf_root(void)
|
2004-11-06 06:18:11 +01:00
|
|
|
{
|
|
|
|
static int is_set = 0;
|
|
|
|
static char path[MAX_PATH+1];
|
2010-08-20 18:30:25 +02:00
|
|
|
TCHAR tpath[MAX_PATH] = {0};
|
2004-11-06 06:18:11 +01:00
|
|
|
|
|
|
|
LPITEMIDLIST idl;
|
|
|
|
IMalloc *m;
|
|
|
|
HRESULT result;
|
|
|
|
|
|
|
|
if (is_set)
|
|
|
|
return path;
|
|
|
|
|
2004-12-01 04:48:14 +01:00
|
|
|
/* Find X:\documents and settings\username\application data\ .
|
2004-11-06 06:18:11 +01:00
|
|
|
* We would use SHGetSpecialFolder path, but that wasn't added until IE4.
|
|
|
|
*/
|
2009-01-16 00:07:11 +01:00
|
|
|
#ifdef ENABLE_LOCAL_APPDATA
|
|
|
|
#define APPDATA_PATH CSIDL_LOCAL_APPDATA
|
|
|
|
#else
|
|
|
|
#define APPDATA_PATH CSIDL_APPDATA
|
|
|
|
#endif
|
|
|
|
if (!SUCCEEDED(SHGetSpecialFolderLocation(NULL, APPDATA_PATH, &idl))) {
|
2010-05-21 04:53:39 +02:00
|
|
|
getcwd(path,MAX_PATH);
|
2004-11-06 06:18:11 +01:00
|
|
|
is_set = 1;
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG,
|
|
|
|
"I couldn't find your application data folder: are you "
|
|
|
|
"running an ancient version of Windows 95? Defaulting to \"%s\"",
|
|
|
|
path);
|
2004-11-06 06:18:11 +01:00
|
|
|
return path;
|
|
|
|
}
|
|
|
|
/* Convert the path from an "ID List" (whatever that is!) to a path. */
|
2010-08-20 18:30:25 +02:00
|
|
|
result = SHGetPathFromIDList(idl, tpath);
|
|
|
|
#ifdef UNICODE
|
|
|
|
wcstombs(path,tpath,MAX_PATH);
|
|
|
|
#else
|
|
|
|
strlcpy(path,tpath,sizeof(path));
|
|
|
|
#endif
|
2010-05-21 04:53:39 +02:00
|
|
|
|
2010-06-15 00:32:44 +02:00
|
|
|
/* Now we need to free the memory that the path-idl was stored in. In
|
|
|
|
* typical Windows fashion, we can't just call 'free()' on it. */
|
2004-11-06 06:18:11 +01:00
|
|
|
SHGetMalloc(&m);
|
|
|
|
if (m) {
|
|
|
|
m->lpVtbl->Free(m, idl);
|
|
|
|
m->lpVtbl->Release(m);
|
|
|
|
}
|
|
|
|
if (!SUCCEEDED(result)) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
strlcat(path,"\\tor",MAX_PATH);
|
|
|
|
is_set = 1;
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2004-11-09 00:12:40 +01:00
|
|
|
/** Return the default location for our torrc file. */
|
2005-08-10 20:05:20 +02:00
|
|
|
static const char *
|
2004-11-06 06:18:11 +01:00
|
|
|
get_default_conf_file(void)
|
|
|
|
{
|
|
|
|
#ifdef MS_WINDOWS
|
2005-08-10 20:05:20 +02:00
|
|
|
static char path[MAX_PATH+1];
|
2004-11-06 06:18:11 +01:00
|
|
|
strlcpy(path, get_windows_conf_root(), MAX_PATH);
|
|
|
|
strlcat(path,"\\torrc",MAX_PATH);
|
|
|
|
return path;
|
|
|
|
#else
|
2005-08-10 20:05:20 +02:00
|
|
|
return (CONFDIR "/torrc");
|
2004-11-06 06:18:11 +01:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-10-01 05:41:33 +02:00
|
|
|
/** Verify whether lst is a string containing valid-looking comma-separated
|
2004-11-06 06:18:11 +01:00
|
|
|
* nicknames, or NULL. Return 0 on success. Warn and return -1 on failure.
|
|
|
|
*/
|
2005-06-11 20:52:12 +02:00
|
|
|
static int
|
2006-03-26 08:51:26 +02:00
|
|
|
check_nickname_list(const char *lst, const char *name, char **msg)
|
2004-11-06 06:18:11 +01:00
|
|
|
{
|
|
|
|
int r = 0;
|
|
|
|
smartlist_t *sl;
|
|
|
|
|
|
|
|
if (!lst)
|
|
|
|
return 0;
|
|
|
|
sl = smartlist_create();
|
2008-10-01 05:41:33 +02:00
|
|
|
|
|
|
|
smartlist_split_string(sl, lst, ",",
|
|
|
|
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK|SPLIT_STRIP_SPACE, 0);
|
|
|
|
|
2004-11-06 06:18:11 +01:00
|
|
|
SMARTLIST_FOREACH(sl, const char *, s,
|
|
|
|
{
|
|
|
|
if (!is_legal_nickname_or_hexdigest(s)) {
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(msg, "Invalid nickname '%s' in %s line", s, name);
|
2004-11-06 06:18:11 +01:00
|
|
|
r = -1;
|
2006-03-26 08:51:26 +02:00
|
|
|
break;
|
2004-11-06 06:18:11 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
SMARTLIST_FOREACH(sl, char *, s, tor_free(s));
|
|
|
|
smartlist_free(sl);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2008-03-10 13:41:29 +01:00
|
|
|
/** Learn config file name from command line arguments, or use the default */
|
2008-03-11 05:30:14 +01:00
|
|
|
static char *
|
2008-03-10 13:41:29 +01:00
|
|
|
find_torrc_filename(int argc, char **argv,
|
|
|
|
int *using_default_torrc, int *ignore_missing_torrc)
|
|
|
|
{
|
|
|
|
char *fname=NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 1; i < argc; ++i) {
|
|
|
|
if (i < argc-1 && !strcmp(argv[i],"-f")) {
|
|
|
|
if (fname) {
|
|
|
|
log(LOG_WARN, LD_CONFIG, "Duplicate -f options on command line.");
|
|
|
|
tor_free(fname);
|
|
|
|
}
|
|
|
|
fname = expand_filename(argv[i+1]);
|
|
|
|
*using_default_torrc = 0;
|
|
|
|
++i;
|
|
|
|
} else if (!strcmp(argv[i],"--ignore-missing-torrc")) {
|
|
|
|
*ignore_missing_torrc = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*using_default_torrc) {
|
|
|
|
/* didn't find one, try CONFDIR */
|
|
|
|
const char *dflt = get_default_conf_file();
|
|
|
|
if (dflt && file_status(dflt) == FN_FILE) {
|
|
|
|
fname = tor_strdup(dflt);
|
|
|
|
} else {
|
|
|
|
#ifndef MS_WINDOWS
|
|
|
|
char *fn;
|
|
|
|
fn = expand_filename("~/.torrc");
|
|
|
|
if (fn && file_status(fn) == FN_FILE) {
|
|
|
|
fname = fn;
|
|
|
|
} else {
|
|
|
|
tor_free(fn);
|
|
|
|
fname = tor_strdup(dflt);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
fname = tor_strdup(dflt);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return fname;
|
|
|
|
}
|
|
|
|
|
2008-03-10 13:41:36 +01:00
|
|
|
/** Load torrc from disk, setting torrc_fname if successful */
|
2008-03-11 05:30:14 +01:00
|
|
|
static char *
|
2008-03-10 13:41:36 +01:00
|
|
|
load_torrc_from_disk(int argc, char **argv)
|
|
|
|
{
|
|
|
|
char *fname=NULL;
|
|
|
|
char *cf = NULL;
|
|
|
|
int using_default_torrc = 1;
|
|
|
|
int ignore_missing_torrc = 0;
|
|
|
|
|
|
|
|
fname = find_torrc_filename(argc, argv,
|
|
|
|
&using_default_torrc, &ignore_missing_torrc);
|
|
|
|
tor_assert(fname);
|
|
|
|
log(LOG_DEBUG, LD_CONFIG, "Opening config file \"%s\"", fname);
|
|
|
|
|
|
|
|
tor_free(torrc_fname);
|
|
|
|
torrc_fname = fname;
|
|
|
|
|
|
|
|
/* Open config file */
|
|
|
|
if (file_status(fname) != FN_FILE ||
|
|
|
|
!(cf = read_file_to_str(fname,0,NULL))) {
|
|
|
|
if (using_default_torrc == 1 || ignore_missing_torrc ) {
|
|
|
|
log(LOG_NOTICE, LD_CONFIG, "Configuration file \"%s\" not present, "
|
|
|
|
"using reasonable defaults.", fname);
|
|
|
|
tor_free(fname); /* sets fname to NULL */
|
|
|
|
torrc_fname = NULL;
|
|
|
|
cf = tor_strdup("");
|
|
|
|
} else {
|
|
|
|
log(LOG_WARN, LD_CONFIG,
|
|
|
|
"Unable to open configuration file \"%s\".", fname);
|
|
|
|
goto err;
|
|
|
|
}
|
2011-01-27 15:31:34 +01:00
|
|
|
} else {
|
|
|
|
log(LOG_NOTICE, LD_CONFIG, "Read configuration file \"%s\".", fname);
|
2008-03-10 13:41:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return cf;
|
|
|
|
err:
|
|
|
|
tor_free(fname);
|
|
|
|
torrc_fname = NULL;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2004-11-04 11:23:30 +01:00
|
|
|
/** Read a configuration file into <b>options</b>, finding the configuration
|
2008-03-10 13:41:49 +01:00
|
|
|
* file location based on the command line. After loading the file
|
|
|
|
* call options_init_from_string() to load the config.
|
2004-11-09 05:28:18 +01:00
|
|
|
* Return 0 if success, -1 if failure. */
|
2004-11-04 11:23:30 +01:00
|
|
|
int
|
2005-07-23 03:58:05 +02:00
|
|
|
options_init_from_torrc(int argc, char **argv)
|
2004-11-04 11:23:30 +01:00
|
|
|
{
|
2008-03-10 13:41:44 +01:00
|
|
|
char *cf=NULL;
|
|
|
|
int i, retval, command;
|
2004-11-04 11:23:30 +01:00
|
|
|
static char **backup_argv;
|
|
|
|
static int backup_argc;
|
2008-03-10 13:41:44 +01:00
|
|
|
char *command_arg = NULL;
|
2008-03-10 13:41:49 +01:00
|
|
|
char *errmsg=NULL;
|
2004-11-06 06:18:11 +01:00
|
|
|
|
2009-05-27 23:55:51 +02:00
|
|
|
if (argv) { /* first time we're called. save command line args */
|
2004-11-04 11:23:30 +01:00
|
|
|
backup_argv = argv;
|
|
|
|
backup_argc = argc;
|
|
|
|
} else { /* we're reloading. need to clean up old options first. */
|
|
|
|
argv = backup_argv;
|
|
|
|
argc = backup_argc;
|
|
|
|
}
|
|
|
|
if (argc > 1 && (!strcmp(argv[1], "-h") || !strcmp(argv[1],"--help"))) {
|
|
|
|
print_usage();
|
|
|
|
exit(0);
|
|
|
|
}
|
2006-12-20 18:05:48 +01:00
|
|
|
if (argc > 1 && !strcmp(argv[1], "--list-torrc-options")) {
|
|
|
|
/* For documenting validating whether we've documented everything. */
|
|
|
|
list_torrc_options();
|
|
|
|
exit(0);
|
|
|
|
}
|
2004-11-04 11:23:30 +01:00
|
|
|
|
|
|
|
if (argc > 1 && (!strcmp(argv[1],"--version"))) {
|
2007-05-22 17:48:46 +02:00
|
|
|
printf("Tor version %s.\n",get_version());
|
2004-11-04 11:23:30 +01:00
|
|
|
exit(0);
|
|
|
|
}
|
2009-01-04 03:43:05 +01:00
|
|
|
if (argc > 1 && (!strcmp(argv[1],"--digests"))) {
|
|
|
|
printf("Tor version %s.\n",get_version());
|
|
|
|
printf("%s", libor_get_digests());
|
2009-05-08 18:35:36 +02:00
|
|
|
printf("%s", tor_get_digests());
|
2009-01-04 03:43:05 +01:00
|
|
|
exit(0);
|
|
|
|
}
|
2004-11-04 11:23:30 +01:00
|
|
|
|
2008-03-10 13:41:40 +01:00
|
|
|
/* Go through command-line variables */
|
|
|
|
if (!global_cmdline_options) {
|
|
|
|
/* Or we could redo the list every time we pass this place.
|
|
|
|
* It does not really matter */
|
|
|
|
if (config_get_commandlines(argc, argv, &global_cmdline_options) < 0) {
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-10 13:41:44 +01:00
|
|
|
command = CMD_RUN_TOR;
|
2008-03-10 13:41:26 +01:00
|
|
|
for (i = 1; i < argc; ++i) {
|
|
|
|
if (!strcmp(argv[i],"--list-fingerprint")) {
|
2008-03-10 13:41:44 +01:00
|
|
|
command = CMD_LIST_FINGERPRINT;
|
2008-03-10 13:41:26 +01:00
|
|
|
} else if (!strcmp(argv[i],"--hash-password")) {
|
2008-03-10 13:41:44 +01:00
|
|
|
command = CMD_HASH_PASSWORD;
|
|
|
|
command_arg = tor_strdup( (i < argc-1) ? argv[i+1] : "");
|
2008-03-10 13:41:26 +01:00
|
|
|
++i;
|
|
|
|
} else if (!strcmp(argv[i],"--verify-config")) {
|
2008-03-10 13:41:44 +01:00
|
|
|
command = CMD_VERIFY_CONFIG;
|
2008-03-10 13:41:26 +01:00
|
|
|
}
|
|
|
|
}
|
2004-11-06 06:18:11 +01:00
|
|
|
|
2008-03-27 17:46:34 +01:00
|
|
|
if (command == CMD_HASH_PASSWORD) {
|
|
|
|
cf = tor_strdup("");
|
|
|
|
} else {
|
|
|
|
cf = load_torrc_from_disk(argc, argv);
|
|
|
|
if (!cf)
|
|
|
|
goto err;
|
|
|
|
}
|
2004-11-04 11:23:30 +01:00
|
|
|
|
2008-03-10 13:41:49 +01:00
|
|
|
retval = options_init_from_string(cf, command, command_arg, &errmsg);
|
2008-03-10 13:41:44 +01:00
|
|
|
tor_free(cf);
|
|
|
|
if (retval < 0)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
2008-03-10 13:41:49 +01:00
|
|
|
if (errmsg) {
|
|
|
|
log(LOG_WARN,LD_CONFIG,"%s", errmsg);
|
|
|
|
tor_free(errmsg);
|
|
|
|
}
|
2008-03-10 13:41:44 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-03-10 13:41:49 +01:00
|
|
|
/** Load the options from the configuration in <b>cf</b>, validate
|
|
|
|
* them for consistency and take actions based on them.
|
|
|
|
*
|
|
|
|
* Return 0 if success, negative on error:
|
|
|
|
* * -1 for general errors.
|
|
|
|
* * -2 for failure to parse/validate,
|
|
|
|
* * -3 for transition not allowed
|
|
|
|
* * -4 for error while setting the new options
|
|
|
|
*/
|
2008-03-13 16:11:56 +01:00
|
|
|
setopt_err_t
|
2008-03-10 13:41:49 +01:00
|
|
|
options_init_from_string(const char *cf,
|
|
|
|
int command, const char *command_arg,
|
|
|
|
char **msg)
|
2008-03-10 13:41:44 +01:00
|
|
|
{
|
|
|
|
or_options_t *oldoptions, *newoptions;
|
|
|
|
config_line_t *cl;
|
2008-03-10 13:41:49 +01:00
|
|
|
int retval;
|
2008-03-13 16:11:56 +01:00
|
|
|
setopt_err_t err = SETOPT_ERR_MISC;
|
2008-03-11 19:56:41 +01:00
|
|
|
tor_assert(msg);
|
2008-03-10 13:41:44 +01:00
|
|
|
|
|
|
|
oldoptions = global_options; /* get_options unfortunately asserts if
|
|
|
|
this is the first time we run*/
|
|
|
|
|
|
|
|
newoptions = tor_malloc_zero(sizeof(or_options_t));
|
|
|
|
newoptions->_magic = OR_OPTIONS_MAGIC;
|
|
|
|
options_init(newoptions);
|
|
|
|
newoptions->command = command;
|
|
|
|
newoptions->command_arg = command_arg;
|
|
|
|
|
2008-03-10 13:41:33 +01:00
|
|
|
/* get config lines, assign them */
|
|
|
|
retval = config_get_lines(cf, &cl);
|
2008-03-10 13:41:49 +01:00
|
|
|
if (retval < 0) {
|
2008-03-13 16:11:56 +01:00
|
|
|
err = SETOPT_ERR_PARSE;
|
2008-03-10 13:41:33 +01:00
|
|
|
goto err;
|
2008-03-10 13:41:49 +01:00
|
|
|
}
|
|
|
|
retval = config_assign(&options_format, newoptions, cl, 0, 0, msg);
|
2008-03-10 13:41:33 +01:00
|
|
|
config_free_lines(cl);
|
2008-03-10 13:41:49 +01:00
|
|
|
if (retval < 0) {
|
2008-03-13 16:11:56 +01:00
|
|
|
err = SETOPT_ERR_PARSE;
|
2008-03-10 13:41:33 +01:00
|
|
|
goto err;
|
2008-03-10 13:41:49 +01:00
|
|
|
}
|
2008-03-10 13:41:33 +01:00
|
|
|
|
2004-11-09 05:28:18 +01:00
|
|
|
/* Go through command-line variables too */
|
2008-03-10 13:41:40 +01:00
|
|
|
retval = config_assign(&options_format, newoptions,
|
2008-03-10 13:41:49 +01:00
|
|
|
global_cmdline_options, 0, 0, msg);
|
|
|
|
if (retval < 0) {
|
2008-03-13 16:11:56 +01:00
|
|
|
err = SETOPT_ERR_PARSE;
|
2004-11-06 06:18:11 +01:00
|
|
|
goto err;
|
2008-03-10 13:41:49 +01:00
|
|
|
}
|
2004-11-04 11:23:30 +01:00
|
|
|
|
2008-06-14 18:01:29 +02:00
|
|
|
/* If this is a testing network configuration, change defaults
|
|
|
|
* for a list of dependent config options, re-initialize newoptions
|
|
|
|
* with the new defaults, and assign all options to it second time. */
|
|
|
|
if (newoptions->TestingTorNetwork) {
|
2008-12-18 17:11:24 +01:00
|
|
|
/* XXXX this is a bit of a kludge. perhaps there's a better way to do
|
2008-06-14 18:11:37 +02:00
|
|
|
* this? We could, for example, make the parsing algorithm do two passes
|
|
|
|
* over the configuration. If it finds any "suite" options like
|
|
|
|
* TestingTorNetwork, it could change the defaults before its second pass.
|
|
|
|
* Not urgent so long as this seems to work, but at any sign of trouble,
|
|
|
|
* let's clean it up. -NM */
|
2008-06-14 18:01:29 +02:00
|
|
|
|
|
|
|
/* Change defaults. */
|
|
|
|
int i;
|
|
|
|
for (i = 0; testing_tor_network_defaults[i].name; ++i) {
|
|
|
|
config_var_t *new_var = &testing_tor_network_defaults[i];
|
|
|
|
config_var_t *old_var =
|
|
|
|
config_find_option(&options_format, new_var->name);
|
|
|
|
tor_assert(new_var);
|
|
|
|
tor_assert(old_var);
|
|
|
|
old_var->initvalue = new_var->initvalue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Clear newoptions and re-initialize them with new defaults. */
|
|
|
|
config_free(&options_format, newoptions);
|
|
|
|
newoptions = tor_malloc_zero(sizeof(or_options_t));
|
|
|
|
newoptions->_magic = OR_OPTIONS_MAGIC;
|
|
|
|
options_init(newoptions);
|
|
|
|
newoptions->command = command;
|
|
|
|
newoptions->command_arg = command_arg;
|
|
|
|
|
|
|
|
/* Assign all options a second time. */
|
|
|
|
retval = config_get_lines(cf, &cl);
|
|
|
|
if (retval < 0) {
|
|
|
|
err = SETOPT_ERR_PARSE;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
retval = config_assign(&options_format, newoptions, cl, 0, 0, msg);
|
|
|
|
config_free_lines(cl);
|
|
|
|
if (retval < 0) {
|
|
|
|
err = SETOPT_ERR_PARSE;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
retval = config_assign(&options_format, newoptions,
|
|
|
|
global_cmdline_options, 0, 0, msg);
|
|
|
|
if (retval < 0) {
|
|
|
|
err = SETOPT_ERR_PARSE;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-11-09 05:28:18 +01:00
|
|
|
/* Validate newoptions */
|
2008-03-10 13:41:49 +01:00
|
|
|
if (options_validate(oldoptions, newoptions, 0, msg) < 0) {
|
2008-12-18 17:11:24 +01:00
|
|
|
err = SETOPT_ERR_PARSE; /*XXX make this a separate return value.*/
|
2004-11-06 06:18:11 +01:00
|
|
|
goto err;
|
2008-03-10 13:41:49 +01:00
|
|
|
}
|
2004-11-04 11:23:30 +01:00
|
|
|
|
2008-03-10 13:41:49 +01:00
|
|
|
if (options_transition_allowed(oldoptions, newoptions, msg) < 0) {
|
2008-03-13 16:11:56 +01:00
|
|
|
err = SETOPT_ERR_TRANSITION;
|
2004-11-06 06:18:11 +01:00
|
|
|
goto err;
|
2008-03-10 13:41:49 +01:00
|
|
|
}
|
2004-11-04 11:23:30 +01:00
|
|
|
|
2008-03-10 13:41:49 +01:00
|
|
|
if (set_options(newoptions, msg)) {
|
2008-03-13 16:11:56 +01:00
|
|
|
err = SETOPT_ERR_SETTING;
|
2005-09-14 04:36:29 +02:00
|
|
|
goto err; /* frees and replaces old options */
|
2008-03-10 13:41:49 +01:00
|
|
|
}
|
2006-03-26 08:51:26 +02:00
|
|
|
|
2008-03-13 16:11:56 +01:00
|
|
|
return SETOPT_OK;
|
2008-03-10 13:41:44 +01:00
|
|
|
|
2004-11-06 06:18:11 +01:00
|
|
|
err:
|
2005-08-04 21:56:41 +02:00
|
|
|
config_free(&options_format, newoptions);
|
2008-03-10 13:41:49 +01:00
|
|
|
if (*msg) {
|
2010-03-01 03:46:50 +01:00
|
|
|
char *old_msg = *msg;
|
|
|
|
tor_asprintf(msg, "Failed to parse/validate config: %s", old_msg);
|
|
|
|
tor_free(old_msg);
|
2006-03-26 08:51:26 +02:00
|
|
|
}
|
2008-03-10 13:41:49 +01:00
|
|
|
return err;
|
2002-07-03 18:31:22 +02:00
|
|
|
}
|
|
|
|
|
2005-08-10 20:05:20 +02:00
|
|
|
/** Return the location for our configuration file.
|
|
|
|
*/
|
|
|
|
const char *
|
|
|
|
get_torrc_fname(void)
|
|
|
|
{
|
|
|
|
if (torrc_fname)
|
|
|
|
return torrc_fname;
|
|
|
|
else
|
|
|
|
return get_default_conf_file();
|
|
|
|
}
|
|
|
|
|
2009-05-27 23:55:51 +02:00
|
|
|
/** Adjust the address map based on the MapAddress elements in the
|
2005-06-11 20:52:12 +02:00
|
|
|
* configuration <b>options</b>
|
|
|
|
*/
|
2005-02-22 01:53:08 +01:00
|
|
|
static void
|
2005-06-11 20:52:12 +02:00
|
|
|
config_register_addressmaps(or_options_t *options)
|
|
|
|
{
|
2005-02-22 01:53:08 +01:00
|
|
|
smartlist_t *elts;
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *opt;
|
2005-02-22 01:53:08 +01:00
|
|
|
char *from, *to;
|
|
|
|
|
2005-03-11 22:39:39 +01:00
|
|
|
addressmap_clear_configured();
|
2005-02-22 01:53:08 +01:00
|
|
|
elts = smartlist_create();
|
|
|
|
for (opt = options->AddressMap; opt; opt = opt->next) {
|
|
|
|
smartlist_split_string(elts, opt->value, NULL,
|
|
|
|
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 2);
|
|
|
|
if (smartlist_len(elts) >= 2) {
|
|
|
|
from = smartlist_get(elts,0);
|
|
|
|
to = smartlist_get(elts,1);
|
2007-01-11 17:02:39 +01:00
|
|
|
if (address_is_invalid_destination(to, 1)) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG,
|
|
|
|
"Skipping invalid argument '%s' to MapAddress", to);
|
2005-02-25 21:46:13 +01:00
|
|
|
} else {
|
2008-02-21 19:45:11 +01:00
|
|
|
addressmap_register(from, tor_strdup(to), 0, ADDRMAPSRC_TORRC);
|
2005-02-25 21:46:13 +01:00
|
|
|
if (smartlist_len(elts)>2) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG,"Ignoring extra arguments to MapAddress.");
|
2005-02-25 21:46:13 +01:00
|
|
|
}
|
|
|
|
}
|
2005-02-22 01:53:08 +01:00
|
|
|
} else {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG,"MapAddress '%s' has too few arguments. Ignoring.",
|
|
|
|
opt->value);
|
2005-02-22 01:53:08 +01:00
|
|
|
}
|
|
|
|
SMARTLIST_FOREACH(elts, char*, cp, tor_free(cp));
|
|
|
|
smartlist_clear(elts);
|
|
|
|
}
|
|
|
|
smartlist_free(elts);
|
|
|
|
}
|
|
|
|
|
2004-05-19 22:07:08 +02:00
|
|
|
/**
|
|
|
|
* Initialize the logs based on the configuration file.
|
|
|
|
*/
|
2007-10-02 22:35:23 +02:00
|
|
|
static int
|
2005-07-23 03:58:05 +02:00
|
|
|
options_init_logs(or_options_t *options, int validate_only)
|
2004-05-19 22:07:08 +02:00
|
|
|
{
|
2005-07-22 23:12:10 +02:00
|
|
|
config_line_t *opt;
|
2004-11-05 06:50:35 +01:00
|
|
|
int ok;
|
2004-11-06 06:18:11 +01:00
|
|
|
smartlist_t *elts;
|
2006-05-23 09:04:55 +02:00
|
|
|
int daemon =
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
0;
|
|
|
|
#else
|
|
|
|
options->RunAsDaemon;
|
|
|
|
#endif
|
2004-11-05 06:50:35 +01:00
|
|
|
|
2010-11-08 16:37:20 +01:00
|
|
|
if (options->LogTimeGranularity <= 0) {
|
|
|
|
log_warn(LD_CONFIG, "Log time granularity '%d' has to be positive.",
|
2010-08-27 08:13:54 +02:00
|
|
|
options->LogTimeGranularity);
|
|
|
|
return -1;
|
2010-11-08 16:37:20 +01:00
|
|
|
} else if (1000 % options->LogTimeGranularity != 0 &&
|
|
|
|
options->LogTimeGranularity % 1000 != 0) {
|
|
|
|
int granularity = options->LogTimeGranularity;
|
|
|
|
if (granularity < 40) {
|
|
|
|
do granularity++;
|
|
|
|
while (1000 % granularity != 0);
|
|
|
|
} else if (granularity < 1000) {
|
|
|
|
granularity = 1000 / granularity;
|
|
|
|
while (1000 % granularity != 0)
|
|
|
|
granularity--;
|
|
|
|
granularity = 1000 / granularity;
|
|
|
|
} else {
|
|
|
|
granularity = 1000 * ((granularity / 1000) + 1);
|
|
|
|
}
|
|
|
|
log_warn(LD_CONFIG, "Log time granularity '%d' has to be either a "
|
|
|
|
"divisor or a multiple of 1 second. Changing to "
|
|
|
|
"'%d'.",
|
|
|
|
options->LogTimeGranularity, granularity);
|
2010-11-08 18:40:26 +01:00
|
|
|
if (!validate_only)
|
|
|
|
set_log_time_granularity(granularity);
|
2010-11-08 16:37:20 +01:00
|
|
|
} else {
|
2010-11-08 18:40:26 +01:00
|
|
|
if (!validate_only)
|
|
|
|
set_log_time_granularity(options->LogTimeGranularity);
|
2010-08-27 08:13:54 +02:00
|
|
|
}
|
|
|
|
|
2004-11-05 06:50:35 +01:00
|
|
|
ok = 1;
|
2004-11-06 06:18:11 +01:00
|
|
|
elts = smartlist_create();
|
2006-01-11 20:40:14 +01:00
|
|
|
|
2004-11-05 06:50:35 +01:00
|
|
|
for (opt = options->Logs; opt; opt = opt->next) {
|
2008-03-05 23:31:39 +01:00
|
|
|
log_severity_list_t *severity;
|
|
|
|
const char *cfg = opt->value;
|
|
|
|
severity = tor_malloc_zero(sizeof(log_severity_list_t));
|
|
|
|
if (parse_log_severity_config(&cfg, severity) < 0) {
|
|
|
|
log_warn(LD_CONFIG, "Couldn't parse log levels in Log option 'Log %s'",
|
|
|
|
opt->value);
|
2004-11-05 06:50:35 +01:00
|
|
|
ok = 0; goto cleanup;
|
|
|
|
}
|
2008-03-05 23:31:39 +01:00
|
|
|
|
|
|
|
smartlist_split_string(elts, cfg, NULL,
|
|
|
|
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 2);
|
|
|
|
|
|
|
|
if (smartlist_len(elts) == 0)
|
|
|
|
smartlist_add(elts, tor_strdup("stdout"));
|
|
|
|
|
|
|
|
if (smartlist_len(elts) == 1 &&
|
|
|
|
(!strcasecmp(smartlist_get(elts,0), "stdout") ||
|
|
|
|
!strcasecmp(smartlist_get(elts,0), "stderr"))) {
|
|
|
|
int err = smartlist_len(elts) &&
|
|
|
|
!strcasecmp(smartlist_get(elts,0), "stderr");
|
2006-01-11 20:40:14 +01:00
|
|
|
if (!validate_only) {
|
|
|
|
if (daemon) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG,
|
2008-03-05 23:31:39 +01:00
|
|
|
"Can't log to %s with RunAsDaemon set; skipping stdout",
|
|
|
|
err?"stderr":"stdout");
|
2006-02-11 22:56:03 +01:00
|
|
|
} else {
|
2008-03-05 23:31:39 +01:00
|
|
|
add_stream_log(severity, err?"<stderr>":"<stdout>",
|
2008-12-03 00:36:58 +01:00
|
|
|
fileno(err?stderr:stdout));
|
2006-01-11 20:40:14 +01:00
|
|
|
}
|
|
|
|
}
|
2004-11-05 06:50:35 +01:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2008-03-05 23:31:39 +01:00
|
|
|
if (smartlist_len(elts) == 1 &&
|
|
|
|
!strcasecmp(smartlist_get(elts,0), "syslog")) {
|
|
|
|
#ifdef HAVE_SYSLOG_H
|
|
|
|
if (!validate_only) {
|
|
|
|
add_syslog_log(severity);
|
2004-11-05 06:50:35 +01:00
|
|
|
}
|
2008-03-05 23:31:39 +01:00
|
|
|
#else
|
|
|
|
log_warn(LD_CONFIG, "Syslog is not supported on this system. Sorry.");
|
|
|
|
#endif
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (smartlist_len(elts) == 2 &&
|
|
|
|
!strcasecmp(smartlist_get(elts,0), "file")) {
|
2006-01-11 20:40:14 +01:00
|
|
|
if (!validate_only) {
|
2011-04-22 16:06:52 +02:00
|
|
|
char *fname = expand_filename(smartlist_get(elts, 1));
|
|
|
|
if (add_file_log(severity, fname) < 0) {
|
2008-04-01 23:05:31 +02:00
|
|
|
log_warn(LD_CONFIG, "Couldn't open file for 'Log %s': %s",
|
|
|
|
opt->value, strerror(errno));
|
2006-01-11 20:40:14 +01:00
|
|
|
ok = 0;
|
2006-01-11 21:09:37 +01:00
|
|
|
}
|
2011-04-22 16:06:52 +02:00
|
|
|
tor_free(fname);
|
2006-01-11 20:40:14 +01:00
|
|
|
}
|
2004-11-05 06:50:35 +01:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2008-03-05 23:31:39 +01:00
|
|
|
|
|
|
|
log_warn(LD_CONFIG, "Bad syntax on file Log option 'Log %s'",
|
|
|
|
opt->value);
|
|
|
|
ok = 0; goto cleanup;
|
|
|
|
|
2004-11-05 06:50:35 +01:00
|
|
|
cleanup:
|
|
|
|
SMARTLIST_FOREACH(elts, char*, cp, tor_free(cp));
|
|
|
|
smartlist_clear(elts);
|
2008-03-05 23:31:39 +01:00
|
|
|
tor_free(severity);
|
2004-11-05 06:50:35 +01:00
|
|
|
}
|
|
|
|
smartlist_free(elts);
|
|
|
|
|
2011-01-25 21:53:15 +01:00
|
|
|
if (ok && !validate_only)
|
|
|
|
logs_set_domain_logging(options->LogMessageDomains);
|
|
|
|
|
2004-11-05 06:50:35 +01:00
|
|
|
return ok?0:-1;
|
|
|
|
}
|
|
|
|
|
2007-05-08 13:28:05 +02:00
|
|
|
/** Read the contents of a Bridge line from <b>line</b>. Return 0
|
|
|
|
* if the line is well-formed, and -1 if it isn't. If
|
|
|
|
* <b>validate_only</b> is 0, and the line is well-formed, then add
|
|
|
|
* the bridge described in the line to our internal bridge list. */
|
|
|
|
static int
|
|
|
|
parse_bridge_line(const char *line, int validate_only)
|
|
|
|
{
|
|
|
|
smartlist_t *items = NULL;
|
|
|
|
int r;
|
2008-08-05 22:08:19 +02:00
|
|
|
char *addrport=NULL, *fingerprint=NULL;
|
|
|
|
tor_addr_t addr;
|
2007-05-08 13:28:05 +02:00
|
|
|
uint16_t port = 0;
|
|
|
|
char digest[DIGEST_LEN];
|
|
|
|
|
|
|
|
items = smartlist_create();
|
|
|
|
smartlist_split_string(items, line, NULL,
|
|
|
|
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
|
|
|
|
if (smartlist_len(items) < 1) {
|
|
|
|
log_warn(LD_CONFIG, "Too few arguments to Bridge line.");
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
addrport = smartlist_get(items, 0);
|
|
|
|
smartlist_del_keeporder(items, 0);
|
2008-08-05 22:08:19 +02:00
|
|
|
if (tor_addr_port_parse(addrport, &addr, &port)<0) {
|
2007-05-08 13:28:05 +02:00
|
|
|
log_warn(LD_CONFIG, "Error parsing Bridge address '%s'", addrport);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
if (!port) {
|
2009-04-11 02:16:05 +02:00
|
|
|
log_info(LD_CONFIG,
|
|
|
|
"Bridge address '%s' has no port; using default port 443.",
|
|
|
|
addrport);
|
|
|
|
port = 443;
|
2007-05-08 13:28:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (smartlist_len(items)) {
|
|
|
|
fingerprint = smartlist_join_strings(items, "", 0, NULL);
|
|
|
|
if (strlen(fingerprint) != HEX_DIGEST_LEN) {
|
|
|
|
log_warn(LD_CONFIG, "Key digest for Bridge is wrong length.");
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
if (base16_decode(digest, DIGEST_LEN, fingerprint, HEX_DIGEST_LEN)<0) {
|
|
|
|
log_warn(LD_CONFIG, "Unable to decode Bridge key digest.");
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!validate_only) {
|
2008-08-05 22:08:19 +02:00
|
|
|
log_debug(LD_DIR, "Bridge at %s:%d (%s)", fmt_addr(&addr),
|
2007-05-08 13:28:05 +02:00
|
|
|
(int)port,
|
|
|
|
fingerprint ? fingerprint : "no key listed");
|
2008-08-05 22:08:19 +02:00
|
|
|
bridge_add_from_config(&addr, port, fingerprint ? digest : NULL);
|
2007-05-08 13:28:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
r = 0;
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
err:
|
|
|
|
r = -1;
|
|
|
|
|
|
|
|
done:
|
|
|
|
SMARTLIST_FOREACH(items, char*, s, tor_free(s));
|
|
|
|
smartlist_free(items);
|
|
|
|
tor_free(addrport);
|
|
|
|
tor_free(fingerprint);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2008-02-04 17:58:50 +01:00
|
|
|
/** Read the contents of a DirServer line from <b>line</b>. If
|
2007-12-12 05:38:54 +01:00
|
|
|
* <b>validate_only</b> is 0, and the line is well-formed, and it
|
|
|
|
* shares any bits with <b>required_type</b> or <b>required_type</b>
|
|
|
|
* is 0, then add the dirserver described in the line (minus whatever
|
2008-02-04 17:58:50 +01:00
|
|
|
* bits it's missing) as a valid authority. Return 0 on success,
|
|
|
|
* or -1 if the line isn't well-formed or if we can't add it. */
|
2004-11-09 00:12:40 +01:00
|
|
|
static int
|
2010-11-08 20:27:36 +01:00
|
|
|
parse_dir_server_line(const char *line, dirinfo_type_t required_type,
|
2007-12-12 05:38:54 +01:00
|
|
|
int validate_only)
|
2004-10-12 17:55:20 +02:00
|
|
|
{
|
|
|
|
smartlist_t *items = NULL;
|
2006-10-09 04:35:51 +02:00
|
|
|
int r;
|
2005-10-25 20:06:29 +02:00
|
|
|
char *addrport=NULL, *address=NULL, *nickname=NULL, *fingerprint=NULL;
|
2006-12-24 03:45:27 +01:00
|
|
|
uint16_t dir_port = 0, or_port = 0;
|
2004-10-12 17:55:20 +02:00
|
|
|
char digest[DIGEST_LEN];
|
2007-05-22 19:58:25 +02:00
|
|
|
char v3_digest[DIGEST_LEN];
|
2010-11-08 20:35:02 +01:00
|
|
|
dirinfo_type_t type = V2_DIRINFO;
|
2007-05-09 06:15:46 +02:00
|
|
|
int is_not_hidserv_authority = 0, is_not_v2_authority = 0;
|
2005-09-07 18:42:53 +02:00
|
|
|
|
2005-10-04 23:21:09 +02:00
|
|
|
items = smartlist_create();
|
|
|
|
smartlist_split_string(items, line, NULL,
|
|
|
|
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
|
2006-09-30 00:33:34 +02:00
|
|
|
if (smartlist_len(items) < 1) {
|
|
|
|
log_warn(LD_CONFIG, "No arguments on DirServer line.");
|
2005-10-25 09:05:03 +02:00
|
|
|
goto err;
|
2005-10-04 23:21:09 +02:00
|
|
|
}
|
2005-09-07 18:42:53 +02:00
|
|
|
|
2005-10-04 23:21:09 +02:00
|
|
|
if (is_legal_nickname(smartlist_get(items, 0))) {
|
|
|
|
nickname = smartlist_get(items, 0);
|
|
|
|
smartlist_del_keeporder(items, 0);
|
|
|
|
}
|
|
|
|
|
2006-09-29 01:57:59 +02:00
|
|
|
while (smartlist_len(items)) {
|
|
|
|
char *flag = smartlist_get(items, 0);
|
|
|
|
if (TOR_ISDIGIT(flag[0]))
|
|
|
|
break;
|
|
|
|
if (!strcasecmp(flag, "v1")) {
|
2010-11-08 20:35:02 +01:00
|
|
|
type |= (V1_DIRINFO | HIDSERV_DIRINFO);
|
2006-09-29 01:57:59 +02:00
|
|
|
} else if (!strcasecmp(flag, "hs")) {
|
2010-11-08 20:35:02 +01:00
|
|
|
type |= HIDSERV_DIRINFO;
|
2006-09-29 01:57:59 +02:00
|
|
|
} else if (!strcasecmp(flag, "no-hs")) {
|
|
|
|
is_not_hidserv_authority = 1;
|
2007-05-07 10:26:50 +02:00
|
|
|
} else if (!strcasecmp(flag, "bridge")) {
|
2010-11-08 20:35:02 +01:00
|
|
|
type |= BRIDGE_DIRINFO;
|
2006-09-29 01:57:59 +02:00
|
|
|
} else if (!strcasecmp(flag, "no-v2")) {
|
2007-05-09 06:15:46 +02:00
|
|
|
is_not_v2_authority = 1;
|
2006-12-24 03:45:27 +01:00
|
|
|
} else if (!strcasecmpstart(flag, "orport=")) {
|
|
|
|
int ok;
|
2007-01-05 02:23:34 +01:00
|
|
|
char *portstring = flag + strlen("orport=");
|
|
|
|
or_port = (uint16_t) tor_parse_long(portstring, 10, 1, 65535, &ok, NULL);
|
2006-12-24 03:45:27 +01:00
|
|
|
if (!ok)
|
2007-01-05 02:23:34 +01:00
|
|
|
log_warn(LD_CONFIG, "Invalid orport '%s' on DirServer line.",
|
|
|
|
portstring);
|
2007-05-22 19:58:25 +02:00
|
|
|
} else if (!strcasecmpstart(flag, "v3ident=")) {
|
|
|
|
char *idstr = flag + strlen("v3ident=");
|
|
|
|
if (strlen(idstr) != HEX_DIGEST_LEN ||
|
|
|
|
base16_decode(v3_digest, DIGEST_LEN, idstr, HEX_DIGEST_LEN)<0) {
|
|
|
|
log_warn(LD_CONFIG, "Bad v3 identity digest '%s' on DirServer line",
|
|
|
|
flag);
|
|
|
|
} else {
|
2010-11-08 20:21:32 +01:00
|
|
|
type |= V3_DIRINFO|EXTRAINFO_DIRINFO|MICRODESC_DIRINFO;
|
2007-05-22 19:58:25 +02:00
|
|
|
}
|
2006-09-29 01:57:59 +02:00
|
|
|
} else {
|
|
|
|
log_warn(LD_CONFIG, "Unrecognized flag '%s' on DirServer line",
|
|
|
|
flag);
|
|
|
|
}
|
|
|
|
tor_free(flag);
|
2005-10-04 23:21:09 +02:00
|
|
|
smartlist_del_keeporder(items, 0);
|
2005-09-07 18:42:53 +02:00
|
|
|
}
|
2006-09-29 01:57:59 +02:00
|
|
|
if (is_not_hidserv_authority)
|
2010-11-08 20:35:02 +01:00
|
|
|
type &= ~HIDSERV_DIRINFO;
|
2007-05-09 06:15:46 +02:00
|
|
|
if (is_not_v2_authority)
|
2010-11-08 20:35:02 +01:00
|
|
|
type &= ~V2_DIRINFO;
|
2006-09-29 01:57:59 +02:00
|
|
|
|
2004-10-12 17:55:20 +02:00
|
|
|
if (smartlist_len(items) < 2) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG, "Too few arguments to DirServer line.");
|
2004-10-14 04:47:09 +02:00
|
|
|
goto err;
|
2004-10-12 17:55:20 +02:00
|
|
|
}
|
|
|
|
addrport = smartlist_get(items, 0);
|
2007-01-05 02:12:10 +01:00
|
|
|
smartlist_del_keeporder(items, 0);
|
2006-12-24 03:45:27 +01:00
|
|
|
if (parse_addr_port(LOG_WARN, addrport, &address, NULL, &dir_port)<0) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG, "Error parsing DirServer address '%s'", addrport);
|
2004-10-14 04:47:09 +02:00
|
|
|
goto err;
|
2004-10-12 17:55:20 +02:00
|
|
|
}
|
2006-12-24 03:45:27 +01:00
|
|
|
if (!dir_port) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG, "Missing port in DirServer address '%s'",addrport);
|
2004-10-14 04:47:09 +02:00
|
|
|
goto err;
|
2004-10-12 17:55:20 +02:00
|
|
|
}
|
|
|
|
|
2005-10-04 23:21:09 +02:00
|
|
|
fingerprint = smartlist_join_strings(items, "", 0, NULL);
|
|
|
|
if (strlen(fingerprint) != HEX_DIGEST_LEN) {
|
2007-06-09 09:05:19 +02:00
|
|
|
log_warn(LD_CONFIG, "Key digest for DirServer is wrong length %d.",
|
|
|
|
(int)strlen(fingerprint));
|
2004-10-14 04:47:09 +02:00
|
|
|
goto err;
|
2004-10-12 17:55:20 +02:00
|
|
|
}
|
2007-08-19 04:51:54 +02:00
|
|
|
if (!strcmp(fingerprint, "E623F7625FBE0C87820F11EC5F6D5377ED816294")) {
|
2007-12-06 12:19:00 +01:00
|
|
|
/* a known bad fingerprint. refuse to use it. We can remove this
|
|
|
|
* clause once Tor 0.1.2.17 is obsolete. */
|
2007-08-19 04:51:54 +02:00
|
|
|
log_warn(LD_CONFIG, "Dangerous dirserver line. To correct, erase your "
|
|
|
|
"torrc file (%s), or reinstall Tor and use the default torrc.",
|
|
|
|
get_torrc_fname());
|
|
|
|
goto err;
|
|
|
|
}
|
2005-10-04 23:21:09 +02:00
|
|
|
if (base16_decode(digest, DIGEST_LEN, fingerprint, HEX_DIGEST_LEN)<0) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG, "Unable to decode DirServer key digest.");
|
2004-10-14 04:47:09 +02:00
|
|
|
goto err;
|
2004-10-12 17:55:20 +02:00
|
|
|
}
|
|
|
|
|
2007-12-12 05:38:54 +01:00
|
|
|
if (!validate_only && (!required_type || required_type & type)) {
|
|
|
|
if (required_type)
|
|
|
|
type &= required_type; /* pare down what we think of them as an
|
|
|
|
* authority for. */
|
|
|
|
log_debug(LD_DIR, "Trusted %d dirserver at %s:%d (%s)", (int)type,
|
|
|
|
address, (int)dir_port, (char*)smartlist_get(items,0));
|
2008-02-04 17:58:50 +01:00
|
|
|
if (!add_trusted_dir_server(nickname, address, dir_port, or_port,
|
|
|
|
digest, v3_digest, type))
|
|
|
|
goto err;
|
2004-11-09 00:12:40 +01:00
|
|
|
}
|
2004-10-12 17:55:20 +02:00
|
|
|
|
|
|
|
r = 0;
|
|
|
|
goto done;
|
2004-10-14 04:47:09 +02:00
|
|
|
|
|
|
|
err:
|
2004-10-12 17:55:20 +02:00
|
|
|
r = -1;
|
2004-10-14 04:47:09 +02:00
|
|
|
|
|
|
|
done:
|
2004-10-12 17:55:20 +02:00
|
|
|
SMARTLIST_FOREACH(items, char*, s, tor_free(s));
|
|
|
|
smartlist_free(items);
|
2005-10-25 20:06:29 +02:00
|
|
|
tor_free(addrport);
|
2004-11-06 06:18:11 +01:00
|
|
|
tor_free(address);
|
2005-10-04 23:21:09 +02:00
|
|
|
tor_free(nickname);
|
|
|
|
tor_free(fingerprint);
|
2004-10-12 17:55:20 +02:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2004-11-10 01:11:37 +01:00
|
|
|
/** Adjust the value of options->DataDirectory, or fill it in if it's
|
2004-11-09 19:22:17 +01:00
|
|
|
* absent. Return 0 on success, -1 on failure. */
|
2004-11-09 06:26:49 +01:00
|
|
|
static int
|
2005-06-11 20:52:12 +02:00
|
|
|
normalize_data_directory(or_options_t *options)
|
|
|
|
{
|
2004-08-18 05:42:55 +02:00
|
|
|
#ifdef MS_WINDOWS
|
2004-11-09 08:05:53 +01:00
|
|
|
char *p;
|
|
|
|
if (options->DataDirectory)
|
|
|
|
return 0; /* all set */
|
|
|
|
p = tor_malloc(MAX_PATH);
|
|
|
|
strlcpy(p,get_windows_conf_root(),MAX_PATH);
|
|
|
|
options->DataDirectory = p;
|
|
|
|
return 0;
|
2004-08-18 05:42:55 +02:00
|
|
|
#else
|
2004-11-09 08:05:53 +01:00
|
|
|
const char *d = options->DataDirectory;
|
2004-11-28 10:05:49 +01:00
|
|
|
if (!d)
|
2004-06-21 06:37:27 +02:00
|
|
|
d = "~/.tor";
|
2004-10-14 04:47:09 +02:00
|
|
|
|
2004-11-09 08:05:53 +01:00
|
|
|
if (strncmp(d,"~/",2) == 0) {
|
2004-11-09 06:26:49 +01:00
|
|
|
char *fn = expand_filename(d);
|
|
|
|
if (!fn) {
|
2007-05-13 11:25:06 +02:00
|
|
|
log_warn(LD_CONFIG,"Failed to expand filename \"%s\".", d);
|
2004-11-09 08:05:53 +01:00
|
|
|
return -1;
|
2004-11-09 06:26:49 +01:00
|
|
|
}
|
2004-11-09 19:22:17 +01:00
|
|
|
if (!options->DataDirectory && !strcmp(fn,"/.tor")) {
|
|
|
|
/* If our homedir is /, we probably don't want to use it. */
|
2006-10-03 00:13:42 +02:00
|
|
|
/* Default to LOCALSTATEDIR/tor which is probably closer to what we
|
|
|
|
* want. */
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG,
|
|
|
|
"Default DataDirectory is \"~/.tor\". This expands to "
|
2007-03-09 22:39:30 +01:00
|
|
|
"\"%s\", which is probably not what you want. Using "
|
|
|
|
"\"%s"PATH_SEPARATOR"tor\" instead", fn, LOCALSTATEDIR);
|
2005-05-03 02:36:57 +02:00
|
|
|
tor_free(fn);
|
2007-03-09 22:39:30 +01:00
|
|
|
fn = tor_strdup(LOCALSTATEDIR PATH_SEPARATOR "tor");
|
2004-11-09 19:22:17 +01:00
|
|
|
}
|
2004-11-09 06:26:49 +01:00
|
|
|
tor_free(options->DataDirectory);
|
|
|
|
options->DataDirectory = fn;
|
|
|
|
}
|
|
|
|
return 0;
|
2004-11-09 08:05:53 +01:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2004-11-09 19:22:17 +01:00
|
|
|
/** Check and normalize the value of options->DataDirectory; return 0 if it
|
2009-12-19 21:08:58 +01:00
|
|
|
* is sane, -1 otherwise. */
|
2004-11-09 08:05:53 +01:00
|
|
|
static int
|
2005-06-11 20:52:12 +02:00
|
|
|
validate_data_directory(or_options_t *options)
|
|
|
|
{
|
2004-11-09 08:20:21 +01:00
|
|
|
if (normalize_data_directory(options) < 0)
|
2004-11-09 08:05:53 +01:00
|
|
|
return -1;
|
|
|
|
tor_assert(options->DataDirectory);
|
|
|
|
if (strlen(options->DataDirectory) > (512-128)) {
|
2007-05-13 11:25:06 +02:00
|
|
|
log_warn(LD_CONFIG, "DataDirectory is too long.");
|
2004-11-09 08:05:53 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
2004-06-21 06:37:27 +02:00
|
|
|
}
|
|
|
|
|
2005-12-27 03:48:02 +01:00
|
|
|
/** This string must remain the same forevermore. It is how we
|
|
|
|
* recognize that the torrc file doesn't need to be backed up. */
|
2005-12-14 21:40:40 +01:00
|
|
|
#define GENERATED_FILE_PREFIX "# This file was generated by Tor; " \
|
|
|
|
"if you edit it, comments will not be preserved"
|
2005-12-27 03:48:02 +01:00
|
|
|
/** This string can change; it tries to give the reader an idea
|
|
|
|
* that editing this file by hand is not a good plan. */
|
2006-06-09 04:20:42 +02:00
|
|
|
#define GENERATED_FILE_COMMENT "# The old torrc file was renamed " \
|
|
|
|
"to torrc.orig.1 or similar, and Tor will ignore it"
|
2004-11-14 21:51:28 +01:00
|
|
|
|
|
|
|
/** Save a configuration file for the configuration in <b>options</b>
|
|
|
|
* into the file <b>fname</b>. If the file already exists, and
|
|
|
|
* doesn't begin with GENERATED_FILE_PREFIX, rename it. Otherwise
|
|
|
|
* replace it. Return 0 on success, -1 on failure. */
|
|
|
|
static int
|
|
|
|
write_configuration_file(const char *fname, or_options_t *options)
|
|
|
|
{
|
2004-11-15 04:53:03 +01:00
|
|
|
char *old_val=NULL, *new_val=NULL, *new_conf=NULL;
|
2004-11-14 21:51:28 +01:00
|
|
|
int rename_old = 0, r;
|
|
|
|
|
2008-09-05 23:19:53 +02:00
|
|
|
tor_assert(fname);
|
|
|
|
|
|
|
|
switch (file_status(fname)) {
|
|
|
|
case FN_FILE:
|
|
|
|
old_val = read_file_to_str(fname, 0, NULL);
|
2011-05-12 04:05:41 +02:00
|
|
|
if (!old_val || strcmpstart(old_val, GENERATED_FILE_PREFIX)) {
|
2008-09-05 23:19:53 +02:00
|
|
|
rename_old = 1;
|
|
|
|
}
|
|
|
|
tor_free(old_val);
|
|
|
|
break;
|
|
|
|
case FN_NOENT:
|
|
|
|
break;
|
|
|
|
case FN_ERROR:
|
|
|
|
case FN_DIR:
|
|
|
|
default:
|
|
|
|
log_warn(LD_CONFIG,
|
|
|
|
"Config file \"%s\" is not a file? Failing.", fname);
|
|
|
|
return -1;
|
2004-11-14 21:51:28 +01:00
|
|
|
}
|
|
|
|
|
2005-07-23 03:58:05 +02:00
|
|
|
if (!(new_conf = options_dump(options, 1))) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_BUG, "Couldn't get configuration string");
|
2004-11-14 21:51:28 +01:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(&new_val, "%s\n%s\n\n%s",
|
2005-12-27 03:48:35 +01:00
|
|
|
GENERATED_FILE_PREFIX, GENERATED_FILE_COMMENT, new_conf);
|
2004-11-14 21:51:28 +01:00
|
|
|
|
|
|
|
if (rename_old) {
|
|
|
|
int i = 1;
|
2005-02-22 07:38:39 +01:00
|
|
|
size_t fn_tmp_len = strlen(fname)+32;
|
|
|
|
char *fn_tmp;
|
|
|
|
tor_assert(fn_tmp_len > strlen(fname)); /*check for overflow*/
|
|
|
|
fn_tmp = tor_malloc(fn_tmp_len);
|
2004-11-14 21:51:28 +01:00
|
|
|
while (1) {
|
2005-02-22 07:38:39 +01:00
|
|
|
if (tor_snprintf(fn_tmp, fn_tmp_len, "%s.orig.%d", fname, i)<0) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_BUG, "tor_snprintf failed inexplicably");
|
2005-02-22 07:38:39 +01:00
|
|
|
tor_free(fn_tmp);
|
2004-11-14 21:51:28 +01:00
|
|
|
goto err;
|
|
|
|
}
|
2004-11-15 04:53:03 +01:00
|
|
|
if (file_status(fn_tmp) == FN_NOENT)
|
2004-11-14 21:51:28 +01:00
|
|
|
break;
|
|
|
|
++i;
|
|
|
|
}
|
2006-02-13 10:02:35 +01:00
|
|
|
log_notice(LD_CONFIG, "Renaming old configuration file to \"%s\"", fn_tmp);
|
2006-02-20 00:12:26 +01:00
|
|
|
if (rename(fname, fn_tmp) < 0) {
|
2006-10-03 00:13:42 +02:00
|
|
|
log_warn(LD_FS,
|
2006-10-07 08:28:50 +02:00
|
|
|
"Couldn't rename configuration file \"%s\" to \"%s\": %s",
|
|
|
|
fname, fn_tmp, strerror(errno));
|
2006-02-20 00:12:26 +01:00
|
|
|
tor_free(fn_tmp);
|
|
|
|
goto err;
|
|
|
|
}
|
2005-02-22 07:38:39 +01:00
|
|
|
tor_free(fn_tmp);
|
2004-11-14 21:51:28 +01:00
|
|
|
}
|
|
|
|
|
2006-02-20 02:06:27 +01:00
|
|
|
if (write_str_to_file(fname, new_val, 0) < 0)
|
|
|
|
goto err;
|
2004-11-14 21:51:28 +01:00
|
|
|
|
|
|
|
r = 0;
|
|
|
|
goto done;
|
|
|
|
err:
|
|
|
|
r = -1;
|
|
|
|
done:
|
|
|
|
tor_free(new_val);
|
|
|
|
tor_free(new_conf);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Save the current configuration file value to disk. Return 0 on
|
|
|
|
* success, -1 on failure.
|
|
|
|
**/
|
|
|
|
int
|
2005-07-23 03:58:05 +02:00
|
|
|
options_save_current(void)
|
2004-11-14 21:51:28 +01:00
|
|
|
{
|
2010-02-22 12:21:58 +01:00
|
|
|
/* This fails if we can't write to our configuration file.
|
|
|
|
*
|
|
|
|
* If we try falling back to datadirectory or something, we have a better
|
|
|
|
* chance of saving the configuration, but a better chance of doing
|
|
|
|
* something the user never expected. */
|
|
|
|
return write_configuration_file(get_torrc_fname(), get_options());
|
2004-11-14 21:51:28 +01:00
|
|
|
}
|
|
|
|
|
2005-10-06 06:33:40 +02:00
|
|
|
/** Mapping from a unit name to a multiplier for converting that unit into a
|
2011-03-16 23:10:15 +01:00
|
|
|
* base unit. Used by config_parse_unit. */
|
2004-11-20 01:37:00 +01:00
|
|
|
struct unit_table_t {
|
2011-03-16 23:10:15 +01:00
|
|
|
const char *unit; /**< The name of the unit */
|
|
|
|
uint64_t multiplier; /**< How many of the base unit appear in this unit */
|
2004-11-20 01:37:00 +01:00
|
|
|
};
|
|
|
|
|
2008-12-23 18:56:31 +01:00
|
|
|
/** Table to map the names of memory units to the number of bytes they
|
|
|
|
* contain. */
|
2004-11-20 01:37:00 +01:00
|
|
|
static struct unit_table_t memory_units[] = {
|
2004-11-23 11:52:27 +01:00
|
|
|
{ "", 1 },
|
2004-11-22 22:56:51 +01:00
|
|
|
{ "b", 1<< 0 },
|
2004-11-20 01:37:00 +01:00
|
|
|
{ "byte", 1<< 0 },
|
|
|
|
{ "bytes", 1<< 0 },
|
|
|
|
{ "kb", 1<<10 },
|
2007-12-23 05:22:55 +01:00
|
|
|
{ "kbyte", 1<<10 },
|
|
|
|
{ "kbytes", 1<<10 },
|
2004-11-20 01:37:00 +01:00
|
|
|
{ "kilobyte", 1<<10 },
|
|
|
|
{ "kilobytes", 1<<10 },
|
|
|
|
{ "m", 1<<20 },
|
|
|
|
{ "mb", 1<<20 },
|
2007-12-23 05:22:55 +01:00
|
|
|
{ "mbyte", 1<<20 },
|
|
|
|
{ "mbytes", 1<<20 },
|
2004-11-20 01:37:00 +01:00
|
|
|
{ "megabyte", 1<<20 },
|
|
|
|
{ "megabytes", 1<<20 },
|
|
|
|
{ "gb", 1<<30 },
|
2007-12-23 05:22:55 +01:00
|
|
|
{ "gbyte", 1<<30 },
|
|
|
|
{ "gbytes", 1<<30 },
|
2004-11-20 01:37:00 +01:00
|
|
|
{ "gigabyte", 1<<30 },
|
|
|
|
{ "gigabytes", 1<<30 },
|
|
|
|
{ "tb", U64_LITERAL(1)<<40 },
|
|
|
|
{ "terabyte", U64_LITERAL(1)<<40 },
|
|
|
|
{ "terabytes", U64_LITERAL(1)<<40 },
|
|
|
|
{ NULL, 0 },
|
|
|
|
};
|
|
|
|
|
2008-12-23 18:56:31 +01:00
|
|
|
/** Table to map the names of time units to the number of seconds they
|
|
|
|
* contain. */
|
2004-11-20 01:37:00 +01:00
|
|
|
static struct unit_table_t time_units[] = {
|
2004-11-23 11:52:27 +01:00
|
|
|
{ "", 1 },
|
2004-11-23 08:37:25 +01:00
|
|
|
{ "second", 1 },
|
2004-11-20 01:37:00 +01:00
|
|
|
{ "seconds", 1 },
|
|
|
|
{ "minute", 60 },
|
|
|
|
{ "minutes", 60 },
|
|
|
|
{ "hour", 60*60 },
|
|
|
|
{ "hours", 60*60 },
|
|
|
|
{ "day", 24*60*60 },
|
|
|
|
{ "days", 24*60*60 },
|
|
|
|
{ "week", 7*24*60*60 },
|
|
|
|
{ "weeks", 7*24*60*60 },
|
|
|
|
{ NULL, 0 },
|
|
|
|
};
|
|
|
|
|
2010-08-27 08:13:54 +02:00
|
|
|
/** Table to map the names of time units to the number of milliseconds
|
|
|
|
* they contain. */
|
|
|
|
static struct unit_table_t time_msec_units[] = {
|
|
|
|
{ "", 1 },
|
|
|
|
{ "msec", 1 },
|
|
|
|
{ "millisecond", 1 },
|
|
|
|
{ "milliseconds", 1 },
|
|
|
|
{ "second", 1000 },
|
|
|
|
{ "seconds", 1000 },
|
|
|
|
{ "minute", 60*1000 },
|
|
|
|
{ "minutes", 60*1000 },
|
|
|
|
{ "hour", 60*60*1000 },
|
|
|
|
{ "hours", 60*60*1000 },
|
|
|
|
{ "day", 24*60*60*1000 },
|
|
|
|
{ "days", 24*60*60*1000 },
|
|
|
|
{ "week", 7*24*60*60*1000 },
|
|
|
|
{ "weeks", 7*24*60*60*1000 },
|
|
|
|
{ NULL, 0 },
|
|
|
|
};
|
|
|
|
|
2004-11-20 01:37:00 +01:00
|
|
|
/** Parse a string <b>val</b> containing a number, zero or more
|
|
|
|
* spaces, and an optional unit string. If the unit appears in the
|
|
|
|
* table <b>u</b>, then multiply the number by the unit multiplier.
|
|
|
|
* On success, set *<b>ok</b> to 1 and return this product.
|
|
|
|
* Otherwise, set *<b>ok</b> to 0.
|
|
|
|
*/
|
|
|
|
static uint64_t
|
|
|
|
config_parse_units(const char *val, struct unit_table_t *u, int *ok)
|
|
|
|
{
|
2009-07-15 16:02:49 +02:00
|
|
|
uint64_t v = 0;
|
|
|
|
double d = 0;
|
|
|
|
int use_float = 0;
|
2009-08-31 06:18:55 +02:00
|
|
|
char *cp;
|
2004-11-20 01:37:00 +01:00
|
|
|
|
|
|
|
tor_assert(ok);
|
|
|
|
|
2009-08-31 06:18:55 +02:00
|
|
|
v = tor_parse_uint64(val, 10, 0, UINT64_MAX, ok, &cp);
|
|
|
|
if (!*ok || (cp && *cp == '.')) {
|
|
|
|
d = tor_parse_double(val, 0, UINT64_MAX, ok, &cp);
|
|
|
|
if (!*ok)
|
2009-07-15 16:02:49 +02:00
|
|
|
goto done;
|
|
|
|
use_float = 1;
|
|
|
|
}
|
|
|
|
|
2009-08-31 06:18:55 +02:00
|
|
|
if (!cp) {
|
2004-11-20 01:37:00 +01:00
|
|
|
*ok = 1;
|
2009-07-15 16:02:49 +02:00
|
|
|
v = use_float ? DBL_TO_U64(d) : v;
|
|
|
|
goto done;
|
2004-11-20 01:37:00 +01:00
|
|
|
}
|
2009-07-15 16:02:49 +02:00
|
|
|
|
2009-08-31 06:18:55 +02:00
|
|
|
cp = (char*) eat_whitespace(cp);
|
|
|
|
|
2004-11-20 01:37:00 +01:00
|
|
|
for ( ;u->unit;++u) {
|
2009-08-31 06:18:55 +02:00
|
|
|
if (!strcasecmp(u->unit, cp)) {
|
2009-07-15 16:02:49 +02:00
|
|
|
if (use_float)
|
|
|
|
v = u->multiplier * d;
|
|
|
|
else
|
|
|
|
v *= u->multiplier;
|
2004-11-20 01:37:00 +01:00
|
|
|
*ok = 1;
|
2009-07-15 16:02:49 +02:00
|
|
|
goto done;
|
2004-11-20 01:37:00 +01:00
|
|
|
}
|
|
|
|
}
|
2009-08-31 06:18:55 +02:00
|
|
|
log_warn(LD_CONFIG, "Unknown unit '%s'.", cp);
|
2004-11-20 01:37:00 +01:00
|
|
|
*ok = 0;
|
2009-07-15 16:02:49 +02:00
|
|
|
done:
|
|
|
|
|
|
|
|
if (*ok)
|
|
|
|
return v;
|
|
|
|
else
|
|
|
|
return 0;
|
2004-11-20 01:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/** Parse a string in the format "number unit", where unit is a unit of
|
|
|
|
* information (byte, KB, M, etc). On success, set *<b>ok</b> to true
|
|
|
|
* and return the number of bytes specified. Otherwise, set
|
|
|
|
* *<b>ok</b> to false and return 0. */
|
|
|
|
static uint64_t
|
2005-09-30 03:09:52 +02:00
|
|
|
config_parse_memunit(const char *s, int *ok)
|
|
|
|
{
|
2009-08-31 06:18:55 +02:00
|
|
|
uint64_t u = config_parse_units(s, memory_units, ok);
|
|
|
|
return u;
|
2004-11-20 01:37:00 +01:00
|
|
|
}
|
|
|
|
|
2010-08-27 08:13:54 +02:00
|
|
|
/** Parse a string in the format "number unit", where unit is a unit of
|
|
|
|
* time in milliseconds. On success, set *<b>ok</b> to true and return
|
|
|
|
* the number of milliseconds in the provided interval. Otherwise, set
|
|
|
|
* *<b>ok</b> to 0 and return -1. */
|
|
|
|
static int
|
|
|
|
config_parse_msec_interval(const char *s, int *ok)
|
|
|
|
{
|
|
|
|
uint64_t r;
|
|
|
|
r = config_parse_units(s, time_msec_units, ok);
|
|
|
|
if (!ok)
|
|
|
|
return -1;
|
|
|
|
if (r > INT_MAX) {
|
|
|
|
log_warn(LD_CONFIG, "Msec interval '%s' is too long", s);
|
|
|
|
*ok = 0;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return (int)r;
|
|
|
|
}
|
|
|
|
|
2004-11-20 01:37:00 +01:00
|
|
|
/** Parse a string in the format "number unit", where unit is a unit of time.
|
|
|
|
* On success, set *<b>ok</b> to true and return the number of seconds in
|
|
|
|
* the provided interval. Otherwise, set *<b>ok</b> to 0 and return -1.
|
|
|
|
*/
|
|
|
|
static int
|
2005-09-30 03:09:52 +02:00
|
|
|
config_parse_interval(const char *s, int *ok)
|
|
|
|
{
|
2004-11-20 01:37:00 +01:00
|
|
|
uint64_t r;
|
|
|
|
r = config_parse_units(s, time_units, ok);
|
|
|
|
if (!ok)
|
|
|
|
return -1;
|
|
|
|
if (r > INT_MAX) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_CONFIG, "Interval '%s' is too long", s);
|
2004-11-20 01:37:00 +01:00
|
|
|
*ok = 0;
|
|
|
|
return -1;
|
|
|
|
}
|
2004-11-22 23:24:10 +01:00
|
|
|
return (int)r;
|
2004-11-20 01:37:00 +01:00
|
|
|
}
|
|
|
|
|
2010-09-28 20:36:28 +02:00
|
|
|
/** Return the number of cpus configured in <b>options</b>. If we are
|
|
|
|
* told to auto-detect the number of cpus, return the auto-detected number. */
|
|
|
|
int
|
|
|
|
get_num_cpus(const or_options_t *options)
|
|
|
|
{
|
2010-11-15 20:14:13 +01:00
|
|
|
if (options->NumCPUs == 0) {
|
2010-09-28 20:36:28 +02:00
|
|
|
int n = compute_num_cpus();
|
|
|
|
return (n >= 1) ? n : 1;
|
|
|
|
} else {
|
2010-11-15 20:14:13 +01:00
|
|
|
return options->NumCPUs;
|
2010-09-28 20:36:28 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-08 15:53:19 +02:00
|
|
|
/**
|
|
|
|
* Initialize the libevent library.
|
|
|
|
*/
|
2006-03-26 08:51:26 +02:00
|
|
|
static void
|
2010-09-28 20:01:45 +02:00
|
|
|
init_libevent(const or_options_t *options)
|
2005-06-08 15:53:19 +02:00
|
|
|
{
|
2009-06-04 09:16:26 +02:00
|
|
|
const char *badness=NULL;
|
2010-09-28 20:01:45 +02:00
|
|
|
tor_libevent_cfg cfg;
|
|
|
|
|
|
|
|
tor_assert(options);
|
2009-06-04 09:16:26 +02:00
|
|
|
|
2005-06-08 15:53:19 +02:00
|
|
|
configure_libevent_logging();
|
|
|
|
/* If the kernel complains that some method (say, epoll) doesn't
|
|
|
|
* exist, we don't care about it, since libevent will cope.
|
|
|
|
*/
|
|
|
|
suppress_libevent_log_msg("Function not implemented");
|
2009-01-07 22:05:02 +01:00
|
|
|
|
2009-06-04 09:16:26 +02:00
|
|
|
tor_check_libevent_header_compatibility();
|
2009-01-07 22:05:02 +01:00
|
|
|
|
2010-09-28 20:01:45 +02:00
|
|
|
memset(&cfg, 0, sizeof(cfg));
|
|
|
|
cfg.disable_iocp = options->DisableIOCP;
|
2010-09-28 20:36:28 +02:00
|
|
|
cfg.num_cpus = get_num_cpus(options);
|
2010-09-28 20:01:45 +02:00
|
|
|
|
|
|
|
tor_libevent_initialize(&cfg);
|
2009-06-04 07:05:23 +02:00
|
|
|
|
2005-06-08 15:53:19 +02:00
|
|
|
suppress_libevent_log_msg(NULL);
|
2006-08-10 10:00:13 +02:00
|
|
|
|
2009-06-04 09:16:26 +02:00
|
|
|
tor_check_libevent_version(tor_libevent_get_method(),
|
|
|
|
get_options()->ORPort != 0,
|
|
|
|
&badness);
|
2007-01-06 08:34:02 +01:00
|
|
|
if (badness) {
|
2009-06-04 09:16:26 +02:00
|
|
|
const char *v = tor_libevent_get_version_str();
|
|
|
|
const char *m = tor_libevent_get_method();
|
2007-01-06 08:34:02 +01:00
|
|
|
control_event_general_status(LOG_WARN,
|
|
|
|
"BAD_LIBEVENT VERSION=%s METHOD=%s BADNESS=%s RECOVERED=NO",
|
|
|
|
v, m, badness);
|
2005-06-08 15:53:19 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-03-17 06:50:41 +01:00
|
|
|
/** Return the persistent state struct for this Tor. */
|
2005-07-28 21:01:48 +02:00
|
|
|
or_state_t *
|
|
|
|
get_or_state(void)
|
|
|
|
{
|
2007-01-11 00:48:24 +01:00
|
|
|
tor_assert(global_state);
|
2005-07-28 21:01:48 +02:00
|
|
|
return global_state;
|
|
|
|
}
|
|
|
|
|
2007-10-17 18:55:44 +02:00
|
|
|
/** Return a newly allocated string holding a filename relative to the data
|
|
|
|
* directory. If <b>sub1</b> is present, it is the first path component after
|
|
|
|
* the data directory. If <b>sub2</b> is also present, it is the second path
|
|
|
|
* component after the data directory. If <b>suffix</b> is present, it
|
|
|
|
* is appended to the filename.
|
|
|
|
*
|
|
|
|
* Examples:
|
|
|
|
* get_datadir_fname2_suffix("a", NULL, NULL) -> $DATADIR/a
|
|
|
|
* get_datadir_fname2_suffix("a", NULL, ".tmp") -> $DATADIR/a.tmp
|
|
|
|
* get_datadir_fname2_suffix("a", "b", ".tmp") -> $DATADIR/a/b/.tmp
|
|
|
|
* get_datadir_fname2_suffix("a", "b", NULL) -> $DATADIR/a/b
|
|
|
|
*
|
|
|
|
* Note: Consider using the get_datadir_fname* macros in or.h.
|
|
|
|
*/
|
|
|
|
char *
|
2008-09-01 22:06:26 +02:00
|
|
|
options_get_datadir_fname2_suffix(or_options_t *options,
|
|
|
|
const char *sub1, const char *sub2,
|
|
|
|
const char *suffix)
|
2005-07-28 21:01:48 +02:00
|
|
|
{
|
2007-10-17 18:55:44 +02:00
|
|
|
char *fname = NULL;
|
|
|
|
size_t len;
|
|
|
|
tor_assert(options);
|
|
|
|
tor_assert(options->DataDirectory);
|
|
|
|
tor_assert(sub1 || !sub2); /* If sub2 is present, sub1 must be present. */
|
|
|
|
len = strlen(options->DataDirectory);
|
|
|
|
if (sub1) {
|
|
|
|
len += strlen(sub1)+1;
|
|
|
|
if (sub2)
|
|
|
|
len += strlen(sub2)+1;
|
|
|
|
}
|
|
|
|
if (suffix)
|
|
|
|
len += strlen(suffix);
|
|
|
|
len++;
|
2005-07-28 21:01:48 +02:00
|
|
|
fname = tor_malloc(len);
|
2007-10-17 18:55:44 +02:00
|
|
|
if (sub1) {
|
|
|
|
if (sub2) {
|
|
|
|
tor_snprintf(fname, len, "%s"PATH_SEPARATOR"%s"PATH_SEPARATOR"%s",
|
|
|
|
options->DataDirectory, sub1, sub2);
|
|
|
|
} else {
|
|
|
|
tor_snprintf(fname, len, "%s"PATH_SEPARATOR"%s",
|
|
|
|
options->DataDirectory, sub1);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
strlcpy(fname, options->DataDirectory, len);
|
|
|
|
}
|
|
|
|
if (suffix)
|
|
|
|
strlcat(fname, suffix, len);
|
2005-07-28 21:01:48 +02:00
|
|
|
return fname;
|
|
|
|
}
|
|
|
|
|
2006-03-17 06:50:41 +01:00
|
|
|
/** Return 0 if every setting in <b>state</b> is reasonable, and a
|
|
|
|
* permissible transition from <b>old_state</b>. Else warn and return -1.
|
|
|
|
* Should have no side effects, except for normalizing the contents of
|
|
|
|
* <b>state</b>.
|
|
|
|
*/
|
2006-01-10 21:38:33 +01:00
|
|
|
/* XXX from_setconf is here because of bug 238 */
|
2005-07-28 21:01:48 +02:00
|
|
|
static int
|
2006-03-26 08:51:26 +02:00
|
|
|
or_state_validate(or_state_t *old_state, or_state_t *state,
|
|
|
|
int from_setconf, char **msg)
|
2005-07-28 21:01:48 +02:00
|
|
|
{
|
2006-06-05 00:42:13 +02:00
|
|
|
/* We don't use these; only options do. Still, we need to match that
|
|
|
|
* signature. */
|
|
|
|
(void) from_setconf;
|
|
|
|
(void) old_state;
|
2007-08-24 10:01:47 +02:00
|
|
|
|
2007-08-25 22:34:13 +02:00
|
|
|
if (entry_guards_parse_state(state, 0, msg)<0)
|
2006-01-02 05:14:52 +01:00
|
|
|
return -1;
|
2007-08-25 22:34:13 +02:00
|
|
|
|
2005-07-28 21:01:48 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-03-17 06:50:41 +01:00
|
|
|
/** Replace the current persistent state with <b>new_state</b> */
|
2010-07-06 21:08:13 +02:00
|
|
|
static int
|
2005-07-28 21:01:48 +02:00
|
|
|
or_state_set(or_state_t *new_state)
|
|
|
|
{
|
2006-03-26 08:51:26 +02:00
|
|
|
char *err = NULL;
|
2010-07-06 21:08:13 +02:00
|
|
|
int ret = 0;
|
2005-07-28 21:01:48 +02:00
|
|
|
tor_assert(new_state);
|
2009-12-12 08:07:59 +01:00
|
|
|
config_free(&state_format, global_state);
|
2005-07-28 21:01:48 +02:00
|
|
|
global_state = new_state;
|
2006-03-26 08:51:26 +02:00
|
|
|
if (entry_guards_parse_state(global_state, 1, &err)<0) {
|
|
|
|
log_warn(LD_GENERAL,"%s",err);
|
|
|
|
tor_free(err);
|
2010-07-06 21:08:13 +02:00
|
|
|
ret = -1;
|
2006-03-26 08:51:26 +02:00
|
|
|
}
|
|
|
|
if (rep_hist_load_state(global_state, &err)<0) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_GENERAL,"Unparseable bandwidth history state: %s",err);
|
2006-03-26 08:51:26 +02:00
|
|
|
tor_free(err);
|
2010-07-06 21:08:13 +02:00
|
|
|
ret = -1;
|
2006-03-26 08:51:26 +02:00
|
|
|
}
|
2010-08-15 14:22:32 +02:00
|
|
|
if (circuit_build_times_parse_state(&circ_times, global_state) < 0) {
|
2010-07-06 21:08:13 +02:00
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Save a broken state file to a backup location.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
or_state_save_broken(char *fname)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
file_status_t status;
|
|
|
|
size_t len = strlen(fname)+16;
|
|
|
|
char *fname2 = tor_malloc(len);
|
|
|
|
for (i = 0; i < 100; ++i) {
|
|
|
|
tor_snprintf(fname2, len, "%s.%d", fname, i);
|
|
|
|
status = file_status(fname2);
|
|
|
|
if (status == FN_NOENT)
|
|
|
|
break;
|
2009-08-26 02:13:12 +02:00
|
|
|
}
|
2010-07-06 21:08:13 +02:00
|
|
|
if (i == 100) {
|
|
|
|
log_warn(LD_BUG, "Unable to parse state in \"%s\"; too many saved bad "
|
|
|
|
"state files to move aside. Discarding the old state file.",
|
|
|
|
fname);
|
|
|
|
unlink(fname);
|
|
|
|
} else {
|
|
|
|
log_warn(LD_BUG, "Unable to parse state in \"%s\". Moving it aside "
|
|
|
|
"to \"%s\". This could be a bug in Tor; please tell "
|
|
|
|
"the developers.", fname, fname2);
|
|
|
|
if (rename(fname, fname2) < 0) {
|
|
|
|
log_warn(LD_BUG, "Weirdly, I couldn't even move the state aside. The "
|
|
|
|
"OS gave an error of %s", strerror(errno));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tor_free(fname2);
|
2005-07-28 21:01:48 +02:00
|
|
|
}
|
|
|
|
|
2006-03-17 06:50:41 +01:00
|
|
|
/** Reload the persistent state from disk, generating a new state as needed.
|
|
|
|
* Return 0 on success, less than 0 on failure.
|
|
|
|
*/
|
2007-10-02 22:35:23 +02:00
|
|
|
static int
|
2005-07-28 21:01:48 +02:00
|
|
|
or_state_load(void)
|
|
|
|
{
|
|
|
|
or_state_t *new_state = NULL;
|
|
|
|
char *contents = NULL, *fname;
|
2006-03-26 08:51:26 +02:00
|
|
|
char *errmsg = NULL;
|
2006-08-25 23:01:56 +02:00
|
|
|
int r = -1, badstate = 0;
|
2005-07-28 21:01:48 +02:00
|
|
|
|
2007-10-17 18:55:44 +02:00
|
|
|
fname = get_datadir_fname("state");
|
2005-07-28 21:01:48 +02:00
|
|
|
switch (file_status(fname)) {
|
|
|
|
case FN_FILE:
|
2006-10-20 01:05:02 +02:00
|
|
|
if (!(contents = read_file_to_str(fname, 0, NULL))) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_FS, "Unable to read state file \"%s\"", fname);
|
2005-07-28 21:01:48 +02:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case FN_NOENT:
|
|
|
|
break;
|
2006-08-11 09:09:17 +02:00
|
|
|
case FN_ERROR:
|
|
|
|
case FN_DIR:
|
2005-07-28 21:01:48 +02:00
|
|
|
default:
|
2006-02-13 10:02:35 +01:00
|
|
|
log_warn(LD_GENERAL,"State file \"%s\" is not a file? Failing.", fname);
|
2005-07-28 21:01:48 +02:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
new_state = tor_malloc_zero(sizeof(or_state_t));
|
|
|
|
new_state->_magic = OR_STATE_MAGIC;
|
|
|
|
config_init(&state_format, new_state);
|
|
|
|
if (contents) {
|
|
|
|
config_line_t *lines=NULL;
|
|
|
|
int assign_retval;
|
|
|
|
if (config_get_lines(contents, &lines)<0)
|
|
|
|
goto done;
|
2006-03-26 10:09:19 +02:00
|
|
|
assign_retval = config_assign(&state_format, new_state,
|
|
|
|
lines, 0, 0, &errmsg);
|
2005-07-28 21:01:48 +02:00
|
|
|
config_free_lines(lines);
|
|
|
|
if (assign_retval<0)
|
2006-08-25 23:01:56 +02:00
|
|
|
badstate = 1;
|
|
|
|
if (errmsg) {
|
|
|
|
log_warn(LD_GENERAL, "%s", errmsg);
|
|
|
|
tor_free(errmsg);
|
|
|
|
}
|
2005-07-28 21:01:48 +02:00
|
|
|
}
|
|
|
|
|
2006-08-25 23:01:56 +02:00
|
|
|
if (!badstate && or_state_validate(NULL, new_state, 1, &errmsg) < 0)
|
|
|
|
badstate = 1;
|
|
|
|
|
|
|
|
if (errmsg) {
|
|
|
|
log_warn(LD_GENERAL, "%s", errmsg);
|
|
|
|
tor_free(errmsg);
|
2006-03-26 08:51:26 +02:00
|
|
|
}
|
2005-07-28 21:01:48 +02:00
|
|
|
|
2006-08-25 23:01:56 +02:00
|
|
|
if (badstate && !contents) {
|
2006-08-26 06:48:50 +02:00
|
|
|
log_warn(LD_BUG, "Uh oh. We couldn't even validate our own default state."
|
|
|
|
" This is a bug in Tor.");
|
2006-08-25 23:01:56 +02:00
|
|
|
goto done;
|
|
|
|
} else if (badstate && contents) {
|
2010-07-06 21:08:13 +02:00
|
|
|
or_state_save_broken(fname);
|
|
|
|
|
2006-08-25 23:01:56 +02:00
|
|
|
tor_free(contents);
|
|
|
|
config_free(&state_format, new_state);
|
|
|
|
|
|
|
|
new_state = tor_malloc_zero(sizeof(or_state_t));
|
|
|
|
new_state->_magic = OR_STATE_MAGIC;
|
|
|
|
config_init(&state_format, new_state);
|
|
|
|
} else if (contents) {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_info(LD_GENERAL, "Loaded state from \"%s\"", fname);
|
2006-08-25 23:01:56 +02:00
|
|
|
} else {
|
2006-02-13 10:02:35 +01:00
|
|
|
log_info(LD_GENERAL, "Initialized state");
|
2006-08-25 23:01:56 +02:00
|
|
|
}
|
2010-07-06 21:08:13 +02:00
|
|
|
if (or_state_set(new_state) == -1) {
|
|
|
|
or_state_save_broken(fname);
|
|
|
|
}
|
2005-07-28 21:01:48 +02:00
|
|
|
new_state = NULL;
|
|
|
|
if (!contents) {
|
2006-12-07 21:11:30 +01:00
|
|
|
global_state->next_write = 0;
|
|
|
|
or_state_save(time(NULL));
|
2005-07-28 21:01:48 +02:00
|
|
|
}
|
|
|
|
r = 0;
|
2006-08-25 23:01:56 +02:00
|
|
|
|
2005-07-28 21:01:48 +02:00
|
|
|
done:
|
|
|
|
tor_free(fname);
|
|
|
|
tor_free(contents);
|
|
|
|
if (new_state)
|
|
|
|
config_free(&state_format, new_state);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2011-04-29 02:40:15 +02:00
|
|
|
/** Did the last time we tried to write the state file fail? If so, we
|
|
|
|
* should consider disabling such features as preemptive circuit generation
|
|
|
|
* to compute circuit-build-time. */
|
|
|
|
static int last_state_file_write_failed = 0;
|
|
|
|
|
|
|
|
/** Return whether the state file failed to write last time we tried. */
|
|
|
|
int
|
|
|
|
did_last_state_file_write_fail(void)
|
|
|
|
{
|
|
|
|
return last_state_file_write_failed;
|
|
|
|
}
|
|
|
|
|
2011-01-10 22:44:42 +01:00
|
|
|
/** If writing the state to disk fails, try again after this many seconds. */
|
|
|
|
#define STATE_WRITE_RETRY_INTERVAL 3600
|
|
|
|
|
2011-04-29 03:06:25 +02:00
|
|
|
/** If we're a relay, how often should we checkpoint our state file even
|
|
|
|
* if nothing else dirties it? This will checkpoint ongoing stats like
|
|
|
|
* bandwidth used, per-country user stats, etc. */
|
|
|
|
#define STATE_RELAY_CHECKPOINT_INTERVAL (12*60*60)
|
|
|
|
|
2006-03-17 06:50:41 +01:00
|
|
|
/** Write the persistent state to disk. Return 0 for success, <0 on failure. */
|
2005-07-28 21:01:48 +02:00
|
|
|
int
|
2006-12-07 21:11:30 +01:00
|
|
|
or_state_save(time_t now)
|
2005-07-28 21:01:48 +02:00
|
|
|
{
|
|
|
|
char *state, *contents;
|
|
|
|
char tbuf[ISO_TIME_LEN+1];
|
|
|
|
char *fname;
|
|
|
|
|
2006-01-02 05:14:52 +01:00
|
|
|
tor_assert(global_state);
|
|
|
|
|
2006-12-07 21:11:30 +01:00
|
|
|
if (global_state->next_write > now)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Call everything else that might dirty the state even more, in order
|
|
|
|
* to avoid redundant writes. */
|
2006-01-10 23:42:44 +01:00
|
|
|
entry_guards_update_state(global_state);
|
2005-12-24 00:56:42 +01:00
|
|
|
rep_hist_update_state(global_state);
|
2009-09-02 05:27:43 +02:00
|
|
|
circuit_build_times_update_state(&circ_times, global_state);
|
2006-12-09 03:55:40 +01:00
|
|
|
if (accounting_is_enabled(get_options()))
|
|
|
|
accounting_run_housekeeping(now);
|
2005-07-28 21:01:48 +02:00
|
|
|
|
2011-04-29 02:40:15 +02:00
|
|
|
global_state->LastWritten = now;
|
|
|
|
|
2006-01-02 05:14:52 +01:00
|
|
|
tor_free(global_state->TorVersion);
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(&global_state->TorVersion, "Tor %s", get_version());
|
2007-05-22 17:48:46 +02:00
|
|
|
|
2006-12-15 22:27:19 +01:00
|
|
|
state = config_dump(&state_format, global_state, 1, 0);
|
2011-04-29 02:40:15 +02:00
|
|
|
format_local_iso_time(tbuf, now);
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(&contents,
|
2006-12-15 00:39:14 +01:00
|
|
|
"# Tor state file last generated on %s local time\n"
|
|
|
|
"# Other times below are in GMT\n"
|
2005-07-28 21:01:48 +02:00
|
|
|
"# You *do not* need to edit this file.\n\n%s",
|
|
|
|
tbuf, state);
|
|
|
|
tor_free(state);
|
2007-10-17 18:55:44 +02:00
|
|
|
fname = get_datadir_fname("state");
|
2005-07-28 21:01:48 +02:00
|
|
|
if (write_str_to_file(fname, contents, 0)<0) {
|
2011-01-13 20:36:41 +01:00
|
|
|
log_warn(LD_FS, "Unable to write state to file \"%s\"; "
|
|
|
|
"will try again later", fname);
|
2011-04-29 02:40:15 +02:00
|
|
|
last_state_file_write_failed = 1;
|
2005-07-28 21:01:48 +02:00
|
|
|
tor_free(fname);
|
|
|
|
tor_free(contents);
|
2011-01-12 18:37:42 +01:00
|
|
|
/* Try again after STATE_WRITE_RETRY_INTERVAL (or sooner, if the state
|
|
|
|
* changes sooner). */
|
2011-01-10 22:44:42 +01:00
|
|
|
global_state->next_write = now + STATE_WRITE_RETRY_INTERVAL;
|
2005-07-28 21:01:48 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2010-05-08 20:54:29 +02:00
|
|
|
|
2011-04-29 02:40:15 +02:00
|
|
|
last_state_file_write_failed = 0;
|
2006-02-13 10:02:35 +01:00
|
|
|
log_info(LD_GENERAL, "Saved state to \"%s\"", fname);
|
2005-07-28 21:01:48 +02:00
|
|
|
tor_free(fname);
|
|
|
|
tor_free(contents);
|
|
|
|
|
2011-04-29 03:06:25 +02:00
|
|
|
if (server_mode(get_options()))
|
|
|
|
global_state->next_write = now + STATE_RELAY_CHECKPOINT_INTERVAL;
|
|
|
|
else
|
|
|
|
global_state->next_write = TIME_MAX;
|
|
|
|
|
2005-07-28 21:01:48 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-14 02:13:06 +02:00
|
|
|
/** Given a file name check to see whether the file exists but has not been
|
|
|
|
* modified for a very long time. If so, remove it. */
|
|
|
|
void
|
|
|
|
remove_file_if_very_old(const char *fname, time_t now)
|
|
|
|
{
|
|
|
|
#define VERY_OLD_FILE_AGE (28*24*60*60)
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (stat(fname, &st)==0 && st.st_mtime < now-VERY_OLD_FILE_AGE) {
|
|
|
|
char buf[ISO_TIME_LEN+1];
|
|
|
|
format_local_iso_time(buf, st.st_mtime);
|
|
|
|
log_notice(LD_GENERAL, "Obsolete file %s hasn't been modified since %s. "
|
|
|
|
"Removing it.", fname, buf);
|
|
|
|
unlink(fname);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-03-17 06:50:41 +01:00
|
|
|
/** Helper to implement GETINFO functions about configuration variables (not
|
|
|
|
* their values). Given a "config/names" question, set *<b>answer</b> to a
|
|
|
|
* new string describing the supported configuration variables and their
|
|
|
|
* types. */
|
2005-08-04 21:56:41 +02:00
|
|
|
int
|
2006-12-08 05:39:13 +01:00
|
|
|
getinfo_helper_config(control_connection_t *conn,
|
2010-07-18 17:05:58 +02:00
|
|
|
const char *question, char **answer,
|
|
|
|
const char **errmsg)
|
2005-08-04 21:56:41 +02:00
|
|
|
{
|
2006-12-08 05:39:13 +01:00
|
|
|
(void) conn;
|
2010-07-18 17:05:58 +02:00
|
|
|
(void) errmsg;
|
2005-08-04 21:56:41 +02:00
|
|
|
if (!strcmp(question, "config/names")) {
|
|
|
|
smartlist_t *sl = smartlist_create();
|
|
|
|
int i;
|
|
|
|
for (i = 0; _option_vars[i].name; ++i) {
|
|
|
|
config_var_t *var = &_option_vars[i];
|
2009-12-19 21:25:25 +01:00
|
|
|
const char *type;
|
2005-08-04 21:56:41 +02:00
|
|
|
char *line;
|
|
|
|
switch (var->type) {
|
2005-08-08 23:58:48 +02:00
|
|
|
case CONFIG_TYPE_STRING: type = "String"; break;
|
2008-06-16 20:09:53 +02:00
|
|
|
case CONFIG_TYPE_FILENAME: type = "Filename"; break;
|
2005-08-04 21:56:41 +02:00
|
|
|
case CONFIG_TYPE_UINT: type = "Integer"; break;
|
2011-05-02 21:05:10 +02:00
|
|
|
case CONFIG_TYPE_PORT: type = "Port"; break;
|
2005-08-08 23:58:48 +02:00
|
|
|
case CONFIG_TYPE_INTERVAL: type = "TimeInterval"; break;
|
2010-08-27 08:13:54 +02:00
|
|
|
case CONFIG_TYPE_MSEC_INTERVAL: type = "TimeMsecInterval"; break;
|
2005-08-04 21:56:41 +02:00
|
|
|
case CONFIG_TYPE_MEMUNIT: type = "DataSize"; break;
|
|
|
|
case CONFIG_TYPE_DOUBLE: type = "Float"; break;
|
|
|
|
case CONFIG_TYPE_BOOL: type = "Boolean"; break;
|
2010-11-08 19:34:40 +01:00
|
|
|
case CONFIG_TYPE_AUTOBOOL: type = "Boolean+Auto"; break;
|
2005-08-04 21:56:41 +02:00
|
|
|
case CONFIG_TYPE_ISOTIME: type = "Time"; break;
|
2008-07-18 20:36:32 +02:00
|
|
|
case CONFIG_TYPE_ROUTERSET: type = "RouterList"; break;
|
2005-08-04 21:56:41 +02:00
|
|
|
case CONFIG_TYPE_CSV: type = "CommaList"; break;
|
|
|
|
case CONFIG_TYPE_LINELIST: type = "LineList"; break;
|
|
|
|
case CONFIG_TYPE_LINELIST_S: type = "Dependant"; break;
|
|
|
|
case CONFIG_TYPE_LINELIST_V: type = "Virtual"; break;
|
|
|
|
default:
|
|
|
|
case CONFIG_TYPE_OBSOLETE:
|
|
|
|
type = NULL; break;
|
|
|
|
}
|
|
|
|
if (!type)
|
|
|
|
continue;
|
2010-03-01 03:46:50 +01:00
|
|
|
tor_asprintf(&line, "%s %s\n",var->name,type);
|
2005-08-04 21:56:41 +02:00
|
|
|
smartlist_add(sl, line);
|
|
|
|
}
|
|
|
|
*answer = smartlist_join_strings(sl, "", 0, NULL);
|
|
|
|
SMARTLIST_FOREACH(sl, char *, c, tor_free(c));
|
|
|
|
smartlist_free(sl);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|