commit d3ea7d5c0461d237ec3c1e437bc6609d0d0a1075
Author: George Kadianakis <desnacked(a)gmail.com>
Date: Sat Aug 20 06:35:30 2011 +0200
Introduce managed.[ch] to the world.
---
src/managed.c | 670 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/managed.h | 16 ++
2 files changed, 686 insertions(+), 0 deletions(-)
diff --git a/src/managed.c b/src/managed.c
new file mode 100644
index 0000000..979bc38
--- /dev/null
+++ b/src/managed.c
@@ -0,0 +1,670 @@
+/* Copyright 2011 Nick Mathewson, George Kadianakis
+ See LICENSE for other credits and copying information
+*/
+
+#include "util.h"
+
+#define MANAGED_PRIVATE
+#include "managed.h"
+#include "network.h"
+#include "protocol.h"
+#include "main.h"
+
+#include "container.h"
+
+#include <event2/event.h>
+#include <event2/listener.h>
+
+#include <arpa/inet.h> /* for inet_ntoa() */
+
+/** Holds all the parameters provided by tor through environment
+ variables. */
+typedef struct managed_env_vars_t {
+ char *state_loc; /* where we should store our state */
+ char *conf_proto_version; /* managed proxy configuration protocols tor supports */
+ char *transports; /* pluggable transports tor wants us to launch */
+
+ /* server-only */
+ char *extended_port; /* extended OR port tor wants us to use */
+ char *or_port; /* ORPort that tor uses */
+ char *bindaddrs; /* address to listen for client proxy connections */
+} managed_env_vars_t;
+
+/** Holds data for this managed proxy. */
+typedef struct managed_proxy_t {
+ unsigned int is_server : 1; /* whether we are a server or a client */
+
+ managed_env_vars_t vars; /* environment variables */
+
+ smartlist_t *configs; /* configs created */
+} managed_proxy_t;
+
+/* Holds the status of the environment variables parsing, so that we
+ can report a granular error if something fails. */
+enum env_parsing_status {
+ ST_ENV_SMOOTH,
+ ST_ENV_FAIL_STATE_LOC,
+ ST_ENV_FAIL_CONF_PROTO_VER,
+ ST_ENV_FAIL_CLIENT_TRANSPORTS,
+ ST_ENV_FAIL_EXTENDED_PORT,
+ ST_ENV_FAIL_ORPORT,
+ ST_ENV_FAIL_BINDADDR,
+ ST_ENV_FAIL_SERVER_TRANSPORTS,
+};
+
+/* Holds the status of a listener launch. */
+enum launch_status {
+ ST_LAUNCH_SMOOTH,
+ ST_LAUNCH_FAIL_SETUP,
+ ST_LAUNCH_FAIL_LSN,
+};
+
+/** Managed proxy protocol strings */
+#define PROTO_ENV_ERROR "ENV-ERROR"
+#define PROTO_NEG_SUCCESS "VERSION"
+#define PROTO_NEG_FAIL "VERSION-ERROR no-version\n"
+#define PROTO_CMETHOD "CMETHOD"
+#define PROTO_SMETHOD "SMETHOD"
+#define PROTO_CMETHOD_ERROR "CMETHOD-ERROR"
+#define PROTO_SMETHOD_ERROR "SMETHOD-ERROR"
+#define PROTO_CMETHODS_DONE "CMETHODS DONE\n"
+#define PROTO_SMETHODS_DONE "SMETHODS DONE\n"
+
+static int handle_environment(managed_proxy_t *proxy);
+static int conf_proto_version_negotiation(const managed_proxy_t *proxy);
+static int launch_listeners(const managed_proxy_t *proxy);
+static void print_method_line(const char *transport,
+ const managed_proxy_t *proxy,
+ config_t *cfg);
+static void print_method_error_line(const char *protocol,
+ const managed_proxy_t *proxy,
+ enum launch_status status);
+static const char *get_launch_error_message(enum launch_status status);
+
+static void print_method_done_line(const managed_proxy_t *proxy);
+
+static const char *get_env_parsing_error_message(enum env_parsing_status status);
+
+static void proxy_free(managed_proxy_t *proxy);
+static int is_supported_conf_protocol(const char *name);
+static void print_protocol_line(const char *format, ...);
+
+static int validate_environment(managed_proxy_t *proxy);
+
+const char *supported_conf_protocols[] = { "1" };
+const size_t n_supported_conf_protocols =
+ sizeof(supported_conf_protocols)/sizeof(supported_conf_protocols[0]);
+
+/**
+ This function fires up the managed proxy.
+ It first reads the environment that tor should have prepared, and then
+ launches the appropriate listeners.
+
+ Returns 0 if we managed to launch at least one proxy,
+ returns -1 if something went wrong or we didn't launch any proxies.
+*/
+int
+launch_managed_proxy(void)
+{
+ int r=-1;
+ managed_proxy_t *proxy = xzalloc(sizeof(managed_proxy_t));
+ proxy->configs = smartlist_create();
+
+ obfsproxy_init();
+
+ if (handle_environment(proxy) < 0)
+ goto done;
+
+ if (validate_environment(proxy) < 0)
+ goto done;
+
+ if (conf_proto_version_negotiation(proxy) < 0)
+ goto done;
+
+ if (launch_listeners(proxy) < 0)
+ goto done;
+
+ /* Kickstart libevent */
+ event_base_dispatch(get_event_base());
+
+ r=0;
+
+ done:
+ obfsproxy_cleanup();
+ proxy_free(proxy);
+
+ return r;
+}
+
+/**
+ Make sure that we got *all* the necessary environment variables off tor.
+*/
+static inline void
+assert_proxy_env(managed_proxy_t *proxy)
+{
+ obfs_assert(proxy);
+
+ obfs_assert(proxy->vars.state_loc);
+ obfs_assert(proxy->vars.conf_proto_version);
+ obfs_assert(proxy->vars.transports);
+ if (proxy->is_server) {
+ obfs_assert(proxy->vars.extended_port);
+ obfs_assert(proxy->vars.or_port);
+ obfs_assert(proxy->vars.bindaddrs);
+ } else {
+ obfs_assert(!proxy->vars.extended_port);
+ obfs_assert(!proxy->vars.or_port);
+ obfs_assert(!proxy->vars.bindaddrs);
+ }
+}
+
+/**
+ Validates the environment variables that we got off tor.
+*/
+static int
+validate_environment(managed_proxy_t *proxy)
+{
+ enum env_parsing_status status;
+
+ assert_proxy_env(proxy);
+
+ if (proxy->is_server) {
+ if (validate_bindaddrs(proxy->vars.bindaddrs, proxy->vars.transports) < 0) {
+ status = ST_ENV_FAIL_BINDADDR;
+ goto err;
+ }
+ }
+
+ return 0;
+
+ err:
+ print_protocol_line("%s %s\n", PROTO_ENV_ERROR,
+ get_env_parsing_error_message(status));
+
+ return -1;
+}
+
+/**
+ Free memory allocated by 'proxy'.
+*/
+static void
+proxy_free(managed_proxy_t *proxy)
+{
+ free(proxy->vars.state_loc);
+ free(proxy->vars.conf_proto_version);
+ free(proxy->vars.transports);
+ free(proxy->vars.extended_port);
+ free(proxy->vars.or_port);
+ free(proxy->vars.bindaddrs);
+
+ SMARTLIST_FOREACH(proxy->configs, config_t *, cfg, config_free(cfg));
+ smartlist_free(proxy->configs);
+
+ free(proxy);
+}
+
+/**
+ Given a smartlist of listener configs; launch them all and print
+ method lines as appropriate. Return 0 if at least a listener was
+ spawned, -1 otherwise.
+*/
+static int
+open_listeners_managed(const managed_proxy_t *proxy)
+{
+ int ret=-1;
+ const char *transport;
+
+ /* Open listeners for each configuration. */
+ SMARTLIST_FOREACH_BEGIN(proxy->configs, config_t *, cfg) {
+ transport = get_transport_name_from_config(cfg);
+
+ if (open_listeners(get_event_base(), cfg)) {
+ ret=0; /* success! launched at least one listener. */
+ print_method_line(transport, proxy, cfg);
+ } else { /* fail. print a method error line. */
+ print_method_error_line(transport, proxy, ST_LAUNCH_FAIL_LSN);
+ }
+ } SMARTLIST_FOREACH_END(cfg);
+
+ return ret;
+}
+
+/**
+ Launch all server listeners that tor wants us to launch.
+*/
+static int
+launch_server_listeners(const managed_proxy_t *proxy)
+{
+ int ret=-1;
+ int i, n_transports;
+ const char *transport = NULL;
+ const char *bindaddr_temp = NULL;
+ const char *bindaddr = NULL;
+ config_t *cfg = NULL;
+
+ /* list of transports */
+ smartlist_t *transports = smartlist_create();
+ /* a list of "<transport>-<bindaddr>" strings */
+ smartlist_t *bindaddrs = smartlist_create();
+
+ /* split the comma-separated transports/bindaddrs to their smartlists */
+ smartlist_split_string(transports, proxy->vars.transports, ",",
+ SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
+ smartlist_split_string(bindaddrs, proxy->vars.bindaddrs, ",",
+ SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
+
+ n_transports = smartlist_len(transports);
+
+ /* Iterate transports; match them with their bindaddr; create their
+ config_t. */
+ for (i=0;i<n_transports;i++) {
+ transport = smartlist_get(transports, i);
+ bindaddr_temp = smartlist_get(bindaddrs, i);
+
+ obfs_assert(strlen(bindaddr_temp) > strlen(transport)+1);
+
+ bindaddr = bindaddr_temp+strlen(transport)+1; /* +1 for the dash */
+
+ cfg = config_create_managed(proxy->is_server,
+ transport, bindaddr, proxy->vars.or_port);
+ if (cfg) /* if a config was created; put it in the config smartlist */
+ smartlist_add(proxy->configs, cfg);
+ else /* otherwise, spit a method error line */
+ print_method_error_line(transport, proxy, ST_LAUNCH_FAIL_SETUP);
+ }
+
+ /* open listeners */
+ ret = open_listeners_managed(proxy);
+
+ SMARTLIST_FOREACH(bindaddrs, char *, cp, free(cp));
+ smartlist_free(bindaddrs);
+ SMARTLIST_FOREACH(transports, char *, cp, free(cp));
+ smartlist_free(transports);
+
+ print_method_done_line(proxy); /* print {C,S}METHODS DONE */
+
+ return ret;
+}
+
+/**
+ Launch all client listeners that tor wants us to launch.
+*/
+static int
+launch_client_listeners(const managed_proxy_t *proxy)
+{
+ int ret=-1;
+ config_t *cfg = NULL;
+
+ /* list of transports */
+ smartlist_t *transports = smartlist_create();
+
+ smartlist_split_string(transports, proxy->vars.transports, ",",
+ SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
+
+ SMARTLIST_FOREACH_BEGIN(transports, char *, transport) {
+ /* clients should find their own listen port */
+ cfg = config_create_managed(proxy->is_server,
+ transport, "127.0.0.1:0", proxy->vars.or_port);
+ if (cfg) /* if config was created; put it in the config smartlist */
+ smartlist_add(proxy->configs, cfg);
+ else
+ print_method_error_line(transport, proxy, ST_LAUNCH_FAIL_SETUP);
+ } SMARTLIST_FOREACH_END(transport);
+
+ /* open listeners */
+ ret = open_listeners_managed(proxy);
+
+ SMARTLIST_FOREACH(transports, char *, cp, free(cp));
+ smartlist_free(transports);
+
+ print_method_done_line(proxy); /* print {C,S}METHODS DONE */
+
+ return ret;
+}
+
+/**
+ Launch all listeners that tor wants us to launch.
+ Return 0 if at least a listener was launched, -1 otherwise.
+*/
+static inline int
+launch_listeners(const managed_proxy_t *proxy)
+{
+ if (proxy->is_server)
+ return launch_server_listeners(proxy);
+ else
+ return launch_client_listeners(proxy);
+}
+
+/**
+ Given:
+ * comma-separated list of "<transport>-<bindaddr>" strings in 'all_bindaddrs'.
+ * comma-separated list of "<transport>" strings in 'all_transports'.
+
+ Return:
+ * 0, if
+ - all <transport> strings in 'all_bindaddrs' match with <transport>
+ strings in 'all_transports' (order matters).
+ AND
+ - if all <bindaddr> strings in 'all_bindaddrs' are valid addrports.
+ * -1, otherwise.
+*/
+int
+validate_bindaddrs(const char *all_bindaddrs, const char *all_transports)
+{
+ int ret,i,n_bindaddrs,n_transports;
+ struct evutil_addrinfo *bindaddr_test;
+ char *bindaddr = NULL;
+ char *transport = NULL;
+
+ /* a list of "<proto>-<bindaddr>" strings */
+ smartlist_t *bindaddrs = smartlist_create();
+ /* a list holding (<proto>, <bindaddr>) for each 'bindaddrs' entry */
+ smartlist_t *split_bindaddr = NULL;
+ /* a list of "<proto>" strings */
+ smartlist_t *transports = smartlist_create();
+
+ smartlist_split_string(bindaddrs, all_bindaddrs, ",",
+ SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
+ smartlist_split_string(transports, all_transports, ",",
+ SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
+
+ n_bindaddrs = smartlist_len(bindaddrs);
+ n_transports = smartlist_len(transports);
+
+ if (n_bindaddrs != n_transports)
+ goto err;
+
+ for (i=0;i<n_bindaddrs;i++) {
+ bindaddr = smartlist_get(bindaddrs, i);
+ transport = smartlist_get(transports, i);
+
+ split_bindaddr = smartlist_create();
+ smartlist_split_string(split_bindaddr, bindaddr, "-",
+ SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
+
+ /* (<proto>, <bindaddr>) */
+ if (smartlist_len(split_bindaddr) != 2)
+ goto err;
+
+ /* "all <transport> strings in 'all_bindaddrs' match with <transport>
+ strings in 'all_transports' (order matters)." */
+ if (strcmp(smartlist_get(split_bindaddr,0), transport))
+ goto err;
+
+ /* "if all <bindaddr> strings in 'all_bindaddrs' are valid addrports." */
+ bindaddr_test = resolve_address_port(smartlist_get(split_bindaddr, 1),
+ 1, 1, NULL);
+ if (!bindaddr_test)
+ goto err;
+
+ evutil_freeaddrinfo(bindaddr_test);
+ SMARTLIST_FOREACH(split_bindaddr, char *, cp, free(cp));
+ smartlist_free(split_bindaddr);
+ split_bindaddr = NULL;
+ }
+
+ ret = 0;
+ goto done;
+
+ err:
+ ret = -1;
+
+ done:
+ SMARTLIST_FOREACH(bindaddrs, char *, cp, free(cp));
+ smartlist_free(bindaddrs);
+ SMARTLIST_FOREACH(transports, char *, cp, free(cp));
+ smartlist_free(transports);
+ if (split_bindaddr) {
+ SMARTLIST_FOREACH(split_bindaddr, char *, cp, free(cp));
+ smartlist_free(split_bindaddr);
+ }
+
+ return ret;
+}
+
+/**
+ Read the environment variables defined in the
+ 180-pluggable-transport.txt spec and fill 'proxy' accordingly.
+
+ Return 0 if all necessary environment variables were set properly.
+ Return -1 otherwise.
+*/
+static int
+handle_environment(managed_proxy_t *proxy)
+{
+ char *tmp;
+ enum env_parsing_status status=ST_ENV_SMOOTH;
+
+ tmp = getenv("TOR_PT_STATE_LOCATION");
+ if (!tmp) {
+ status = ST_ENV_FAIL_STATE_LOC;
+ goto err;
+ }
+ proxy->vars.state_loc = xstrdup(tmp);
+
+ tmp = getenv("TOR_PT_MANAGED_TRANSPORT_VER");
+ if (!tmp) {
+ status = ST_ENV_FAIL_CONF_PROTO_VER;
+ goto err;
+ }
+ proxy->vars.conf_proto_version = xstrdup(tmp);
+
+ tmp = getenv("TOR_PT_CLIENT_TRANSPORTS");
+ if (tmp) {
+ proxy->vars.transports = xstrdup(tmp);
+ proxy->is_server = 0;
+ } else {
+ proxy->is_server = 1;
+ }
+
+ if (proxy->is_server) {
+ tmp = getenv("TOR_PT_EXTENDED_SERVER_PORT");
+ if (!tmp) {
+ status = ST_ENV_FAIL_EXTENDED_PORT;
+ goto err;
+ }
+ proxy->vars.extended_port = xstrdup(tmp);
+
+ tmp = getenv("TOR_PT_ORPORT");
+ if (!tmp) {
+ status = ST_ENV_FAIL_ORPORT;
+ goto err;
+ }
+ proxy->vars.or_port = xstrdup(tmp);
+
+ tmp = getenv("TOR_PT_SERVER_BINDADDR");
+ if (tmp) {
+ proxy->vars.bindaddrs = xstrdup(tmp);
+ } else {
+ status = ST_ENV_FAIL_BINDADDR;
+ goto err;
+ }
+
+ tmp = getenv("TOR_PT_SERVER_TRANSPORTS");
+ if (!tmp) {
+ status = ST_ENV_FAIL_SERVER_TRANSPORTS;
+ goto err;
+ }
+ proxy->vars.transports = xstrdup(tmp);
+ }
+
+ return 0;
+
+ err:
+ print_protocol_line("%s %s\n", PROTO_ENV_ERROR,
+ get_env_parsing_error_message(status));
+
+ return -1;
+}
+
+/**
+ Given the name of a protocol we tried to launch in 'protocol'
+ the managed proxy parameters in 'proxy' and a listener launch
+ status in 'status', print a line of the form:
+ CMETHOD-ERROR <methodname> "<errormessage>"
+ to signify a listener launching failure.
+*/
+static inline void
+print_method_error_line(const char *protocol,
+ const managed_proxy_t *proxy,
+ enum launch_status status)
+{
+ print_protocol_line("%s %s %s\n",
+ proxy->is_server ?
+ PROTO_SMETHOD_ERROR : PROTO_CMETHOD_ERROR,
+ protocol,
+ get_launch_error_message(status));
+}
+
+/**
+ Print a CMETHOD/SMETHOD line saying that we launched 'transport'
+ with 'cfg' under 'proxy'.
+*/
+static void
+print_method_line(const char *transport, const managed_proxy_t *proxy,
+ config_t *cfg)
+{
+ struct evconnlistener *listener = get_evconnlistener_by_config(cfg);
+ obfs_assert(listener);
+
+ struct sockaddr_in saddr;
+ memset(&saddr,0,sizeof(struct sockaddr_in));
+ socklen_t slen = sizeof(saddr);
+
+ obfs_assert(!(getsockname(evconnlistener_get_fd(listener),
+ (struct sockaddr *)&saddr, &slen) < 0));
+
+ if (proxy->is_server) {
+ print_protocol_line("%s %s %s:%hu\n",
+ PROTO_SMETHOD,
+ transport,
+ inet_ntoa(saddr.sin_addr),
+ ntohs(saddr.sin_port));
+ } else {
+ print_protocol_line("%s %s %s %s:%hu\n",
+ PROTO_CMETHOD,
+ transport,
+ "socks5",
+ inet_ntoa(saddr.sin_addr),
+ ntohs(saddr.sin_port));
+
+ }
+}
+
+/**
+ Print the '{S,C}METHOD DONE' message.
+*/
+static inline void
+print_method_done_line(const managed_proxy_t *proxy)
+{
+ print_protocol_line("%s", proxy->is_server ?
+ PROTO_SMETHODS_DONE : PROTO_CMETHODS_DONE);
+}
+
+/**
+ Return true if 'name' matches the name of a supported managed proxy
+ configuration protocol.
+*/
+static inline int
+is_supported_conf_protocol(const char *name) {
+ int f;
+ for (f=0;f<n_supported_conf_protocols;f++) {
+ if (!strcmp(name,supported_conf_protocols[f]))
+ return 1;
+ }
+ return 0;
+}
+
+/**
+ Finish the configuration protocol version negotiation by printing
+ whether we support any of the suggested configuration protocols in
+ stdout, according to the 180 spec.
+
+ Return:
+ * 0: if we actually found and selected a protocol.
+ * -1: if we couldn't find a common supported protocol or if we
+ couldn't even parse tor's supported protocol list.
+
+ XXX: in the future we should return the protocol version we
+ selected. let's keep it simple for now since we have just one
+ protocol version.
+*/
+static int
+conf_proto_version_negotiation(const managed_proxy_t *proxy)
+{
+ int r=-1;
+
+ smartlist_t *versions = smartlist_create();
+ smartlist_split_string(versions, proxy->vars.conf_proto_version, ",",
+ SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
+
+ SMARTLIST_FOREACH_BEGIN(versions, char *, version) {
+ if (is_supported_conf_protocol(version)) {
+ print_protocol_line("%s %s\n", PROTO_NEG_SUCCESS, version);
+ r=0;
+ goto done;
+ }
+ } SMARTLIST_FOREACH_END(version);
+
+ /* we get here if we couldn't find a supported protocol */
+ print_protocol_line("%s", PROTO_NEG_FAIL);
+
+ done:
+ SMARTLIST_FOREACH(versions, char *, cp, free(cp));
+ smartlist_free(versions);
+
+ return r;
+}
+
+/**
+ Return a string containing the error we encountered while parsing
+ the environment variables, according to 'status'.
+*/
+static inline const char *
+get_env_parsing_error_message(enum env_parsing_status status)
+{
+ switch(status) {
+ case ST_ENV_SMOOTH: return "no error";
+ case ST_ENV_FAIL_STATE_LOC: return "failed on TOR_PT_STATE_LOCATION";
+ case ST_ENV_FAIL_CONF_PROTO_VER: return "failed on TOR_PT_MANAGED_TRANSPORT_VER";
+ case ST_ENV_FAIL_CLIENT_TRANSPORTS: return "failed on TOR_PT_CLIENT_TRANSPORTS";
+ case ST_ENV_FAIL_EXTENDED_PORT: return "failed on TOR_PT_EXTENDED_SERVER_PORT";
+ case ST_ENV_FAIL_ORPORT: return "failed on TOR_PT_ORPORT";
+ case ST_ENV_FAIL_BINDADDR: return "failed on TOR_PT_SERVER_BINDADDR";
+ case ST_ENV_FAIL_SERVER_TRANSPORTS: return "failed on TOR_PT_SERVER_TRANSPORTS";
+ default:
+ obfs_assert(0); return "UNKNOWN";
+ }
+}
+
+/**
+ Return a string containing the error we encountered while
+ launching a listener, according to 'status'.
+*/
+static inline const char *
+get_launch_error_message(enum launch_status status)
+{
+ switch (status) {
+ case ST_LAUNCH_SMOOTH: return "no error";
+ case ST_LAUNCH_FAIL_SETUP: return "could not setup protocol";
+ case ST_LAUNCH_FAIL_LSN: return "could not launch listener";
+ default:
+ obfs_assert(0); return "UNKNOWN";
+ }
+}
+
+/**
+ This function is used for obfsproxy to communicate with tor.
+ Practically a wrapper of printf, it prints 'format' and the
+ fflushes stdout so that the output is always immediately available
+ to tor.
+*/
+static void
+print_protocol_line(const char *format, ...)
+{
+ va_list ap;
+ va_start(ap,format);
+ vprintf(format, ap);
+ fflush(stdout);
+ va_end(ap);
+}
diff --git a/src/managed.h b/src/managed.h
new file mode 100644
index 0000000..2b14c2b
--- /dev/null
+++ b/src/managed.h
@@ -0,0 +1,16 @@
+/* Copyright 2011 Nick Mathewson, George Kadianakis
+ See LICENSE for other credits and copying information
+*/
+
+#ifndef MANAGED_H
+#define MANAGED_H
+
+int launch_managed_proxy();
+
+#ifdef MANAGED_PRIVATE
+
+int validate_bindaddrs(const char *all_bindaddrs, const char *all_transports);
+
+#endif /* MANAGED_PRIVATE */
+
+#endif
