summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--changes/bug89294
-rw-r--r--changes/bug92954
-rw-r--r--changes/bug93096
-rw-r--r--changes/bug93374
-rw-r--r--changes/ticket_92146
-rw-r--r--configure.ac2
-rw-r--r--doc/tor.1.txt29
-rw-r--r--src/common/util.c9
-rw-r--r--src/common/util.h3
-rw-r--r--src/or/channel.c4
-rw-r--r--src/or/channeltls.c5
-rw-r--r--src/or/circuitlist.c4
-rw-r--r--src/or/circuitlist.h1
-rw-r--r--src/or/circuitmux.c3
-rw-r--r--src/or/config.c103
-rw-r--r--src/or/config.h15
-rw-r--r--src/or/confparse.c16
-rw-r--r--src/or/confparse.h2
-rw-r--r--src/or/dns.c8
-rw-r--r--src/or/or.h11
-rw-r--r--src/or/relay.c42
-rw-r--r--src/or/relay.h3
-rw-r--r--src/or/transports.c105
-rw-r--r--src/or/transports.h10
-rw-r--r--src/test/include.am3
-rw-r--r--src/test/test.c6
-rw-r--r--src/test/test_cell_queue.c146
-rw-r--r--src/test/test_circuitmux.c84
-rw-r--r--src/test/test_config.c72
-rw-r--r--src/test/test_options.c169
-rw-r--r--src/test/test_pt.c120
-rw-r--r--src/test/test_util.c14
32 files changed, 927 insertions, 86 deletions
diff --git a/changes/bug8929 b/changes/bug8929
new file mode 100644
index 0000000000..2a1898b8a9
--- /dev/null
+++ b/changes/bug8929
@@ -0,0 +1,4 @@
+ o Minor features:
+ - Add a new torrc option "ServerTransportOptions" that allows
+ bridge operators to pass configuration parameters to their
+ pluggable transports. Resolves ticket 8929.
diff --git a/changes/bug9295 b/changes/bug9295
new file mode 100644
index 0000000000..2c113616c3
--- /dev/null
+++ b/changes/bug9295
@@ -0,0 +1,4 @@
+ o Major bugfixes:
+ - Avoid a crash when using --hash-password. Fixes bug 9295; bugfix on
+ 0.2.4.15-rc. Found by stem integration tests.
+
diff --git a/changes/bug9309 b/changes/bug9309
new file mode 100644
index 0000000000..38c462bc0f
--- /dev/null
+++ b/changes/bug9309
@@ -0,0 +1,6 @@
+ o Minor bugfixes:
+ - When evaluating whether to use a connection that we haven't
+ decided is canonical using a recent link protocol version,
+ decide that it's canonical only if it used address _does_
+ match the desired address. Fixes bug 9309; bugfix on
+ 0.2.4.4-alpha. Reported by skruffy.
diff --git a/changes/bug9337 b/changes/bug9337
new file mode 100644
index 0000000000..ce99bc8184
--- /dev/null
+++ b/changes/bug9337
@@ -0,0 +1,4 @@
+ o Major bugfixes (DNS):
+ - Avoid an assertion failure when processing DNS replies without the
+ answer types we expected. Fixes bug 9337; bugfix on 0.2.4.7-alpha.
+
diff --git a/changes/ticket_9214 b/changes/ticket_9214
new file mode 100644
index 0000000000..f1e43caeb0
--- /dev/null
+++ b/changes/ticket_9214
@@ -0,0 +1,6 @@
+ o Minor features:
+ - Accept bandwidth and space limits in bits as well as bytes.
+ (Anywhere in the configuration file that you can say "2 Kilobytes",
+ you can now say "16 kilobits", and so on.) Resolves ticket 9214.
+ Patch by CharlieB.
+
diff --git a/configure.ac b/configure.ac
index 73299696e3..4aeec929ef 100644
--- a/configure.ac
+++ b/configure.ac
@@ -47,8 +47,6 @@ AC_ARG_ENABLE(coverage,
AM_CONDITIONAL(UNITTESTS_ENABLED, test x$enable_unittests != xno)
AM_CONDITIONAL(COVERAGE_ENABLED, test x$enable_coverage = xyes)
-echo "COVERAGE: $enable_coverage"
-
if test "$enable_static_tor" = "yes"; then
enable_static_libevent="yes";
enable_static_openssl="yes";
diff --git a/doc/tor.1.txt b/doc/tor.1.txt
index a05ab33fce..fa49f1404d 100644
--- a/doc/tor.1.txt
+++ b/doc/tor.1.txt
@@ -124,42 +124,42 @@ option name with a forward slash.
GENERAL OPTIONS
---------------
-**BandwidthRate** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**::
+**BandwidthRate** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**|**KBits**|**MBits**|**GBits**::
A token bucket limits the average incoming bandwidth usage on this node to
the specified number of bytes per second, and the average outgoing
bandwidth usage to that same value. If you want to run a relay in the
public network, this needs to be _at the very least_ 30 KBytes (that is,
30720 bytes). (Default: 1 GByte)
-**BandwidthBurst** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**::
+**BandwidthBurst** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**|**KBits**|**MBits**|**GBits**::
Limit the maximum token bucket size (also known as the burst) to the given
number of bytes in each direction. (Default: 1 GByte)
-**MaxAdvertisedBandwidth** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**::
+**MaxAdvertisedBandwidth** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**|**KBits**|**MBits**|**GBits**::
If set, we will not advertise more than this amount of bandwidth for our
BandwidthRate. Server operators who want to reduce the number of clients
who ask to build circuits through them (since this is proportional to
advertised bandwidth rate) can thus reduce the CPU demands on their server
without impacting network performance.
-**RelayBandwidthRate** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**::
+**RelayBandwidthRate** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**|**KBits**|**MBits**|**GBits**::
If not 0, a separate token bucket limits the average incoming bandwidth
usage for \_relayed traffic_ on this node to the specified number of bytes
per second, and the average outgoing bandwidth usage to that same value.
Relayed traffic currently is calculated to include answers to directory
requests, but that may change in future versions. (Default: 0)
-**RelayBandwidthBurst** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**::
+**RelayBandwidthBurst** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**|**KBits**|**MBits**|**GBits**::
If not 0, limit the maximum token bucket size (also known as the burst) for
\_relayed traffic_ to the given number of bytes in each direction.
(Default: 0)
-**PerConnBWRate** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**::
+**PerConnBWRate** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**|**KBits**|**MBits**|**GBits**::
If set, do separate rate limiting for each connection from a non-relay.
You should never need to change this value, since a network-wide value is
published in the consensus and your relay will use that value. (Default: 0)
-**PerConnBWBurst** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**::
+**PerConnBWBurst** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**|**KBits**|**MBits**|**GBits**::
If set, do separate rate limiting for each connection from a non-relay.
You should never need to change this value, since a network-wide value is
published in the consensus and your relay will use that value. (Default: 0)
@@ -186,6 +186,11 @@ GENERAL OPTIONS
listening address of any pluggable transport proxy that tries to
launch __transport__.
+**ServerTransportOptions** __transport__ __k=v__ __k=v__ ...::
+ When this option is set, Tor will pass the __k=v__ parameters to
+ any pluggable transport proxy that tries to launch __transport__. +
+ (Example: ServerTransportOptions obfs45 shared-secret=bridgepasswd cache=/var/lib/tor/cache)
+
**ConnLimit** __NUM__::
The minimum number of file descriptors that must be available to the Tor
process before it will start. Tor will ask the OS for as many file
@@ -1537,7 +1542,7 @@ is non-zero):
server is still alive and doing useful things. Settings this
to 0 will disable the heartbeat. (Default: 6 hours)
-**AccountingMax** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**|**TBytes**::
+**AccountingMax** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**|**KBits**|**MBits**|**GBits**|**TBytes**::
Never send more than the specified number of bytes in a given accounting
period, or receive more than that number in the period. For example, with
AccountingMax set to 1 GByte, a server could send 900 MBytes and
@@ -1674,7 +1679,7 @@ is non-zero):
If it hits this threshold, it will begin killing circuits until it
has recovered at least 10% of this memory. Do not set this option too
low, or your relay may be unreliable under load. This option only
- effects circuit queues, so the actual process size will be larger than
+ affects circuit queues, so the actual process size will be larger than
this. (Default: 8GB)
DIRECTORY SERVER OPTIONS
@@ -1869,12 +1874,12 @@ DIRECTORY AUTHORITY SERVER OPTIONS
Authoritative directories only. Like AuthDirMaxServersPerAddr, but applies
to addresses shared with directory authorities. (Default: 5)
-**AuthDirFastGuarantee** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**::
+**AuthDirFastGuarantee** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**|**KBits**|**MBits**|**GBits**::
Authoritative directories only. If non-zero, always vote the
Fast flag for any relay advertising this amount of capacity or
more. (Default: 100 KBytes)
-**AuthDirGuardBWGuarantee** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**::
+**AuthDirGuardBWGuarantee** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**|**KBits**|**MBits**|**GBits**::
Authoritative directories only. If non-zero, this advertised capacity
or more is always sufficient to satisfy the bandwidth requirement
for the Guard flag. (Default: 250 KBytes)
@@ -2060,7 +2065,7 @@ The following options are used for running a testing Tor network.
time. Changing this requires that **TestingTorNetwork** is set. (Default:
10 minutes)
-**TestingMinFastFlagThreshold** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**::
+**TestingMinFastFlagThreshold** __N__ **bytes**|**KBytes**|**MBytes**|**GBytes**|**KBits**|**MBits**|**GBits**::
Minimum value for the Fast flag. Overrides the ordinary minimum taken
from the consensus when TestingTorNetwork is set. (Default: 0.)
diff --git a/src/common/util.c b/src/common/util.c
index a8867b691d..849a7178c6 100644
--- a/src/common/util.c
+++ b/src/common/util.c
@@ -1223,17 +1223,14 @@ escaped(const char *s)
return escaped_val_;
}
-/** Escape every ";" or "\" character of <b>string</b>. Use
- * <b>escape_char</b> as the character to use for escaping.
- * The returned string is allocated on the heap and it's the
- * responsibility of the caller to free it. */
+/** Return a newly allocated string equal to <b>string</b>, except that every
+ * character in <b>chars_to_escape</b> is preceded by a backslash. */
char *
-tor_escape_str_for_socks_arg(const char *string)
+tor_escape_str_for_pt_args(const char *string, const char *chars_to_escape)
{
char *new_string = NULL;
char *new_cp = NULL;
size_t length, new_length;
- static const char *chars_to_escape = ";\\";
tor_assert(string);
diff --git a/src/common/util.h b/src/common/util.h
index 505ef23bd2..dd7a169a1b 100644
--- a/src/common/util.h
+++ b/src/common/util.h
@@ -231,7 +231,8 @@ int tor_digest256_is_zero(const char *digest);
char *esc_for_log(const char *string) ATTR_MALLOC;
const char *escaped(const char *string);
-char *tor_escape_str_for_socks_arg(const char *string);
+char *tor_escape_str_for_pt_args(const char *string,
+ const char *chars_to_escape);
struct smartlist_t;
int tor_vsscanf(const char *buf, const char *pattern, va_list ap) \
diff --git a/src/or/channel.c b/src/or/channel.c
index 98c23d91ea..05f269b8fa 100644
--- a/src/or/channel.c
+++ b/src/or/channel.c
@@ -3090,7 +3090,7 @@ channel_get_for_extend(const char *digest,
if (chan->state != CHANNEL_STATE_OPEN) {
/* If the address matches, don't launch a new connection for this
* circuit. */
- if (!channel_matches_target_addr_for_extend(chan, target_addr))
+ if (channel_matches_target_addr_for_extend(chan, target_addr))
++n_inprogress_goodaddr;
continue;
}
@@ -4106,7 +4106,7 @@ channel_matches_extend_info(channel_t *chan, extend_info_t *extend_info)
}
/**
- * Check if a channel matches a given target address
+ * Check if a channel matches a given target address; return true iff we do.
*
* This function calls into the lower layer and asks if this channel thinks
* it matches a given target address for circuit extension purposes.
diff --git a/src/or/channeltls.c b/src/or/channeltls.c
index 60693daeb2..d758d22d82 100644
--- a/src/or/channeltls.c
+++ b/src/or/channeltls.c
@@ -546,7 +546,7 @@ channel_tls_matches_extend_info_method(channel_t *chan,
}
/**
- * Check if we match a target address
+ * Check if we match a target address; return true iff we do.
*
* This implements the matches_target method for channel_tls t_; the upper
* layer wants to know if this channel matches a target address when extending
@@ -563,8 +563,7 @@ channel_tls_matches_target_method(channel_t *chan,
tor_assert(target);
tor_assert(tlschan->conn);
- return tor_addr_compare(&(tlschan->conn->real_addr),
- target, CMP_EXACT);
+ return tor_addr_eq(&(tlschan->conn->real_addr), target);
}
/**
diff --git a/src/or/circuitlist.c b/src/or/circuitlist.c
index 5e51301ceb..85bacce485 100644
--- a/src/or/circuitlist.c
+++ b/src/or/circuitlist.c
@@ -682,6 +682,7 @@ init_circuit_base(circuit_t *circ)
circ->package_window = circuit_initial_package_window();
circ->deliver_window = CIRCWINDOW_START;
+ cell_queue_init(&circ->n_chan_cells);
circuit_add(circ);
}
@@ -727,6 +728,7 @@ or_circuit_new(circid_t p_circ_id, channel_t *p_chan)
circuit_set_p_circid_chan(circ, p_circ_id, p_chan);
circ->remaining_relay_early_cells = MAX_RELAY_EARLY_CELLS_PER_CIRCUIT;
+ cell_queue_init(&circ->p_chan_cells);
init_circuit_base(TO_CIRCUIT(circ));
@@ -1638,7 +1640,7 @@ marked_circuit_free_cells(circuit_t *circ)
}
/** Return the number of cells used by the circuit <b>c</b>'s cell queues. */
-static size_t
+STATIC size_t
n_cells_in_circ_queues(const circuit_t *c)
{
size_t n = c->n_chan_cells.n;
diff --git a/src/or/circuitlist.h b/src/or/circuitlist.h
index a5a54859b2..4e56f5264f 100644
--- a/src/or/circuitlist.h
+++ b/src/or/circuitlist.h
@@ -72,6 +72,7 @@ void channel_note_destroy_not_pending(channel_t *chan, circid_t id);
#ifdef CIRCUITLIST_PRIVATE
STATIC void circuit_free(circuit_t *circ);
+STATIC size_t n_cells_in_circ_queues(const circuit_t *c);
#endif
#endif
diff --git a/src/or/circuitmux.c b/src/or/circuitmux.c
index 081416368e..47b423066a 100644
--- a/src/or/circuitmux.c
+++ b/src/or/circuitmux.c
@@ -383,6 +383,7 @@ circuitmux_alloc(void)
rv = tor_malloc_zero(sizeof(*rv));
rv->chanid_circid_map = tor_malloc_zero(sizeof(*( rv->chanid_circid_map)));
HT_INIT(chanid_circid_muxinfo_map, rv->chanid_circid_map);
+ cell_queue_init(&rv->destroy_cell_queue);
return rv;
}
@@ -510,7 +511,7 @@ circuitmux_mark_destroyed_circids_usable(circuitmux_t *cmux, channel_t *chan)
{
packed_cell_t *cell;
int n_bad = 0;
- for (cell = cmux->destroy_cell_queue.head; cell; cell = cell->next) {
+ TOR_SIMPLEQ_FOREACH(cell, &cmux->destroy_cell_queue.head, next) {
circid_t circid = 0;
if (packed_cell_is_destroy(chan, cell, &circid)) {
channel_mark_circid_usable(chan, circid);
diff --git a/src/or/config.c b/src/or/config.c
index 6d3b133389..ad6689ceef 100644
--- a/src/or/config.c
+++ b/src/or/config.c
@@ -9,6 +9,7 @@
* \brief Code to parse and interpret configuration files.
**/
+#define CONFIG_PRIVATE
#include "or.h"
#include "addressmap.h"
#include "channel.h"
@@ -280,6 +281,7 @@ static config_var_t option_vars_[] = {
V(IPv6Exit, BOOL, "0"),
VAR("ServerTransportPlugin", LINELIST, ServerTransportPlugin, NULL),
V(ServerTransportListenAddr, LINELIST, NULL),
+ V(ServerTransportOptions, LINELIST, NULL),
V(Socks4Proxy, STRING, NULL),
V(Socks5Proxy, STRING, NULL),
V(Socks5ProxyUsername, STRING, NULL),
@@ -508,10 +510,6 @@ static const config_var_t testing_tor_network_defaults[] = {
#ifdef _WIN32
static char *get_windows_conf_root(void);
#endif
-static int options_validate(or_options_t *old_options,
- or_options_t *options,
- or_options_t *default_options,
- int from_setconf, char **msg);
static int options_act_reversible(const or_options_t *old_options, char **msg);
static int options_act(const or_options_t *old_options);
static int options_transition_allowed(const or_options_t *old,
@@ -555,7 +553,7 @@ static void config_maybe_load_geoip_files_(const or_options_t *options,
#define OR_OPTIONS_MAGIC 9090909
/** Configuration format for or_options_t. */
-static config_format_t options_format = {
+STATIC config_format_t options_format = {
sizeof(or_options_t),
OR_OPTIONS_MAGIC,
STRUCT_OFFSET(or_options_t, magic_),
@@ -711,7 +709,7 @@ get_short_version(void)
/** Release additional memory allocated in options
*/
-static void
+STATIC void
or_options_free(or_options_t *options)
{
if (!options)
@@ -2348,7 +2346,7 @@ compute_publishserverdescriptor(or_options_t *options)
* Log line should stay empty. If it's 0, then give us a default log
* if there are no logs defined.
*/
-static int
+STATIC int
options_validate(or_options_t *old_options, or_options_t *options,
or_options_t *default_options, int from_setconf, char **msg)
{
@@ -3147,6 +3145,19 @@ options_validate(or_options_t *old_options, or_options_t *options,
"ServerTransportListenAddr line will be ignored.");
}
+ for (cl = options->ServerTransportOptions; cl; cl = cl->next) {
+ /** If get_options_from_transport_options_line() fails with
+ 'transport' being NULL, it means that something went wrong
+ while parsing the ServerTransportOptions line. */
+ smartlist_t *options_sl =
+ get_options_from_transport_options_line(cl->value, NULL);
+ if (!options_sl)
+ REJECT("ServerTransportOptions did not parse. See logs for details.");
+
+ SMARTLIST_FOREACH(options_sl, char *, cp, tor_free(cp));
+ smartlist_free(options_sl);
+ }
+
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. */
@@ -3817,6 +3828,7 @@ options_init_from_torrc(int argc, char **argv)
}
if (command == CMD_HASH_PASSWORD) {
+ cf_defaults = tor_strdup("");
cf = tor_strdup("");
} else {
cf_defaults = load_torrc_from_disk(argc, argv, 1);
@@ -4580,6 +4592,63 @@ get_bindaddr_from_transport_listen_line(const char *line,const char *transport)
return addrport;
}
+/** Given a ServerTransportOptions <b>line</b>, return a smartlist
+ * with the options. Return NULL if the line was not well-formed.
+ *
+ * If <b>transport</b> is set, return NULL if the line is not
+ * referring to <b>transport</b>.
+ *
+ * The returned smartlist and its strings are allocated on the heap
+ * and it's the responsibility of the caller to free it. */
+smartlist_t *
+get_options_from_transport_options_line(const char *line,const char *transport)
+{
+ smartlist_t *items = smartlist_new();
+ smartlist_t *options = smartlist_new();
+ const char *parsed_transport = NULL;
+
+ smartlist_split_string(items, line, NULL,
+ SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
+
+ if (smartlist_len(items) < 2) {
+ log_warn(LD_CONFIG,"Too few arguments on ServerTransportOptions line.");
+ goto err;
+ }
+
+ parsed_transport = smartlist_get(items, 0);
+ /* If 'transport' is given, check if it matches the one on the line */
+ if (transport && strcmp(transport, parsed_transport))
+ goto err;
+
+ SMARTLIST_FOREACH_BEGIN(items, const char *, option) {
+ if (option_sl_idx == 0) /* skip the transport field (first field)*/
+ continue;
+
+ /* validate that it's a k=v value */
+ if (!string_is_key_value(LOG_WARN, option)) {
+ log_warn(LD_CONFIG, "%s is not a k=v value.", escaped(option));
+ goto err;
+ }
+
+ /* add it to the options smartlist */
+ smartlist_add(options, tor_strdup(option));
+ log_debug(LD_CONFIG, "Added %s to the list of options", escaped(option));
+ } SMARTLIST_FOREACH_END(option);
+
+ goto done;
+
+ err:
+ SMARTLIST_FOREACH(options, char*, s, tor_free(s));
+ smartlist_free(options);
+ options = NULL;
+
+ done:
+ SMARTLIST_FOREACH(items, char*, s, tor_free(s));
+ smartlist_free(items);
+
+ return options;
+}
+
/** Given the name of a pluggable transport in <b>transport</b>, check
* the configuration file to see if the user has explicitly asked for
* it to listen on a specific port. Return a <address:port> string if
@@ -4600,6 +4669,26 @@ get_transport_bindaddr_from_config(const char *transport)
return NULL;
}
+/** Given the name of a pluggable transport in <b>transport</b>, check
+ * the configuration file to see if the user has asked us to pass any
+ * parameters to the pluggable transport. Return a smartlist
+ * containing the parameters, otherwise NULL. */
+smartlist_t *
+get_options_for_server_transport(const char *transport)
+{
+ config_line_t *cl;
+ const or_options_t *options = get_options();
+
+ for (cl = options->ServerTransportOptions; cl; cl = cl->next) {
+ smartlist_t *options_sl =
+ get_options_from_transport_options_line(cl->value, transport);
+ if (options_sl)
+ return options_sl;
+ }
+
+ return NULL;
+}
+
/** Read the contents of a ServerTransportPlugin line from
* <b>line</b>. Return 0 if the line is well-formed, and -1 if it
* isn't.
diff --git a/src/or/config.h b/src/or/config.h
index c35214cd02..16a8a350d5 100644
--- a/src/or/config.h
+++ b/src/or/config.h
@@ -112,6 +112,21 @@ typedef struct bridge_line_t {
void bridge_line_free(bridge_line_t *bridge_line);
bridge_line_t *parse_bridge_line(const char *line);
+smartlist_t *get_options_from_transport_options_line(const char *line,
+ const char *transport);
+smartlist_t *get_options_for_server_transport(const char *transport);
+
+#ifdef CONFIG_PRIVATE
+#ifdef TOR_UNIT_TESTS
+extern struct config_format_t options_format;
+#endif
+
+STATIC void or_options_free(or_options_t *options);
+STATIC int options_validate(or_options_t *old_options,
+ or_options_t *options,
+ or_options_t *default_options,
+ int from_setconf, char **msg);
+#endif
#endif
diff --git a/src/or/confparse.c b/src/or/confparse.c
index eb0362f494..41055791ef 100644
--- a/src/or/confparse.c
+++ b/src/or/confparse.c
@@ -1126,20 +1126,36 @@ static struct unit_table_t memory_units[] = {
{ "kbytes", 1<<10 },
{ "kilobyte", 1<<10 },
{ "kilobytes", 1<<10 },
+ { "kilobits", 1<<7 },
+ { "kilobit", 1<<7 },
+ { "kbits", 1<<7 },
+ { "kbit", 1<<7 },
{ "m", 1<<20 },
{ "mb", 1<<20 },
{ "mbyte", 1<<20 },
{ "mbytes", 1<<20 },
{ "megabyte", 1<<20 },
{ "megabytes", 1<<20 },
+ { "megabits", 1<<17 },
+ { "megabit", 1<<17 },
+ { "mbits", 1<<17 },
+ { "mbit", 1<<17 },
{ "gb", 1<<30 },
{ "gbyte", 1<<30 },
{ "gbytes", 1<<30 },
{ "gigabyte", 1<<30 },
{ "gigabytes", 1<<30 },
+ { "gigabits", 1<<27 },
+ { "gigabit", 1<<27 },
+ { "gbits", 1<<27 },
+ { "gbit", 1<<27 },
{ "tb", U64_LITERAL(1)<<40 },
{ "terabyte", U64_LITERAL(1)<<40 },
{ "terabytes", U64_LITERAL(1)<<40 },
+ { "terabits", U64_LITERAL(1)<<37 },
+ { "terabit", U64_LITERAL(1)<<37 },
+ { "tbits", U64_LITERAL(1)<<37 },
+ { "tbit", U64_LITERAL(1)<<37 },
{ NULL, 0 },
};
diff --git a/src/or/confparse.h b/src/or/confparse.h
index d82e1096ca..924ee0d945 100644
--- a/src/or/confparse.h
+++ b/src/or/confparse.h
@@ -76,7 +76,7 @@ typedef int (*validate_fn_t)(void*,void*,int,char**);
/** Information on the keys, value types, key-to-struct-member mappings,
* variable descriptions, validation functions, and abbreviations for a
* configuration or storage format. */
-typedef struct {
+typedef struct config_format_t {
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. */
diff --git a/src/or/dns.c b/src/or/dns.c
index edcf92e5b3..f2b7eecc3f 100644
--- a/src/or/dns.c
+++ b/src/or/dns.c
@@ -437,8 +437,8 @@ cached_resolve_add_answer(cached_resolve_t *resolve,
if (resolve->res_status_ipv4 != RES_STATUS_INFLIGHT)
return;
- if (dns_result == DNS_ERR_NONE && answer_addr) {
- tor_assert(tor_addr_family(answer_addr) == AF_INET);
+ if (dns_result == DNS_ERR_NONE && answer_addr &&
+ tor_addr_family(answer_addr) == AF_INET) {
resolve->result_ipv4.addr_ipv4 = tor_addr_to_ipv4h(answer_addr);
resolve->res_status_ipv4 = RES_STATUS_DONE_OK;
} else {
@@ -450,8 +450,8 @@ cached_resolve_add_answer(cached_resolve_t *resolve,
if (resolve->res_status_ipv6 != RES_STATUS_INFLIGHT)
return;
- if (dns_result == DNS_ERR_NONE && answer_addr) {
- tor_assert(tor_addr_family(answer_addr) == AF_INET6);
+ if (dns_result == DNS_ERR_NONE && answer_addr &&
+ tor_addr_family(answer_addr) == AF_INET6) {
memcpy(&resolve->result_ipv6.addr_ipv6,
tor_addr_to_in6(answer_addr),
sizeof(struct in6_addr));
diff --git a/src/or/or.h b/src/or/or.h
index 568958d61f..06363fa360 100644
--- a/src/or/or.h
+++ b/src/or/or.h
@@ -99,6 +99,7 @@
#include "ht.h"
#include "replaycache.h"
#include "crypto_curve25519.h"
+#include "tor_queue.h"
/* These signals are defined to help handle_control_signal work.
*/
@@ -1083,7 +1084,8 @@ typedef struct var_cell_t {
/** A cell as packed for writing to the network. */
typedef struct packed_cell_t {
- struct packed_cell_t *next; /**< Next cell queued on this circuit. */
+ /** Next cell queued on this circuit. */
+ TOR_SIMPLEQ_ENTRY(packed_cell_t) next;
char body[CELL_MAX_NETWORK_SIZE]; /**< Cell as packed for network. */
} packed_cell_t;
@@ -1105,8 +1107,8 @@ typedef struct insertion_time_queue_t {
/** A queue of cells on a circuit, waiting to be added to the
* or_connection_t's outbuf. */
typedef struct cell_queue_t {
- packed_cell_t *head; /**< The first cell, or NULL if the queue is empty. */
- packed_cell_t *tail; /**< The last cell, or NULL if the queue is empty. */
+ /** Linked list of packed_cell_t*/
+ TOR_SIMPLEQ_HEAD(cell_simpleq, packed_cell_t) head;
int n; /**< The number of cells in the queue. */
insertion_time_queue_t *insertion_times; /**< Insertion times of cells. */
} cell_queue_t;
@@ -3500,6 +3502,9 @@ typedef struct {
/** List of TCP/IP addresses that transports should listen at. */
config_line_t *ServerTransportListenAddr;
+ /** List of options that must be passed to pluggable transports. */
+ config_line_t *ServerTransportOptions;
+
int BridgeRelay; /**< Boolean: are we acting as a bridge relay? We make
* this explicit so we can change how we behave in the
* future. */
diff --git a/src/or/relay.c b/src/or/relay.c
index 7ec7e03024..297f0f69e0 100644
--- a/src/or/relay.c
+++ b/src/or/relay.c
@@ -2089,7 +2089,7 @@ packed_cell_free_unchecked(packed_cell_t *cell)
}
/** Allocate and return a new packed_cell_t. */
-static INLINE packed_cell_t *
+STATIC packed_cell_t *
packed_cell_new(void)
{
++total_cells_allocated;
@@ -2100,6 +2100,8 @@ packed_cell_new(void)
void
packed_cell_free(packed_cell_t *cell)
{
+ if (!cell)
+ return;
packed_cell_free_unchecked(cell);
}
@@ -2129,7 +2131,6 @@ packed_cell_copy(const cell_t *cell, int wide_circ_ids)
{
packed_cell_t *c = packed_cell_new();
cell_pack(c, cell, wide_circ_ids);
- c->next = NULL;
return c;
}
@@ -2137,14 +2138,7 @@ packed_cell_copy(const cell_t *cell, int wide_circ_ids)
void
cell_queue_append(cell_queue_t *queue, packed_cell_t *cell)
{
- if (queue->tail) {
- tor_assert(!queue->tail->next);
- queue->tail->next = cell;
- } else {
- queue->head = cell;
- }
- queue->tail = cell;
- cell->next = NULL;
+ TOR_SIMPLEQ_INSERT_TAIL(&queue->head, cell, next);
++queue->n;
}
@@ -2187,18 +2181,24 @@ cell_queue_append_packed_copy(cell_queue_t *queue, const cell_t *cell,
cell_queue_append(queue, copy);
}
+/** Initialize <b>queue</b> as an empty cell queue. */
+void
+cell_queue_init(cell_queue_t *queue)
+{
+ memset(queue, 0, sizeof(cell_queue_t));
+ TOR_SIMPLEQ_INIT(&queue->head);
+}
+
/** Remove and free every cell in <b>queue</b>. */
void
cell_queue_clear(cell_queue_t *queue)
{
- packed_cell_t *cell, *next;
- cell = queue->head;
- while (cell) {
- next = cell->next;
+ packed_cell_t *cell;
+ while ((cell = TOR_SIMPLEQ_FIRST(&queue->head))) {
+ TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
packed_cell_free_unchecked(cell);
- cell = next;
}
- queue->head = queue->tail = NULL;
+ TOR_SIMPLEQ_INIT(&queue->head);
queue->n = 0;
if (queue->insertion_times) {
while (queue->insertion_times->first) {
@@ -2212,17 +2212,13 @@ cell_queue_clear(cell_queue_t *queue)
/** Extract and return the cell at the head of <b>queue</b>; return NULL if
* <b>queue</b> is empty. */
-static INLINE packed_cell_t *
+STATIC packed_cell_t *
cell_queue_pop(cell_queue_t *queue)
{
- packed_cell_t *cell = queue->head;
+ packed_cell_t *cell = TOR_SIMPLEQ_FIRST(&queue->head);
if (!cell)
return NULL;
- queue->head = cell->next;
- if (cell == queue->tail) {
- tor_assert(!queue->head);
- queue->tail = NULL;
- }
+ TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
--queue->n;
return cell;
}
diff --git a/src/or/relay.h b/src/or/relay.h
index 4be3194e5b..e1b5e381ed 100644
--- a/src/or/relay.h
+++ b/src/or/relay.h
@@ -51,6 +51,7 @@ size_t packed_cell_mem_cost(void);
/* For channeltls.c */
void packed_cell_free(packed_cell_t *cell);
+void cell_queue_init(cell_queue_t *queue);
void cell_queue_clear(cell_queue_t *queue);
void cell_queue_append(cell_queue_t *queue, packed_cell_t *cell);
void cell_queue_append_packed_copy(cell_queue_t *queue, const cell_t *cell,
@@ -81,6 +82,8 @@ int relay_crypt(circuit_t *circ, cell_t *cell, cell_direction_t cell_direction,
#ifdef RELAY_PRIVATE
STATIC int connected_cell_parse(const relay_header_t *rh, const cell_t *cell,
tor_addr_t *addr_out, int *ttl_out);
+STATIC packed_cell_t *packed_cell_new(void);
+STATIC packed_cell_t *cell_queue_pop(cell_queue_t *queue);
#endif
#endif
diff --git a/src/or/transports.c b/src/or/transports.c
index 0bd024fab7..62cc1a864f 100644
--- a/src/or/transports.c
+++ b/src/or/transports.c
@@ -102,9 +102,6 @@ create_managed_proxy_environment(const managed_proxy_t *mp);
static INLINE int proxy_configuration_finished(const managed_proxy_t *mp);
-static void managed_proxy_destroy(managed_proxy_t *mp,
- int also_terminate_process);
-
static void handle_finished_proxy(managed_proxy_t *mp);
static void parse_method_error(const char *line, int is_server_method);
#define parse_server_method_error(l) parse_method_error(l, 1)
@@ -135,7 +132,8 @@ static smartlist_t *transport_list = NULL;
SOCKS version <b>socks_ver</b>. */
static transport_t *
transport_new(const tor_addr_t *addr, uint16_t port,
- const char *name, int socks_ver)
+ const char *name, int socks_ver,
+ const char *extra_info_args)
{
transport_t *t = tor_malloc_zero(sizeof(transport_t));
@@ -143,6 +141,8 @@ transport_new(const tor_addr_t *addr, uint16_t port,
t->port = port;
t->name = tor_strdup(name);
t->socks_version = socks_ver;
+ if (extra_info_args)
+ t->extra_info_args = tor_strdup(extra_info_args);
return t;
}
@@ -155,6 +155,7 @@ transport_free(transport_t *transport)
return;
tor_free(transport->name);
+ tor_free(transport->extra_info_args);
tor_free(transport);
}
@@ -322,7 +323,7 @@ int
transport_add_from_config(const tor_addr_t *addr, uint16_t port,
const char *name, int socks_ver)
{
- transport_t *t = transport_new(addr, port, name, socks_ver);
+ transport_t *t = transport_new(addr, port, name, socks_ver, NULL);
int r = transport_add(t);
@@ -698,7 +699,7 @@ register_proxy(const managed_proxy_t *mp)
}
/** Free memory allocated by managed proxy <b>mp</b>. */
-static void
+STATIC void
managed_proxy_destroy(managed_proxy_t *mp,
int also_terminate_process)
{
@@ -945,7 +946,7 @@ parse_smethod_line(const char *line, managed_proxy_t *mp)
smartlist_t *items = NULL;
char *method_name=NULL;
-
+ char *args_string=NULL;
char *addrport=NULL;
tor_addr_t tor_addr;
char *address=NULL;
@@ -962,6 +963,9 @@ parse_smethod_line(const char *line, managed_proxy_t *mp)
goto err;
}
+ /* Example of legit SMETHOD line:
+ SMETHOD obfs2 0.0.0.0:25612 ARGS:secret=supersekrit,key=superkey */
+
tor_assert(!strcmp(smartlist_get(items,0),PROTO_SMETHOD));
method_name = smartlist_get(items,1);
@@ -989,7 +993,19 @@ parse_smethod_line(const char *line, managed_proxy_t *mp)
goto err;
}
- transport = transport_new(&tor_addr, port, method_name, PROXY_NONE);
+ if (smartlist_len(items) > 3) {
+ /* Seems like there are also some [options] in the SMETHOD line.
+ Let's see if we can parse them. */
+ char *options_string = smartlist_get(items, 3);
+ log_debug(LD_CONFIG, "Got options_string: %s", options_string);
+ if (!strcmpstart(options_string, "ARGS:")) {
+ args_string = options_string+strlen("ARGS:");
+ log_debug(LD_CONFIG, "Got ARGS: %s", args_string);
+ }
+ }
+
+ transport = transport_new(&tor_addr, port, method_name,
+ PROXY_NONE, args_string);
if (!transport)
goto err;
@@ -1081,7 +1097,7 @@ parse_cmethod_line(const char *line, managed_proxy_t *mp)
goto err;
}
- transport = transport_new(&tor_addr, port, method_name, socks_ver);
+ transport = transport_new(&tor_addr, port, method_name, socks_ver, NULL);
if (!transport)
goto err;
@@ -1104,6 +1120,50 @@ parse_cmethod_line(const char *line, managed_proxy_t *mp)
return r;
}
+/** Return a newly allocated string that tor should place in
+ * TOR_PT_SERVER_TRANSPORT_OPTIONS while configuring the server
+ * manged proxy in <b>mp</b>. Return NULL if no such options are found. */
+STATIC char *
+get_transport_options_for_server_proxy(const managed_proxy_t *mp)
+{
+ char *options_string = NULL;
+ smartlist_t *string_sl = smartlist_new();
+
+ tor_assert(mp->is_server);
+
+ /** Loop over the transports of the proxy. If we have options for
+ any of them, format them appropriately and place them in our
+ smartlist. Finally, join our smartlist to get the final
+ string. */
+ SMARTLIST_FOREACH_BEGIN(mp->transports_to_launch, const char *, transport) {
+ smartlist_t *options_tmp_sl = NULL;
+ options_tmp_sl = get_options_for_server_transport(transport);
+ if (!options_tmp_sl)
+ continue;
+
+ /** Loop over the options of this transport, escape them, and
+ place them in the smartlist. */
+ SMARTLIST_FOREACH_BEGIN(options_tmp_sl, const char *, options) {
+ char *escaped_opts = tor_escape_str_for_pt_args(options, ":;\\");
+ smartlist_add_asprintf(string_sl, "%s:%s",
+ transport, escaped_opts);
+ tor_free(escaped_opts);
+ } SMARTLIST_FOREACH_END(options);
+
+ SMARTLIST_FOREACH(options_tmp_sl, char *, c, tor_free(c));
+ smartlist_free(options_tmp_sl);
+ } SMARTLIST_FOREACH_END(transport);
+
+ if (smartlist_len(string_sl)) {
+ options_string = smartlist_join_strings(string_sl, ";", 0, NULL);
+ }
+
+ SMARTLIST_FOREACH(string_sl, char *, t, tor_free(t));
+ smartlist_free(string_sl);
+
+ return options_string;
+}
+
/** Return the string that tor should place in TOR_PT_SERVER_BINDADDR
* while configuring the server managed proxy in <b>mp</b>. The
* string is stored in the heap, and it's the the responsibility of
@@ -1185,6 +1245,16 @@ create_managed_proxy_environment(const managed_proxy_t *mp)
tor_free(bindaddr_tmp);
}
+ {
+ char *server_transport_options =
+ get_transport_options_for_server_proxy(mp);
+ if (server_transport_options) {
+ smartlist_add_asprintf(envs, "TOR_PT_SERVER_TRANSPORT_OPTIONS=%s",
+ server_transport_options);
+ tor_free(server_transport_options);
+ }
+ }
+
/* XXX024 Remove the '=' here once versions of obfsproxy which
* assert that this env var exists are sufficiently dead.
*
@@ -1215,7 +1285,7 @@ create_managed_proxy_environment(const managed_proxy_t *mp)
* <b>proxy_argv</b>.
*
* Requires that proxy_argv have at least one element. */
-static managed_proxy_t *
+STATIC managed_proxy_t *
managed_proxy_create(const smartlist_t *transport_list,
char **proxy_argv, int is_server)
{
@@ -1389,6 +1459,8 @@ pt_get_extra_info_descriptor_string(void)
tor_assert(mp->transports);
SMARTLIST_FOREACH_BEGIN(mp->transports, const transport_t *, t) {
+ char *transport_args = NULL;
+
/* If the transport proxy returned "0.0.0.0" as its address, and
* we know our external IP address, use it. Otherwise, use the
* returned address. */
@@ -1404,9 +1476,16 @@ pt_get_extra_info_descriptor_string(void)
addrport = fmt_addrport(&t->addr, t->port);
}
+ /* If this transport has any arguments with it, prepend a space
+ to them so that we can add them to the transport line. */
+ if (t->extra_info_args)
+ tor_asprintf(&transport_args, " %s", t->extra_info_args);
+
smartlist_add_asprintf(string_chunks,
- "transport %s %s",
- t->name, addrport);
+ "transport %s %s%s",
+ t->name, addrport,
+ transport_args ? transport_args : "");
+ tor_free(transport_args);
} SMARTLIST_FOREACH_END(t);
} SMARTLIST_FOREACH_END(mp);
@@ -1444,7 +1523,7 @@ pt_stringify_socks_args(const smartlist_t *socks_args)
SMARTLIST_FOREACH_BEGIN(socks_args, const char *, s) {
/* Escape ';' and '\'. */
- escaped_string = tor_escape_str_for_socks_arg(s);
+ escaped_string = tor_escape_str_for_pt_args(s, ";\\");
if (!escaped_string)
goto done;
diff --git a/src/or/transports.h b/src/or/transports.h
index 7f180a67b9..7b524f2073 100644
--- a/src/or/transports.h
+++ b/src/or/transports.h
@@ -25,6 +25,9 @@ typedef struct transport_t {
/** Boolean: We are re-parsing our transport list, and we are going to remove
* this one if we don't find it in the list of configured transports. */
unsigned marked_for_removal : 1;
+ /** Arguments for this transport that must be written to the
+ extra-info descriptor. */
+ char *extra_info_args;
} transport_t;
void mark_transport_list(void);
@@ -110,6 +113,13 @@ STATIC int parse_smethod_line(const char *line, managed_proxy_t *mp);
STATIC int parse_version(const char *line, managed_proxy_t *mp);
STATIC void parse_env_error(const char *line);
STATIC void handle_proxy_line(const char *line, managed_proxy_t *mp);
+STATIC char *get_transport_options_for_server_proxy(const managed_proxy_t *mp);
+
+STATIC void managed_proxy_destroy(managed_proxy_t *mp,
+ int also_terminate_process);
+
+STATIC managed_proxy_t *managed_proxy_create(const smartlist_t *transport_list,
+ char **proxy_argv, int is_server);
STATIC int configure_proxy(managed_proxy_t *mp);
diff --git a/src/test/include.am b/src/test/include.am
index 279369e74f..fb704d7185 100644
--- a/src/test/include.am
+++ b/src/test/include.am
@@ -20,12 +20,15 @@ src_test_test_SOURCES = \
src/test/test_addr.c \
src/test/test_cell_formats.c \
src/test/test_circuitlist.c \
+ src/test/test_circuitmux.c \
src/test/test_containers.c \
src/test/test_crypto.c \
+ src/test/test_cell_queue.c \
src/test/test_data.c \
src/test/test_dir.c \
src/test/test_introduce.c \
src/test/test_microdesc.c \
+ src/test/test_options.c \
src/test/test_pt.c \
src/test/test_replay.c \
src/test/test_util.c \
diff --git a/src/test/test.c b/src/test/test.c
index d7d4c6c062..60fbfb132c 100644
--- a/src/test/test.c
+++ b/src/test/test.c
@@ -2133,6 +2133,9 @@ extern struct testcase_t introduce_tests[];
extern struct testcase_t replaycache_tests[];
extern struct testcase_t cell_format_tests[];
extern struct testcase_t circuitlist_tests[];
+extern struct testcase_t circuitmux_tests[];
+extern struct testcase_t cell_queue_tests[];
+extern struct testcase_t options_tests[];
static struct testgroup_t testgroups[] = {
{ "", test_array },
@@ -2142,6 +2145,7 @@ static struct testgroup_t testgroups[] = {
{ "container/", container_tests },
{ "util/", util_tests },
{ "cellfmt/", cell_format_tests },
+ { "cellqueue/", cell_queue_tests },
{ "dir/", dir_tests },
{ "dir/md/", microdesc_tests },
{ "pt/", pt_tests },
@@ -2149,6 +2153,8 @@ static struct testgroup_t testgroups[] = {
{ "replaycache/", replaycache_tests },
{ "introduce/", introduce_tests },
{ "circuitlist/", circuitlist_tests },
+ { "circuitmux/", circuitmux_tests },
+ { "options/", options_tests },
END_OF_GROUPS
};
diff --git a/src/test/test_cell_queue.c b/src/test/test_cell_queue.c
new file mode 100644
index 0000000000..cf2d11ad5d
--- /dev/null
+++ b/src/test/test_cell_queue.c
@@ -0,0 +1,146 @@
+/* Copyright (c) 2013, The Tor Project, Inc. */
+/* See LICENSE for licensing information */
+
+#define CIRCUITLIST_PRIVATE
+#define RELAY_PRIVATE
+#include "or.h"
+#include "circuitlist.h"
+#include "relay.h"
+#include "test.h"
+
+static void
+test_cq_manip(void *arg)
+{
+ packed_cell_t *pc1=NULL, *pc2=NULL, *pc3=NULL, *pc4=NULL, *pc_tmp=NULL;
+ cell_queue_t cq;
+ cell_t cell;
+ (void) arg;
+
+ init_cell_pool();
+ cell_queue_init(&cq);
+ tt_int_op(cq.n, ==, 0);
+
+ pc1 = packed_cell_new();
+ pc2 = packed_cell_new();
+ pc3 = packed_cell_new();
+ pc4 = packed_cell_new();
+ tt_assert(pc1 && pc2 && pc3 && pc4);
+
+ tt_ptr_op(NULL, ==, cell_queue_pop(&cq));
+
+ /* Add and remove a singleton. */
+ cell_queue_append(&cq, pc1);
+ tt_int_op(cq.n, ==, 1);
+ tt_ptr_op(pc1, ==, cell_queue_pop(&cq));
+ tt_int_op(cq.n, ==, 0);
+
+ /* Add and remove four items */
+ cell_queue_append(&cq, pc4);
+ cell_queue_append(&cq, pc3);
+ cell_queue_append(&cq, pc2);
+ cell_queue_append(&cq, pc1);
+ tt_int_op(cq.n, ==, 4);
+ tt_ptr_op(pc4, ==, cell_queue_pop(&cq));
+ tt_ptr_op(pc3, ==, cell_queue_pop(&cq));
+ tt_ptr_op(pc2, ==, cell_queue_pop(&cq));
+ tt_ptr_op(pc1, ==, cell_queue_pop(&cq));
+ tt_int_op(cq.n, ==, 0);
+ tt_ptr_op(NULL, ==, cell_queue_pop(&cq));
+
+ /* Try a packed copy (wide, then narrow, which is a bit of a cheat, since a
+ * real cell queue has only one type.) */
+ memset(&cell, 0, sizeof(cell));
+ cell.circ_id = 0x12345678;
+ cell.command = 10;
+ strlcpy((char*)cell.payload, "Lorax ipsum gruvvulus thneed amet, snergelly "
+ "once-ler lerkim, sed do barbaloot tempor gluppitus ut labore et "
+ "truffula magna aliqua.",
+ sizeof(cell.payload));
+ cell_queue_append_packed_copy(&cq, &cell, 1 /*wide*/, 0 /*stats*/);
+ cell.circ_id = 0x2013;
+ cell_queue_append_packed_copy(&cq, &cell, 0 /*wide*/, 0 /*stats*/);
+ tt_int_op(cq.n, ==, 2);
+
+ pc_tmp = cell_queue_pop(&cq);
+ tt_int_op(cq.n, ==, 1);
+ tt_ptr_op(pc_tmp, !=, NULL);
+ test_mem_op(pc_tmp->body, ==, "\x12\x34\x56\x78\x0a", 5);
+ test_mem_op(pc_tmp->body+5, ==, cell.payload, sizeof(cell.payload));
+ packed_cell_free(pc_tmp);
+
+ pc_tmp = cell_queue_pop(&cq);
+ tt_int_op(cq.n, ==, 0);
+ tt_ptr_op(pc_tmp, !=, NULL);
+ test_mem_op(pc_tmp->body, ==, "\x20\x13\x0a", 3);
+ test_mem_op(pc_tmp->body+3, ==, cell.payload, sizeof(cell.payload));
+ packed_cell_free(pc_tmp);
+ pc_tmp = NULL;
+
+ tt_ptr_op(NULL, ==, cell_queue_pop(&cq));
+
+ /* Now make sure cell_queue_clear works. */
+ cell_queue_append(&cq, pc2);
+ cell_queue_append(&cq, pc1);
+ tt_int_op(cq.n, ==, 2);
+ cell_queue_clear(&cq);
+ pc2 = pc1 = NULL; /* prevent double-free */
+ tt_int_op(cq.n, ==, 0);
+
+ done:
+ packed_cell_free(pc1);
+ packed_cell_free(pc2);
+ packed_cell_free(pc3);
+ packed_cell_free(pc4);
+ packed_cell_free(pc_tmp);
+
+ cell_queue_clear(&cq);
+ free_cell_pool();
+}
+
+static void
+test_circuit_n_cells(void *arg)
+{
+ packed_cell_t *pc1=NULL, *pc2=NULL, *pc3=NULL, *pc4=NULL, *pc5=NULL;
+ origin_circuit_t *origin_c=NULL;
+ or_circuit_t *or_c=NULL;
+
+ (void)arg;
+
+ init_cell_pool();
+
+ pc1 = packed_cell_new();
+ pc2 = packed_cell_new();
+ pc3 = packed_cell_new();
+ pc4 = packed_cell_new();
+ pc5 = packed_cell_new();
+ tt_assert(pc1 && pc2 && pc3 && pc4 && pc5);
+
+ or_c = or_circuit_new(0, NULL);
+ origin_c = origin_circuit_new();
+ origin_c->base_.purpose = CIRCUIT_PURPOSE_C_GENERAL;
+
+ tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), ==, 0);
+ cell_queue_append(&or_c->p_chan_cells, pc1);
+ tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), ==, 1);
+ cell_queue_append(&or_c->base_.n_chan_cells, pc2);
+ cell_queue_append(&or_c->base_.n_chan_cells, pc3);
+ tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), ==, 3);
+
+ tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(origin_c)), ==, 0);
+ cell_queue_append(&origin_c->base_.n_chan_cells, pc4);
+ cell_queue_append(&origin_c->base_.n_chan_cells, pc5);
+ tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(origin_c)), ==, 2);
+
+ done:
+ circuit_free(TO_CIRCUIT(or_c));
+ circuit_free(TO_CIRCUIT(origin_c));
+
+ free_cell_pool();
+}
+
+struct testcase_t cell_queue_tests[] = {
+ { "basic", test_cq_manip, TT_FORK, NULL, NULL, },
+ { "circ_n_cells", test_circuit_n_cells, TT_FORK, NULL, NULL },
+ END_OF_TESTCASES
+};
+
diff --git a/src/test/test_circuitmux.c b/src/test/test_circuitmux.c
new file mode 100644
index 0000000000..0f592001cb
--- /dev/null
+++ b/src/test/test_circuitmux.c
@@ -0,0 +1,84 @@
+/* Copyright (c) 2013, The Tor Project, Inc. */
+/* See LICENSE for licensing information */
+
+#define TOR_CHANNEL_INTERNAL_
+#define CIRCUITMUX_PRIVATE
+#define RELAY_PRIVATE
+#include "or.h"
+#include "channel.h"
+#include "circuitmux.h"
+#include "relay.h"
+#include "test.h"
+
+/* XXXX duplicated function from test_circuitlist.c */
+static channel_t *
+new_fake_channel(void)
+{
+ channel_t *chan = tor_malloc_zero(sizeof(channel_t));
+ channel_init(chan);
+ return chan;
+}
+
+static int
+has_queued_writes(channel_t *c)
+{
+ (void) c;
+ return 1;
+}
+
+/** Test destroy cell queue with no interference from other queues. */
+static void
+test_cmux_destroy_cell_queue(void *arg)
+{
+ circuitmux_t *cmux = NULL;
+ channel_t *ch = NULL;
+ circuit_t *circ = NULL;
+ cell_queue_t *cq = NULL;
+ packed_cell_t *pc = NULL;
+
+ init_cell_pool();
+ (void) arg;
+
+ cmux = circuitmux_alloc();
+ tt_assert(cmux);
+ ch = new_fake_channel();
+ ch->has_queued_writes = has_queued_writes;
+ ch->wide_circ_ids = 1;
+
+ circ = circuitmux_get_first_active_circuit(cmux, &cq);
+ tt_assert(!circ);
+ tt_assert(!cq);
+
+ circuitmux_append_destroy_cell(ch, cmux, 100, 10);
+ circuitmux_append_destroy_cell(ch, cmux, 190, 6);
+ circuitmux_append_destroy_cell(ch, cmux, 30, 1);
+
+ tt_int_op(circuitmux_num_cells(cmux), ==, 3);
+
+ circ = circuitmux_get_first_active_circuit(cmux, &cq);
+ tt_assert(!circ);
+ tt_assert(cq);
+
+ tt_int_op(cq->n, ==, 3);
+
+ pc = cell_queue_pop(cq);
+ tt_assert(pc);
+ test_mem_op(pc->body, ==, "\x00\x00\x00\x64\x04\x0a\x00\x00\x00", 9);
+ packed_cell_free(pc);
+ pc = NULL;
+
+ tt_int_op(circuitmux_num_cells(cmux), ==, 2);
+
+ done:
+ circuitmux_free(cmux);
+ channel_free(ch);
+ packed_cell_free(pc);
+
+ free_cell_pool();
+}
+
+struct testcase_t circuitmux_tests[] = {
+ { "destroy_cell_queue", test_cmux_destroy_cell_queue, TT_FORK, NULL, NULL },
+ END_OF_TESTCASES
+};
+
diff --git a/src/test/test_config.c b/src/test/test_config.c
index 4e9e13e474..3848d352d5 100644
--- a/src/test/test_config.c
+++ b/src/test/test_config.c
@@ -438,12 +438,84 @@ test_config_parse_bridge_line(void *arg)
"aa=b");
}
+static void
+test_config_parse_transport_options_line(void *arg)
+{
+ smartlist_t *options_sl = NULL, *sl_tmp = NULL;
+
+ (void) arg;
+
+ { /* too small line */
+ options_sl = get_options_from_transport_options_line("valley", NULL);
+ test_assert(!options_sl);
+ }
+
+ { /* no k=v values */
+ options_sl = get_options_from_transport_options_line("hit it!", NULL);
+ test_assert(!options_sl);
+ }
+
+ { /* correct line, but wrong transport specified */
+ options_sl =
+ get_options_from_transport_options_line("trebuchet k=v", "rook");
+ test_assert(!options_sl);
+ }
+
+ { /* correct -- no transport specified */
+ sl_tmp = smartlist_new();
+ smartlist_add_asprintf(sl_tmp, "ladi=dadi");
+ smartlist_add_asprintf(sl_tmp, "weliketo=party");
+
+ options_sl =
+ get_options_from_transport_options_line("rook ladi=dadi weliketo=party",
+ NULL);
+ test_assert(options_sl);
+ test_assert(smartlist_strings_eq(options_sl, sl_tmp));
+
+ SMARTLIST_FOREACH(sl_tmp, char *, s, tor_free(s));
+ smartlist_free(sl_tmp);
+ sl_tmp = NULL;
+ SMARTLIST_FOREACH(options_sl, char *, s, tor_free(s));
+ smartlist_free(options_sl);
+ options_sl = NULL;
+ }
+
+ { /* correct -- correct transport specified */
+ sl_tmp = smartlist_new();
+ smartlist_add_asprintf(sl_tmp, "ladi=dadi");
+ smartlist_add_asprintf(sl_tmp, "weliketo=party");
+
+ options_sl =
+ get_options_from_transport_options_line("rook ladi=dadi weliketo=party",
+ "rook");
+ test_assert(options_sl);
+ test_assert(smartlist_strings_eq(options_sl, sl_tmp));
+ SMARTLIST_FOREACH(sl_tmp, char *, s, tor_free(s));
+ smartlist_free(sl_tmp);
+ sl_tmp = NULL;
+ SMARTLIST_FOREACH(options_sl, char *, s, tor_free(s));
+ smartlist_free(options_sl);
+ options_sl = NULL;
+ }
+
+ done:
+ if (options_sl) {
+ SMARTLIST_FOREACH(options_sl, char *, s, tor_free(s));
+ smartlist_free(options_sl);
+ }
+ if (sl_tmp) {
+ SMARTLIST_FOREACH(sl_tmp, char *, s, tor_free(s));
+ smartlist_free(sl_tmp);
+ }
+}
+
#define CONFIG_TEST(name, flags) \
{ #name, test_config_ ## name, flags, NULL, NULL }
struct testcase_t config_tests[] = {
CONFIG_TEST(addressmap, 0),
CONFIG_TEST(parse_bridge_line, 0),
+ CONFIG_TEST(parse_transport_options_line, 0),
CONFIG_TEST(check_or_create_data_subdir, TT_FORK),
CONFIG_TEST(write_to_data_subdir, TT_FORK),
END_OF_TESTCASES
diff --git a/src/test/test_options.c b/src/test/test_options.c
new file mode 100644
index 0000000000..6beff2567e
--- /dev/null
+++ b/src/test/test_options.c
@@ -0,0 +1,169 @@
+/* Copyright (c) 2001-2004, Roger Dingledine.
+ * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
+ * Copyright (c) 2007-2013, The Tor Project, Inc. */
+/* See LICENSE for licensing information */
+
+#define CONFIG_PRIVATE
+#include "or.h"
+#include "confparse.h"
+#include "config.h"
+#include "test.h"
+
+typedef struct {
+ int severity;
+ uint32_t domain;
+ char *msg;
+} logmsg_t;
+
+static smartlist_t *messages = NULL;
+
+static void
+log_cback(int severity, uint32_t domain, const char *msg)
+{
+ logmsg_t *x = tor_malloc(sizeof(*x));
+ x->severity = severity;
+ x->domain = domain;
+ x->msg = tor_strdup(msg);
+ if (!messages)
+ messages = smartlist_new();
+ smartlist_add(messages, x);
+}
+
+static void
+setup_log_callback(void)
+{
+ log_severity_list_t lst;
+ memset(&lst, 0, sizeof(lst));
+ lst.masks[LOG_ERR - LOG_ERR] = ~0;
+ lst.masks[LOG_WARN - LOG_ERR] = ~0;
+ lst.masks[LOG_NOTICE - LOG_ERR] = ~0;
+ add_callback_log(&lst, log_cback);
+}
+
+static char *
+dump_logs(void)
+{
+ smartlist_t *msgs;
+ char *out;
+ if (! messages)
+ return tor_strdup("");
+ msgs = smartlist_new();
+ SMARTLIST_FOREACH_BEGIN(messages, logmsg_t *, x) {
+ smartlist_add_asprintf(msgs, "[%s] %s",
+ log_level_to_string(x->severity), x->msg);
+ } SMARTLIST_FOREACH_END(x);
+ out = smartlist_join_strings(msgs, "", 0, NULL);
+ SMARTLIST_FOREACH(msgs, char *, cp, tor_free(cp));
+ smartlist_free(msgs);
+ return out;
+}
+
+static void
+clear_log_messages(void)
+{
+ if (!messages)
+ return;
+ SMARTLIST_FOREACH(messages, logmsg_t *, m,
+ { tor_free(m->msg); tor_free(m); });
+ smartlist_free(messages);
+ messages = NULL;
+}
+
+static void
+test_options_validate_impl(const char *configuration,
+ const char *expect_errmsg,
+ int expect_log_severity,
+ const char *expect_log)
+{
+ or_options_t *opt = options_new();
+ or_options_t *dflt;
+ config_line_t *cl=NULL;
+ char *msg=NULL;
+ int r;
+ opt->command = CMD_RUN_TOR;
+ options_init(opt);
+
+ dflt = config_dup(&options_format, opt);
+ clear_log_messages();
+
+ r = config_get_lines(configuration, &cl, 1);
+ tt_int_op(r, ==, 0);
+
+ r = config_assign(&options_format, opt, cl, 0, 0, &msg);
+ tt_int_op(r, ==, 0);
+
+ r = options_validate(NULL, opt, dflt, 0, &msg);
+ if (expect_errmsg && !msg) {
+ TT_DIE(("Expected error message <%s> from <%s>, but got none.",
+ expect_errmsg, configuration));
+ } else if (expect_errmsg && !strstr(msg, expect_errmsg)) {
+ TT_DIE(("Expected error message <%s> from <%s>, but got <%s>.",
+ expect_errmsg, configuration, msg));
+ } else if (!expect_errmsg && msg) {
+ TT_DIE(("Expected no error message from <%s> but got <%s>.",
+ configuration, msg));
+ }
+ tt_int_op((r == 0), ==, (msg == NULL));
+
+ if (expect_log) {
+ int found = 0;
+ if (messages) {
+ SMARTLIST_FOREACH_BEGIN(messages, logmsg_t *, m) {
+ if (m->severity == expect_log_severity &&
+ strstr(m->msg, expect_log)) {
+ found = 1;
+ break;
+ }
+ } SMARTLIST_FOREACH_END(m);
+ }
+ if (!found) {
+ tor_free(msg);
+ msg = dump_logs();
+ TT_DIE(("Expected log message [%s] %s from <%s>, but got <%s>.",
+ log_level_to_string(expect_log_severity), expect_log,
+ configuration, msg));
+ }
+ }
+
+ done:
+ config_free_lines(cl);
+ or_options_free(opt);
+ or_options_free(dflt);
+ tor_free(msg);
+ clear_log_messages();
+}
+
+#define WANT_ERR(config, msg) \
+ test_options_validate_impl((config), (msg), 0, NULL)
+#define WANT_LOG(config, severity, msg) \
+ test_options_validate_impl((config), NULL, (severity), (msg))
+#define WANT_ERR_LOG(config, msg, severity, logmsg) \
+ test_options_validate_impl((config), (msg), (severity), (logmsg))
+#define OK(config) \
+ test_options_validate_impl((config), NULL, 0, NULL)
+
+static void
+test_options_validate(void *arg)
+{
+ (void)arg;
+ setup_log_callback();
+
+ WANT_ERR_LOG("ServerTransportOptions trebuchet",
+ "ServerTransportOptions did not parse",
+ LOG_WARN, "Too few arguments");
+ OK("ServerTransportOptions trebuchet sling=snappy");
+ OK("ServerTransportOptions trebuchet sling=");
+ WANT_ERR_LOG("ServerTransportOptions trebuchet slingsnappy",
+ "ServerTransportOptions did not parse",
+ LOG_WARN, "\"slingsnappy\" is not a k=v");
+
+// done:
+ clear_log_messages();
+ return;
+}
+
+struct testcase_t options_tests[] = {
+ { "validate", test_options_validate, TT_FORK, NULL, NULL },
+ END_OF_TESTCASES
+};
+
diff --git a/src/test/test_pt.c b/src/test/test_pt.c
index afa4917da7..f969457d0e 100644
--- a/src/test/test_pt.c
+++ b/src/test/test_pt.c
@@ -7,6 +7,8 @@
#define PT_PRIVATE
#define UTIL_PRIVATE
#include "or.h"
+#include "config.h"
+#include "confparse.h"
#include "transports.h"
#include "circuitbuild.h"
#include "util.h"
@@ -94,6 +96,23 @@ test_pt_parsing(void)
reset_mp(mp);
+ /* Include some arguments. Good ones. */
+ strlcpy(line,"SMETHOD trebuchet 127.0.0.1:9999 "
+ "ARGS:counterweight=3,sling=snappy",
+ sizeof(line));
+ test_assert(parse_smethod_line(line, mp) == 0);
+ tt_int_op(1, ==, smartlist_len(mp->transports));
+ {
+ const transport_t *transport = smartlist_get(mp->transports, 0);
+ tt_assert(transport);
+ tt_str_op(transport->name, ==, "trebuchet");
+ tt_int_op(transport->port, ==, 9999);
+ tt_str_op(fmt_addr(&transport->addr), ==, "127.0.0.1");
+ tt_str_op(transport->extra_info_args, ==,
+ "counterweight=3,sling=snappy");
+ }
+ reset_mp(mp);
+
/* unsupported version */
strlcpy(line,"VERSION 666",sizeof(line));
test_assert(parse_version(line, mp) < 0);
@@ -111,6 +130,58 @@ test_pt_parsing(void)
}
static void
+test_pt_get_transport_options(void *arg)
+{
+ char **execve_args;
+ smartlist_t *transport_list = smartlist_new();
+ managed_proxy_t *mp;
+ or_options_t *options = get_options_mutable();
+ char *opt_str = NULL;
+ config_line_t *cl = NULL;
+ (void)arg;
+
+ execve_args = tor_malloc(sizeof(char*)*2);
+ execve_args[0] = tor_strdup("cheeseshop");
+ execve_args[1] = NULL;
+
+ mp = managed_proxy_create(transport_list, execve_args, 1);
+ tt_ptr_op(mp, !=, NULL);
+ opt_str = get_transport_options_for_server_proxy(mp);
+ tt_ptr_op(opt_str, ==, NULL);
+
+ smartlist_add(mp->transports_to_launch, tor_strdup("gruyere"));
+ smartlist_add(mp->transports_to_launch, tor_strdup("roquefort"));
+ smartlist_add(mp->transports_to_launch, tor_strdup("stnectaire"));
+
+ tt_assert(options);
+
+ cl = tor_malloc_zero(sizeof(config_line_t));
+ cl->value = tor_strdup("gruyere melty=10 hardness=se;ven");
+ options->ServerTransportOptions = cl;
+
+ cl = tor_malloc_zero(sizeof(config_line_t));
+ cl->value = tor_strdup("stnectaire melty=4 hardness=three");
+ cl->next = options->ServerTransportOptions;
+ options->ServerTransportOptions = cl;
+
+ cl = tor_malloc_zero(sizeof(config_line_t));
+ cl->value = tor_strdup("pepperjack melty=12 hardness=five");
+ cl->next = options->ServerTransportOptions;
+ options->ServerTransportOptions = cl;
+
+ opt_str = get_transport_options_for_server_proxy(mp);
+ tt_str_op(opt_str, ==,
+ "gruyere:melty=10;gruyere:hardness=se\\;ven;"
+ "stnectaire:melty=4;stnectaire:hardness=three");
+
+ done:
+ tor_free(opt_str);
+ config_free_lines(cl);
+ managed_proxy_destroy(mp, 0);
+ smartlist_free(transport_list);
+}
+
+static void
test_pt_protocol(void)
{
char line[200];
@@ -156,6 +227,51 @@ test_pt_protocol(void)
tor_free(mp);
}
+static void
+test_pt_get_extrainfo_string(void *arg)
+{
+ managed_proxy_t *mp1 = NULL, *mp2 = NULL;
+ char **argv1, **argv2;
+ smartlist_t *t1 = smartlist_new(), *t2 = smartlist_new();
+ int r;
+ char *s = NULL;
+ (void) arg;
+
+ argv1 = tor_malloc_zero(sizeof(char*)*3);
+ argv1[0] = tor_strdup("ewige");
+ argv1[1] = tor_strdup("Blumenkraft");
+ argv1[2] = NULL;
+ argv2 = tor_malloc_zero(sizeof(char*)*4);
+ argv2[0] = tor_strdup("und");
+ argv2[1] = tor_strdup("ewige");
+ argv2[2] = tor_strdup("Schlangenkraft");
+ argv2[3] = NULL;
+
+ mp1 = managed_proxy_create(t1, argv1, 1);
+ mp2 = managed_proxy_create(t2, argv2, 1);
+
+ r = parse_smethod_line("SMETHOD hagbard 127.0.0.1:5555", mp1);
+ tt_int_op(r, ==, 0);
+ r = parse_smethod_line("SMETHOD celine 127.0.0.1:1723 ARGS:card=no-enemy",
+ mp2);
+ tt_int_op(r, ==, 0);
+
+ /* Force these proxies to look "completed" or they won't generate output. */
+ mp1->conf_state = mp2->conf_state = PT_PROTO_COMPLETED;
+
+ s = pt_get_extra_info_descriptor_string();
+ tt_assert(s);
+ tt_str_op(s, ==,
+ "transport hagbard 127.0.0.1:5555\n"
+ "transport celine 127.0.0.1:1723 card=no-enemy\n");
+
+ done:
+ /* XXXX clean up better */
+ smartlist_free(t1);
+ smartlist_free(t2);
+ tor_free(s);
+}
+
#ifdef _WIN32
#define STDIN_HANDLE HANDLE
#else
@@ -246,6 +362,10 @@ test_pt_configure_proxy(void *arg)
struct testcase_t pt_tests[] = {
PT_LEGACY(parsing),
PT_LEGACY(protocol),
+ { "get_transport_options", test_pt_get_transport_options, TT_FORK,
+ NULL, NULL },
+ { "get_extrainfo_string", test_pt_get_extrainfo_string, TT_FORK,
+ NULL, NULL },
{ "configure_proxy",test_pt_configure_proxy, TT_FORK,
NULL, NULL },
END_OF_TESTCASES
diff --git a/src/test/test_util.c b/src/test/test_util.c
index 2cc25e9861..f7513c0f31 100644
--- a/src/test/test_util.c
+++ b/src/test/test_util.c
@@ -796,37 +796,37 @@ test_util_expand_filename(void)
}
#endif
-/** Test tor_escape_str_for_socks_arg(). */
+/** Test tor_escape_str_for_pt_args(). */
static void
test_util_escape_string_socks(void)
{
char *escaped_string = NULL;
/** Simple backslash escape. */
- escaped_string = tor_escape_str_for_socks_arg("This is a backslash: \\");
+ escaped_string = tor_escape_str_for_pt_args("This is a backslash: \\",";\\");
test_assert(escaped_string);
test_streq(escaped_string, "This is a backslash: \\\\");
tor_free(escaped_string);
/** Simple semicolon escape. */
- escaped_string = tor_escape_str_for_socks_arg("First rule: Do not use ;");
+ escaped_string = tor_escape_str_for_pt_args("First rule:Do not use ;",";\\");
test_assert(escaped_string);
- test_streq(escaped_string, "First rule: Do not use \\;");
+ test_streq(escaped_string, "First rule:Do not use \\;");
tor_free(escaped_string);
/** Empty string. */
- escaped_string = tor_escape_str_for_socks_arg("");
+ escaped_string = tor_escape_str_for_pt_args("", ";\\");
test_assert(escaped_string);
test_streq(escaped_string, "");
tor_free(escaped_string);
/** Escape all characters. */
- escaped_string = tor_escape_str_for_socks_arg(";\\;\\");
+ escaped_string = tor_escape_str_for_pt_args(";\\;\\", ";\\");
test_assert(escaped_string);
test_streq(escaped_string, "\\;\\\\\\;\\\\");
tor_free(escaped_string);
- escaped_string = tor_escape_str_for_socks_arg(";");
+ escaped_string = tor_escape_str_for_pt_args(";", ";\\");
test_assert(escaped_string);
test_streq(escaped_string, "\\;");
tor_free(escaped_string);
7apu2bq3rhoylwmucxizk54afw5jyda7pho4j5zdcqpwkufke7zdzwad.onion