120#define parse_server_method_error(l) parse_method_error(l, 1)
121#define parse_client_method_error(l) parse_method_error(l, 0)
124#define PROTO_ENV_ERROR "ENV-ERROR"
125#define PROTO_NEG_SUCCESS "VERSION"
126#define PROTO_NEG_FAIL "VERSION-ERROR no-version"
127#define PROTO_CMETHOD "CMETHOD"
128#define PROTO_SMETHOD "SMETHOD"
129#define PROTO_CMETHOD_ERROR "CMETHOD-ERROR"
130#define PROTO_SMETHOD_ERROR "SMETHOD-ERROR"
131#define PROTO_CMETHODS_DONE "CMETHODS DONE"
132#define PROTO_SMETHODS_DONE "SMETHODS DONE"
133#define PROTO_PROXY_DONE "PROXY DONE"
134#define PROTO_PROXY_ERROR "PROXY-ERROR"
135#define PROTO_LOG "LOG"
136#define PROTO_STATUS "STATUS"
140#define PROTO_VERSION_ONE 1
150 const char *
name,
int socks_ver,
151 const char *extra_info_args)
196 if (t->marked_for_removal) {
200 } SMARTLIST_FOREACH_END(t);
222 new_transport = tor_malloc_zero(
sizeof(
transport_t));
225 new_transport->
name = tor_strdup(transport->
name);
227 new_transport->
port = transport->
port;
230 return new_transport;
244 if (!strcmp(transport->name,
name))
246 } SMARTLIST_FOREACH_END(transport);
284 char *new_transport_addrport =
287 log_notice(
LD_GENERAL,
"You tried to add transport '%s' at '%s' "
288 "but there was already a transport marked for deletion at "
289 "'%s'. We deleted the old transport and registered the "
290 "new one.", t->
name, new_transport_addrport,
293 transport_free(t_tmp);
296 log_notice(
LD_GENERAL,
"You tried to add transport '%s' at '%s' "
297 "but the same transport already exists at '%s'. "
298 "Skipping.", t->
name, new_transport_addrport,
339 const char *
name,
int socks_ver))
348 log_notice(
LD_GENERAL,
"Could not add transport %s at %s. Skipping.",
353 log_info(
LD_GENERAL,
"Successfully registered transport %s at %s.",
358 log_info(
LD_GENERAL,
"Successfully registered transport %s at %s.",
384 if (!strcasecmp(
name, transport_name)) {
387 } SMARTLIST_FOREACH_END(
name);
388 } SMARTLIST_FOREACH_END(mp);
413 if (mp->conf_state == PT_PROTO_COMPLETED)
425 char **tmp1=proxy_argv;
426 char **tmp2=mp->argv;
431 while (*tmp1 && *tmp2) {
432 if (strcmp(*tmp1++, *tmp2++))
436 if (!*tmp1 && !*tmp2)
444static managed_proxy_t *
452 mp->is_server == is_server)
454 } SMARTLIST_FOREACH_END(mp);
482 if (
strcmp_opt(proxy_uri, mp->proxy_uri) != 0)
493 tor_assert(smartlist_len(mp->transports_to_launch) > 0);
494 tor_assert(mp->conf_state == PT_PROTO_COMPLETED);
496 if (smartlist_len(mp->transports_to_launch) != smartlist_len(mp->transports))
503 } SMARTLIST_FOREACH_END(t);
519 tor_assert(mp->conf_state == PT_PROTO_COMPLETED);
533 } SMARTLIST_FOREACH_END(t);
543 mp->proxy_supported = 0;
573 for (
int i = 1; mp->argv[i] != NULL; ++i)
577 log_warn(
LD_CONFIG,
"Managed proxy at '%s' failed at launch.",
583 "Managed proxy at '%s' has spawned with PID '%" PRIu64
"'.",
595 int at_least_a_proxy_config_finished = 0;
598 log_debug(
LD_CONFIG,
"Configuring remaining managed proxies (%d)!",
608 tor_assert(mp->conf_state != PT_PROTO_BROKEN &&
609 mp->conf_state != PT_PROTO_FAILED_LAUNCH);
611 if (mp->was_around_before_config_read) {
615 mp->was_around_before_config_read = 0;
618 log_info(
LD_GENERAL,
"Preparing managed proxy '%s' for restart.",
622 log_info(
LD_GENERAL,
"Nothing changed for managed proxy '%s' after "
623 "HUP: not restarting.", mp->argv[0]);
633 at_least_a_proxy_config_finished = 1;
635 } SMARTLIST_FOREACH_END(mp);
641 if (at_least_a_proxy_config_finished)
653 if (mp->conf_state == PT_PROTO_INFANT) {
661 tor_assert(mp->conf_state != PT_PROTO_INFANT);
663 return mp->conf_state == PT_PROTO_COMPLETED;
670 tor_assert(mp->conf_state != PT_PROTO_COMPLETED);
674 log_notice(
LD_GENERAL,
"Registered server transport '%s' at '%s'",
677 } SMARTLIST_FOREACH_END(t);
687 tor_assert(mp->conf_state != PT_PROTO_COMPLETED);
694 log_notice(
LD_GENERAL,
"Could not add transport %s. Skipping.", t->name);
695 transport_free(transport_tmp);
698 log_info(
LD_GENERAL,
"Successfully registered transport %s", t->name);
702 log_info(
LD_GENERAL,
"Successfully registered transport %s", t->name);
704 transport_free(transport_tmp);
707 } SMARTLIST_FOREACH_END(t);
723 int also_terminate_process)
728 smartlist_free(mp->transports);
732 smartlist_free(mp->transports_to_launch);
745 if (also_terminate_process && mp->process) {
802 switch (mp->conf_state) {
803 case PT_PROTO_BROKEN:
806 case PT_PROTO_FAILED_LAUNCH:
809 case PT_PROTO_CONFIGURED:
810 if (mp->proxy_uri && !mp->proxy_supported) {
811 log_warn(
LD_CONFIG,
"Managed proxy '%s' did not configure the "
812 "specified outgoing proxy and will be terminated.",
824 case PT_PROTO_INFANT:
825 case PT_PROTO_LAUNCHED:
826 case PT_PROTO_ACCEPTING_METHODS:
827 case PT_PROTO_COMPLETED:
829 log_warn(
LD_CONFIG,
"Unexpected state '%d' of managed proxy '%s'.",
830 (
int)mp->conf_state, mp->argv[0]);
842 return (mp->conf_state == PT_PROTO_CONFIGURED ||
843 mp->conf_state == PT_PROTO_BROKEN ||
844 mp->conf_state == PT_PROTO_FAILED_LAUNCH);
853 if (smartlist_len(mp->transports) == 0)
854 log_warn(
LD_GENERAL,
"Managed proxy '%s' was spawned successfully, "
855 "but it didn't launch any pluggable transport listeners!",
858 log_info(
LD_CONFIG,
"%s managed proxy '%s' configuration completed!",
859 mp->is_server ?
"Server" :
"Client",
868 log_info(
LD_PT,
"Got a line from managed proxy '%s': (%s)",
872 if (mp->conf_state != PT_PROTO_LAUNCHED)
878 if (mp->conf_state != PT_PROTO_LAUNCHED)
881 log_warn(
LD_CONFIG,
"Managed proxy could not pick a "
882 "configuration protocol version.");
884 }
else if (!
strcmpstart(line, PROTO_NEG_SUCCESS)) {
885 if (mp->conf_state != PT_PROTO_LAUNCHED)
894 }
else if (!
strcmpstart(line, PROTO_CMETHODS_DONE)) {
895 if (mp->conf_state != PT_PROTO_ACCEPTING_METHODS)
902 }
else if (!
strcmpstart(line, PROTO_SMETHODS_DONE)) {
903 if (mp->conf_state != PT_PROTO_ACCEPTING_METHODS)
910 }
else if (!
strcmpstart(line, PROTO_CMETHOD_ERROR)) {
911 if (mp->conf_state != PT_PROTO_ACCEPTING_METHODS)
921 parse_client_method_error(line);
923 }
else if (!
strcmpstart(line, PROTO_SMETHOD_ERROR)) {
924 if (mp->conf_state != PT_PROTO_ACCEPTING_METHODS)
928 parse_server_method_error(line);
931 if (mp->conf_state != PT_PROTO_ACCEPTING_METHODS)
939 if (mp->conf_state != PT_PROTO_ACCEPTING_METHODS)
947 if (mp->conf_state != PT_PROTO_ACCEPTING_METHODS)
951 mp->proxy_supported = 1;
956 }
else if (!
strcmpstart(line, PROTO_PROXY_ERROR)) {
957 if (mp->conf_state != PT_PROTO_ACCEPTING_METHODS)
975 log_notice(
LD_GENERAL,
"Unknown line received by managed proxy (%s).", line);
980 log_warn(
LD_CONFIG,
"Managed proxy at '%s' failed the configuration protocol"
981 " and will be destroyed.", mp->argv[0]);
991 log_notice(
LD_CONFIG,
"Managed proxy sent us an %s without an error "
994 log_warn(
LD_CONFIG,
"Managed proxy couldn't understand the "
995 "pluggable transport environment variables. (%s)",
1004 if (strlen(line) < (strlen(PROTO_NEG_SUCCESS) + 2)) {
1005 log_warn(
LD_CONFIG,
"Managed proxy sent us malformed %s line.",
1010 if (strcmp(
"1", line+strlen(PROTO_NEG_SUCCESS)+1)) {
1011 log_warn(
LD_CONFIG,
"Managed proxy tried to negotiate on version '%s'. "
1012 "We only support version '1'", line+strlen(PROTO_NEG_SUCCESS)+1);
1026 const char* error = is_server ?
1027 PROTO_SMETHOD_ERROR : PROTO_CMETHOD_ERROR;
1031 if (strlen(line) < (strlen(error) + 2))
1032 log_warn(
LD_CONFIG,
"Managed proxy sent us an %s without an error "
1035 log_warn(
LD_CONFIG,
"%s managed proxy encountered a method error. (%s)",
1036 is_server ?
"Server" :
"Client",
1037 line+strlen(error)+1);
1046 managed_proxy_t *mp,
1052 char *transport_name=NULL;
1053 char *args_string=NULL;
1054 char *addrport=NULL;
1055 int socks_ver=PROXY_NONE;
1059 const char *method_str = is_smethod ? PROTO_SMETHOD : PROTO_CMETHOD;
1060 const int min_args_count = is_smethod ? 3 : 4;
1067 SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
1068 if (smartlist_len(items) < min_args_count) {
1069 log_warn(
LD_CONFIG,
"Managed proxy sent us a %s line "
1070 "with too few arguments.", method_str);
1074 tor_assert(!strcmp(smartlist_get(items, item_index),method_str));
1077 transport_name = smartlist_get(items,item_index);
1080 log_warn(
LD_CONFIG,
"Transport name is not a C identifier (%s).",
1087 const char *socks_ver_str = smartlist_get(items,item_index);
1090 if (!strcmp(socks_ver_str,
"socks4")) {
1091 socks_ver = PROXY_SOCKS4;
1092 }
else if (!strcmp(socks_ver_str,
"socks5")) {
1093 socks_ver = PROXY_SOCKS5;
1095 log_warn(
LD_CONFIG,
"Client managed proxy sent us a proxy protocol "
1096 "we don't recognize. (%s)", socks_ver_str);
1101 addrport = smartlist_get(items, item_index);
1104 log_warn(
LD_CONFIG,
"Error parsing transport address '%s'", addrport);
1110 "Transport address '%s' has no port.", addrport);
1115 log_warn(
LD_CONFIG,
"Error parsing transport address '%s'", address);
1120 if (is_smethod && smartlist_len(items) > min_args_count) {
1123 char *options_string = smartlist_get(items, item_index);
1124 log_debug(
LD_CONFIG,
"Got options_string: %s", options_string);
1126 args_string = options_string+strlen(
"ARGS:");
1127 log_debug(
LD_CONFIG,
"Got ARGS: %s", args_string);
1132 socks_ver, args_string);
1138 log_info(
LD_CONFIG,
"Server transport %s at %s:%d.",
1139 transport_name, address, (
int)port);
1141 log_info(
LD_CONFIG,
"Transport %s at %s:%d with SOCKS %d. "
1142 "Attached to managed proxy.",
1143 transport_name, address, (
int)port, socks_ver);
1154 smartlist_free(items);
1185 if (strlen(line) < (strlen(PROTO_PROXY_ERROR) + 2))
1186 log_notice(
LD_CONFIG,
"Managed proxy sent us an %s without an error "
1187 "message.", PROTO_PROXY_ERROR);
1189 log_warn(
LD_CONFIG,
"Managed proxy failed to configure the "
1190 "pluggable transport's outgoing proxy. (%s)",
1191 line+strlen(PROTO_PROXY_ERROR)+1);
1202 char *log_message = NULL;
1204 if (strlen(line) < (strlen(PROTO_LOG) + 1)) {
1205 log_warn(
LD_PT,
"Managed proxy sent us a %s line "
1206 "with missing argument.", PROTO_LOG);
1210 const char *data = line + strlen(PROTO_LOG) + 1;
1214 log_warn(
LD_PT,
"Managed proxy \"%s\" wrote an invalid LOG message: %s",
1224 log_warn(
LD_PT,
"Managed proxy \"%s\" wrote a LOG line without "
1225 "MESSAGE: %s", mp->argv[0],
escaped(data));
1231 log_warn(
LD_PT,
"Managed proxy \"%s\" wrote a LOG line without "
1232 "SEVERITY: %s", mp->argv[0],
escaped(data));
1238 if (log_severity == -1) {
1239 log_warn(
LD_PT,
"Managed proxy \"%s\" wrote a LOG line with an "
1240 "invalid severity level: %s",
1241 mp->argv[0], severity->value);
1245 tor_log(log_severity,
LD_PT,
"Managed proxy \"%s\": %s",
1246 mp->argv[0], message->value);
1256 config_free_lines(values);
1268 char *status_message = NULL;
1270 if (strlen(line) < (strlen(PROTO_STATUS) + 1)) {
1271 log_warn(
LD_PT,
"Managed proxy sent us a %s line "
1272 "with missing argument.", PROTO_STATUS);
1276 const char *data = line + strlen(PROTO_STATUS) + 1;
1281 log_warn(
LD_PT,
"Managed proxy \"%s\" wrote an invalid "
1282 "STATUS message: %s", mp->argv[0],
escaped(data));
1291 log_warn(
LD_PT,
"Managed proxy \"%s\" wrote a STATUS line without "
1292 "TRANSPORT: %s", mp->argv[0],
escaped(data));
1305 config_free_lines(values);
1315 char *options_string = NULL;
1327 if (!options_tmp_sl)
1335 transport, escaped_opts);
1337 } SMARTLIST_FOREACH_END(options);
1340 smartlist_free(options_tmp_sl);
1341 } SMARTLIST_FOREACH_END(transport);
1343 if (smartlist_len(string_sl)) {
1348 smartlist_free(string_sl);
1350 return options_string;
1360 char *bindaddr_result = NULL;
1361 char *bindaddr_tmp = NULL;
1372 } SMARTLIST_FOREACH_END(t);
1377 smartlist_free(string_tmp);
1379 return bindaddr_result;
1400 char *state_tmp = get_datadir_fname(
"pt_state/");
1408 char *transports_to_launch =
1413 "TOR_PT_SERVER_TRANSPORTS=%s" :
1414 "TOR_PT_CLIENT_TRANSPORTS=%s",
1415 transports_to_launch);
1420 if (mp->is_server) {
1437 char *server_transport_options =
1439 if (server_transport_options) {
1441 server_transport_options);
1442 tor_free(server_transport_options);
1454 char *ext_or_addrport_tmp =
1458 if (ext_or_addrport_tmp) {
1460 ext_or_addrport_tmp);
1462 if (cookie_file_loc) {
1478 if (mp->proxy_uri) {
1502 "TOR_PT_OUTBOUND_BIND_ADDRESS_V4=%s",
1513 "TOR_PT_OUTBOUND_BIND_ADDRESS_V6=[%s]",
1522 } SMARTLIST_FOREACH_END(env_var);
1524 smartlist_free(envs);
1526 return merged_env_vars;
1537 char **proxy_argv,
int is_server)
1539 managed_proxy_t *mp = tor_malloc_zero(
sizeof(managed_proxy_t));
1541 mp->is_server = is_server;
1542 mp->argv = proxy_argv;
1575 char **proxy_argv,
int is_server))
1577 managed_proxy_t *mp=NULL;
1580 if (!proxy_argv || !proxy_argv[0]) {
1590 if (mp->was_around_before_config_read) {
1596 if (mp->marked_for_removal) {
1597 mp->marked_for_removal = 0;
1608 } SMARTLIST_FOREACH_END(transport);
1643 if (mp->conf_state != PT_PROTO_COMPLETED) {
1650 tor_assert(mp->conf_state == PT_PROTO_COMPLETED);
1654 mp->marked_for_removal = 1;
1655 mp->was_around_before_config_read = 1;
1658 } SMARTLIST_FOREACH_END(mp);
1678 if (!mp->is_server || mp->conf_state != PT_PROTO_COMPLETED)
1687 } SMARTLIST_FOREACH_END(mp);
1700 char *the_string = NULL;
1710 if ((!mp->is_server) || (mp->conf_state != PT_PROTO_COMPLETED))
1716 char *transport_args = NULL;
1717 const char *addrport = NULL;
1727 RELAY_FIND_ADDR_NO_FLAG,
1731 RELAY_FIND_ADDR_NO_FLAG, &addr);
1734 log_err(
LD_PT,
"Unable to find address for transport %s", t->name);
1744 if (t->extra_info_args)
1745 tor_asprintf(&transport_args,
" %s", t->extra_info_args);
1748 "transport %s %s%s",
1750 transport_args ? transport_args :
"");
1752 } SMARTLIST_FOREACH_END(t);
1754 } SMARTLIST_FOREACH_END(mp);
1756 if (smartlist_len(string_chunks) == 0) {
1757 smartlist_free(string_chunks);
1765 smartlist_free(string_chunks);
1779 char *escaped_string = NULL;
1780 char *new_string = NULL;
1790 if (!escaped_string)
1794 } SMARTLIST_FOREACH_END(s);
1800 smartlist_free(sl_tmp);
1832 if (mp->marked_for_removal) {
1836 } SMARTLIST_FOREACH_END(mp);
1870 char *new_string = NULL;
1871 char *new_cp = NULL;
1872 size_t length, new_length;
1876 length = strlen(
string);
1879 return tor_strdup(
"");
1882 if (length > (SIZE_MAX - 1)/2)
1886 new_length = (length * 2) + 1;
1888 new_string = new_cp = tor_malloc(new_length);
1891 if (strchr(chars_to_escape, *
string))
1894 *new_cp++ = *
string++;
1941 if (BUG(mp == NULL))
1945 "Managed proxy at '%s' reported via standard error: %s",
1959 const char *
name = mp ? mp->argv[0] :
"N/A";
1962 "Managed proxy \"%s\" process terminated with status code %" PRIu64,
1991 if (! strcmp(severity,
"debug"))
1994 if (! strcmp(severity,
"info"))
1997 if (! strcmp(severity,
"notice"))
2000 if (! strcmp(severity,
"warning"))
2003 if (! strcmp(severity,
"error"))
2029 tor_assert_unreached();
2053managed_proxy_state_to_string(
enum pt_proto_state state)
2056 case PT_PROTO_INFANT:
2058 case PT_PROTO_LAUNCHED:
2060 case PT_PROTO_ACCEPTING_METHODS:
2061 return "Accepting methods";
2062 case PT_PROTO_CONFIGURED:
2063 return "Configured";
2064 case PT_PROTO_COMPLETED:
2066 case PT_PROTO_BROKEN:
2068 case PT_PROTO_FAILED_LAUNCH:
2069 return "Failed to launch";
2073 tor_assert_unreached();
2083 if (mp->conf_state == new_state)
2088 managed_proxy_state_to_string(mp->conf_state),
2089 managed_proxy_state_to_string(new_state));
2091 mp->conf_state = new_state;
void tor_addr_copy(tor_addr_t *dest, const tor_addr_t *src)
int tor_addr_parse(tor_addr_t *addr, const char *src)
int tor_addr_port_split(int severity, const char *addrport, char **address_out, uint16_t *port_out)
int tor_addr_is_null(const tor_addr_t *addr)
char * tor_addr_to_str_dup(const tor_addr_t *addr)
const char * fmt_addrport(const tor_addr_t *addr, uint16_t port)
const char * tor_addr_to_str(char *dest, const tor_addr_t *addr, size_t len, int decorate)
#define tor_addr_eq(a, b)
const smartlist_t * get_socks_args_by_bridge_addrport(const tor_addr_t *addr, uint16_t port)
Header file for circuitbuild.c.
Header file for circuitbuild.c.
char * get_first_listener_addrport_string(int listener_type)
const or_options_t * get_options(void)
Header file for config.c.
void config_line_prepend(config_line_t **lst, const char *key, const char *val)
const config_line_t * config_line_find(const config_line_t *lines, const char *key)
Header file for connection.c.
#define CONN_TYPE_OR_LISTENER
#define CONN_TYPE_EXT_OR_LISTENER
Header file for connection_or.c.
void control_event_pt_status(const char *status)
void control_event_pt_log(const char *log)
void control_event_transport_launched(const char *mode, const char *transport_name, tor_addr_t *addr, uint16_t port)
Header file for control_events.c.
struct smartlist_t * get_current_process_environment_variables(void)
void set_environment_variable_in_smartlist(struct smartlist_t *env_vars, const char *new_var, void(*free_old)(void *), int free_p)
const char * escaped(const char *s)
char * get_ext_or_auth_cookie_file_name(void)
char * kvline_encode(const config_line_t *line, unsigned flags)
config_line_t * kvline_parse(const char *line, unsigned flags)
void tor_log(int severity, log_domain_mask_t domain, const char *format,...)
void tor_free_(void *mem)
Master header file for Tor-specific functionality.
int tor_asprintf(char **strp, const char *fmt,...)
void process_set_stderr_read_callback(process_t *process, process_read_callback_t callback)
void process_set_data(process_t *process, void *data)
void process_append_argument(process_t *process, const char *argument)
void process_set_exit_callback(process_t *process, process_exit_callback_t callback)
void * process_get_data(const process_t *process)
void process_reset_environment(process_t *process, const smartlist_t *env)
void process_set_stdout_read_callback(process_t *process, process_read_callback_t callback)
bool process_terminate(process_t *process)
process_status_t process_exec(process_t *process)
process_t * process_new(const char *command)
process_pid_t process_get_pid(process_t *process)
bool relay_find_addr_to_publish(const or_options_t *options, int family, int flags, tor_addr_t *addr_out)
Header file for relay_find_addr.c.
void mark_my_descriptor_dirty(const char *reason)
Header file for router.c.
void smartlist_add_asprintf(struct smartlist_t *sl, const char *pattern,...)
int smartlist_contains_string(const smartlist_t *sl, const char *element)
char * smartlist_join_strings(smartlist_t *sl, const char *join, int terminate, size_t *len_out)
void smartlist_add_all(smartlist_t *s1, const smartlist_t *s2)
void smartlist_add_strdup(struct smartlist_t *sl, const char *string)
smartlist_t * smartlist_new(void)
void smartlist_add(smartlist_t *sl, void *element)
void smartlist_clear(smartlist_t *sl)
void smartlist_remove(smartlist_t *sl, const void *element)
#define SMARTLIST_FOREACH_BEGIN(sl, type, var)
#define SMARTLIST_FOREACH(sl, type, var, cmd)
#define SMARTLIST_DEL_CURRENT(sl, var)
int smartlist_split_string(smartlist_t *sl, const char *str, const char *sep, int flags, int max)
char * get_stored_bindaddr_for_server_transport(const char *transport)
void save_transport_to_state(const char *transport, const tor_addr_t *addr, uint16_t port)
tor_addr_t Socks4ProxyAddr
tor_addr_t HTTPSProxyAddr
struct config_line_t * ExtORPort_lines
char * Socks5ProxyUsername
char * Socks5ProxyPassword
tor_addr_t Socks5ProxyAddr
tor_addr_t OutboundBindAddresses[OUTBOUND_ADDR_MAX][2]
char * HTTPSProxyAuthenticator
unsigned marked_for_removal
#define MOCK_IMPL(rv, funcname, arglist)
smartlist_t * pt_get_options_for_server_transport(const char *transport)
Header for feature/relay/transport_config.c.
#define PROTO_VERSION_ONE
static managed_proxy_t * get_managed_proxy_by_argv_and_type(char **proxy_argv, int is_server)
static int launch_managed_proxy(managed_proxy_t *mp)
static transport_t * transport_copy(const transport_t *transport)
STATIC char * get_transport_options_for_server_proxy(const managed_proxy_t *mp)
int pt_proxies_configuration_pending(void)
int transport_add_from_config(const tor_addr_t *addr, uint16_t port, const char *name, int socks_ver)
static int managed_proxy_has_argv(const managed_proxy_t *mp, char **proxy_argv)
static void register_client_proxy(const managed_proxy_t *mp)
static void handle_methods_done(const managed_proxy_t *mp)
static void register_proxy(const managed_proxy_t *mp)
bool managed_proxy_has_transport(const char *transport_name)
static void parse_method_error(const char *line, int is_server_method)
static int unconfigured_proxies_n
STATIC char * get_pt_proxy_uri(void)
char * pt_stringify_socks_args(const smartlist_t *socks_args)
STATIC const tor_addr_t * managed_proxy_outbound_address(const or_options_t *options, sa_family_t family)
STATIC transport_t * transport_new(const tor_addr_t *addr, uint16_t port, const char *name, int socks_ver, const char *extra_info_args)
void pt_configure_remaining_proxies(void)
STATIC void parse_proxy_error(const char *line)
STATIC void managed_proxy_destroy(managed_proxy_t *mp, int also_terminate_process)
void sweep_proxy_list(void)
static void clear_transport_list(void)
char * pt_get_socks_args_for_proxy_addrport(const tor_addr_t *addr, uint16_t port)
STATIC void parse_log_line(const char *line, managed_proxy_t *mp)
STATIC managed_proxy_t * managed_proxy_create(const smartlist_t *with_transport_list, char **proxy_argv, int is_server)
void mark_transport_list(void)
static int proxy_needs_restart(const managed_proxy_t *mp)
static void proxy_prepare_for_restart(managed_proxy_t *mp)
STATIC int managed_proxy_severity_parse(const char *severity)
STATIC int parse_cmethod_line(const char *line, managed_proxy_t *mp)
static void handle_finished_proxy(managed_proxy_t *mp)
static int transport_add(transport_t *t)
STATIC void parse_status_line(const char *line, managed_proxy_t *mp)
static smartlist_t * transport_list
transport_t * transport_get_by_name(const char *name)
static void register_server_proxy(const managed_proxy_t *mp)
STATIC void managed_proxy_stderr_callback(process_t *process, const char *line, size_t size)
static void add_transport_to_proxy(const char *transport, managed_proxy_t *mp)
STATIC void managed_proxy_stdout_callback(process_t *process, const char *line, size_t size)
STATIC void managed_proxy_set_state(managed_proxy_t *mp, enum pt_proto_state new_state)
STATIC int parse_version(const char *line, managed_proxy_t *mp)
static smartlist_t * create_managed_proxy_environment(const managed_proxy_t *mp)
void sweep_transport_list(void)
static void assert_unconfigured_count_ok(void)
static char * get_bindaddr_for_server_proxy(const managed_proxy_t *mp)
void transport_free_(transport_t *transport)
STATIC void parse_env_error(const char *line)
void pt_prepare_proxy_list_for_config_read(void)
smartlist_t * get_transport_proxy_ports(void)
static int check_if_restarts_needed
char * tor_escape_str_for_pt_args(const char *string, const char *chars_to_escape)
void pt_kickstart_proxy(const smartlist_t *with_transport_list, char **proxy_argv, int is_server)
STATIC int parse_smethod_line(const char *line, managed_proxy_t *mp)
static int parse_method_line_helper(const char *line, managed_proxy_t *mp, int is_smethod)
static int transport_resolve_conflicts(const transport_t *t)
STATIC int configure_proxy(managed_proxy_t *mp)
STATIC void free_execve_args(char **arg)
STATIC bool managed_proxy_exit_callback(process_t *process, process_exit_code_t exit_code)
static int proxy_configuration_finished(const managed_proxy_t *mp)
char * pt_get_extra_info_descriptor_string(void)
static smartlist_t * managed_proxy_list
STATIC void handle_proxy_line(const char *line, managed_proxy_t *mp)
Headers for transports.c.
int strcmpstart(const char *s1, const char *s2)
int strcmp_opt(const char *s1, const char *s2)
int string_is_C_identifier(const char *string)