tor-commits November 2012

tor-commits@lists.torproject.org

18 participants
1508 discussions

[tor/master] Add some missing doxygen for ipv6 exit code
by nickm＠torproject.org 15 Nov '12

15 Nov '12

commit 85e8d35fca49c0a660e104a85bb727f808b8ffb0 Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Nov 14 15:20:28 2012 -0500 Add some missing doxygen for ipv6 exit code --- src/common/address.c | 4 ++- src/or/connection_edge.c | 28 +++++++++++++-- src/or/connection_edge.h | 26 +++++++++++++- src/or/dns.c | 84 ++++++++++++++++++++++++++++++++------------- src/or/or.h | 5 +-- 5 files changed, 113 insertions(+), 34 deletions(-) diff --git a/src/common/address.c b/src/common/address.c index 7a2ce6e..e94f147 100644 --- a/src/common/address.c +++ b/src/common/address.c @@ -181,7 +181,9 @@ tor_addr_make_unspec(tor_addr_t *a) a->family = AF_UNSPEC; } -/** DOCDOC */ +/** Set address <a>a to the null address in address family family. + * The null address for AF_INET is 0.0.0.0. The null address for AF_INET6 is + * [::]. AF_UNSPEC is all null. */ void tor_addr_make_null(tor_addr_t *a, sa_family_t family) { diff --git a/src/or/connection_edge.c b/src/or/connection_edge.c index fbba172..dc58a0e 100644 --- a/src/or/connection_edge.c +++ b/src/or/connection_edge.c @@ -392,10 +392,17 @@ connection_edge_finished_flushing(edge_connection_t *conn) return 0; } -/** DOCDOC */ +/** Longest size for the relay payload of a RELAY_CONNECTED cell that we're + * able to generate. */ +/* 4 zero bytes; 1 type byte; 16 byte IPv6 address; 4 byte TTL. */ #define MAX_CONNECTED_CELL_PAYLOAD_LEN 25 -/** DOCDOC */ +/** Set the buffer at payload_out -- which must have at least + * MAX_CONNECTED_CELL_PAYLOAD_LEN bytes available -- to the body of a + * RELAY_CONNECTED cell indicating that we have connected to addr, and + * that the name resolution that led us to addr will be valid for + * ttl seconds. Return -1 on error, or the number of bytes used on + * success. */ /* private */int connected_cell_format_payload(uint8_t *payload_out, const tor_addr_t *addr, @@ -404,6 +411,9 @@ connected_cell_format_payload(uint8_t *payload_out, const sa_family_t family = tor_addr_family(addr); int connected_payload_len; + /* should be needless */ + memset(payload_out, 0, MAX_CONNECTED_CELL_PAYLOAD_LEN); + if (family == AF_INET) { set_uint32(payload_out, tor_addr_to_ipv4n(addr)); connected_payload_len = 4; @@ -1672,7 +1682,8 @@ connection_ap_supports_optimistic_data(const entry_connection_t *conn) return conn->may_use_optimistic_data; } -/** DOCDOC */ +/** Return a bitmask of BEGIN_FLAG_* flags that we should transmit in the + * RELAY_BEGIN cell for ap_conn. */ static uint32_t connection_ap_get_begincell_flags(entry_connection_t *ap_conn) { @@ -1680,12 +1691,16 @@ connection_ap_get_begincell_flags(entry_connection_t *ap_conn) const node_t *exitnode = NULL; const crypt_path_t *cpath_layer = edge_conn->cpath_layer; uint32_t flags = 0; + + /* No flags for begindir */ if (ap_conn->use_begindir) return 0; + /* No flags for hidden services. */ if (edge_conn->on_circuit->purpose != CIRCUIT_PURPOSE_C_GENERAL) return 0; + /* If only IPv4 is supported, no flags */ if (ap_conn->ipv4_traffic_ok && !ap_conn->ipv6_traffic_ok) return 0; @@ -1704,6 +1719,8 @@ connection_ap_get_begincell_flags(entry_connection_t *ap_conn) if (compare_tor_addr_to_node_policy(&a, ap_conn->socks_request->port, exitnode) != ADDR_POLICY_REJECTED) { + /* Only say "IPv6 OK" if the exit node supports IPv6. Otherwise there's + * no point. */ flags |= BEGIN_FLAG_IPV6_OK; } } @@ -2184,7 +2201,10 @@ connection_ap_handshake_socks_reply(entry_connection_t *conn, char *reply, return; } -/* DOCDOC */ +/** Read a RELAY_BEGIN or RELAY_BEGINDIR cell from cell, decode it, and + * place the result in bcell. On success return 0; on failure return + * <0 and set *end_reason_out to the end reason we should send back to + * the client. */ /* static */ int begin_cell_parse(const cell_t *cell, begin_cell_t *bcell, uint8_t *end_reason_out) diff --git a/src/or/connection_edge.h b/src/or/connection_edge.h index 95bc29c..9f38951 100644 --- a/src/or/connection_edge.h +++ b/src/or/connection_edge.h @@ -91,19 +91,41 @@ int connection_edge_update_circuit_isolation(const entry_connection_t *conn, int dry_run); void circuit_clear_isolation(origin_circuit_t *circ); -/* DOCDOC*/ +/** @name Begin-cell flags + * + * These flags are used in RELAY_BEGIN cells to change the default behavior + * of the cell. + * + * @{ + **/ +/** When this flag is set, the client is willing to get connected to IPv6 + * addresses */ #define BEGIN_FLAG_IPV6_OK (1u<<0) +/** When this flag is set, the client DOES NOT support connecting to IPv4 + * addresses. (The sense of this flag is inverted from IPV6_OK, so that the + * old default behavior of Tor is equivalent to having all flags set to 0.) + **/ #define BEGIN_FLAG_IPV4_NOT_OK (1u<<1) +/** When this flag is set, if we find both an IPv4 and an IPv6 address, + * we use the IPv6 address. Otherwise we use the IPv4 address. */ #define BEGIN_FLAG_IPV6_PREFERRED (1u<<2) +/**@}*/ #ifdef CONNECTION_EDGE_PRIVATE -/*DOCDOC*/ +/** A parsed BEGIN or BEGIN_DIR cell */ typedef struct begin_cell_t { + /** The address the client has asked us to connect to, or NULL if this is + * a BEGIN_DIR cell*/ char *address; + /** The flags specified in the BEGIN cell's body. One or more of + * BEGIN_FLAG_*. */ uint32_t flags; + /** The client's requested port. */ uint16_t port; + /** The client's requested Stream ID */ uint16_t stream_id; + /** True iff this is a BEGIN_DIR cell. */ unsigned is_begindir : 1; } begin_cell_t; diff --git a/src/or/dns.c b/src/or/dns.c index b7b5e0e..6090c45 100644 --- a/src/or/dns.c +++ b/src/or/dns.c @@ -127,10 +127,16 @@ typedef struct pending_connection_t { * connections, and should appear in the hash table. */ #define CACHE_STATE_CACHED 2 -/* DOCDOC */ +/** @name status values for a single DNS request. + * + * @{ */ +/** The DNS request is in progress. */ #define RES_STATUS_INFLIGHT 1 +/** The DNS request finished and gave an answer */ #define RES_STATUS_DONE_OK 2 +/** The DNS request finished and gave an error */ #define RES_STATUS_DONE_ERR 3 +/**@}*/ /** A DNS request: possibly completed, possibly pending; cached_resolve * structs are stored at the OR side in a hash table, and as a linked @@ -138,27 +144,34 @@ typedef struct pending_connection_t { */ typedef struct cached_resolve_t { HT_ENTRY(cached_resolve_t) node; - uint32_t magic; + uint32_t magic; /**< Must be CACHED_RESOLVE_MAGIC */ char address[MAX_ADDRESSLEN]; /**< The hostname to be resolved. */ union { - uint32_t addr_ipv4; /**< IPv4 addr for address. */ - int err_ipv4; - } result_ipv4; + uint32_t addr_ipv4; /**< IPv4 addr for address, if successful */ + int err_ipv4; /**< One of DNS_ERR_*, if IPv4 lookup failed. */ + } result_ipv4; /**< Outcome of IPv4 lookup */ union { - struct in6_addr addr_ipv6; - int err_ipv6; - } result_ipv6; + struct in6_addr addr_ipv6; /**< IPv6 addr for address, if + * successful */ + int err_ipv6; /**< One of DNS_ERR_*, if IPv6 lookup failed. */ + } result_ipv6; /**< Outcome of IPv6 lookup, if any */ union { - char *hostname; - int err_hostname; + char *hostname; /** A hostname, if PTR lookup happened successfully*/ + int err_hostname; /** One of DNS_ERR_*, if PTR lookup failed. */ } result_ptr; + /** @name Status fields + * + * These take one of the RES_STATUS_* values, depending on the state + * of the corresponding lookup. + * + * @{ */ unsigned int res_status_ipv4 : 2; unsigned int res_status_ipv6 : 2; unsigned int res_status_hostname : 2; - + /**@}*/ uint8_t state; /**< Is this cached entry pending/done/informative? */ - //uint8_t is_reverse; /**< Is this a reverse (addr-to-hostname) lookup? */ + time_t expire; /**< Remove items from cache after this time. */ uint32_t ttl_ipv4; /**< What TTL did the nameserver tell us? */ uint32_t ttl_ipv6; /**< What TTL did the nameserver tell us? */ @@ -201,9 +214,11 @@ static void assert_resolve_ok(cached_resolve_t *resolve); /** Hash table of cached_resolve objects. */ static HT_HEAD(cache_map, cached_resolve_t) cache_root; -/*DOCDOC*/ +/** Global: how many IPv6 requests have we made in all? */ static uint64_t n_ipv6_requests_made = 0; +/** Global: how many IPv6 requests have timed out? */ static uint64_t n_ipv6_timeouts = 0; +/** Global: Do we think that IPv6 DNS is broken? */ static int dns_is_broken_for_ipv6 = 0; /** Function to compare hashed resolves on their addresses; used to @@ -445,7 +460,7 @@ cached_resolve_add_answer(cached_resolve_t *resolve, } } -/*DOCDOC*/ +/** Return true iff there are no in-flight requests for resolve. */ static int cached_resolve_have_all_answers(const cached_resolve_t *resolve) { @@ -911,7 +926,16 @@ dns_resolve_impl(edge_connection_t *exitconn, int is_resolve, return launch_resolve(resolve); } -/* DOCDOC must set address_ttl, addr, etc.*/ +/** Given an exit connection exitconn, and a cached_resolve_t + * resolve whose DNS lookups have all succeeded or failed, update the + * appropriate fields (address_ttl and addr) of exitconn. + * + * If this is a reverse lookup, set *hostname_out to a newly allocated + * copy of the name resulting hostname. + * + * Return -2 on a transient error, -1 on a permenent error, and 1 on + * a successful lookup. + */ static int set_exitconn_info_from_resolve(edge_connection_t *exitconn, const cached_resolve_t *resolve, @@ -1178,11 +1202,14 @@ is_test_address(const char *address) smartlist_string_isin_case(options->ServerDNSTestAddresses, address); } -/** Called on the OR side when a DNS worker or the eventdns library tells us - * the outcome of a DNS resolve: tell all pending connections about the result - * of the lookup, and cache the value. (address is a NUL-terminated - * string containing the address to look up; addr is an IPv4 address in - * host order; DOCDOC +/** Called on the OR side when the eventdns library tells us the outcome of a + * single DNS resolve: remember the answer, and tell all pending connections + * about the result of the lookup if the lookup is now done. (address + * is a NUL-terminated string containing the address to look up; + * query_type is one of DNS_{IPv4_A,IPv6_AAAA,PTR}; dns_answer + * is DNS_OK or one of DNS_ERR_*, addr is an IPv4 or IPv6 address if we + * got one; hostname is a hostname fora PTR request if we got one, and + * ttl is the time-to-live of this answer, in seconds.) */ static void dns_found_answer(const char *address, uint8_t query_type, @@ -1229,7 +1256,9 @@ dns_found_answer(const char *address, uint8_t query_type, } } -/*DOCDOC*/ +/** Given a pending cached_resolve_t that we just finished resolving, + * inform every connection that was waiting for the outcome of that + * resolution. */ static void inform_pending_connections(cached_resolve_t *resolve) { @@ -1306,7 +1335,12 @@ inform_pending_connections(cached_resolve_t *resolve) } } -/*DOCDOC*/ +/** Remove a pending cached_resolve_t from the hashtable, and add a + * corresponding cached cached_resolve_t. + * + * This function is only necessary because of the perversity of our + * cache timeout code; see inline comment for ideas on eliminating it. + **/ static void make_pending_resolve_cached(cached_resolve_t *resolve) { @@ -1627,7 +1661,9 @@ evdns_callback(int result, char type, int count, int ttl, void *addresses, tor_free(arg_); } -/**DOCDOC*/ +/** Start a single DNS resolve for address (if query_type is + * DNS_IPv4_A or DNS_IPv6_AAAA) ptr_address (if query_type is + * DNS_PTR). Return 0 if we launched the request, -1 otherwise. */ static int launch_one_resolve(const char *address, uint8_t query_type, const tor_addr_t *ptr_address) @@ -2011,7 +2047,7 @@ dns_seems_to_be_broken(void) return dns_is_completely_invalid; } -/** DOCDOC */ +/** Return true iff we think that IPv6 hostname lookup is broken */ int dns_seems_to_be_broken_for_ipv6(void) { diff --git a/src/or/or.h b/src/or/or.h index 4566f91..a8645f8 100644 --- a/src/or/or.h +++ b/src/or/or.h @@ -1237,7 +1237,6 @@ typedef struct listener_connection_t { * addresses? */ unsigned int socks_prefer_ipv6 : 1; - } listener_connection_t; /** Minimum length of the random part of an AUTH_CHALLENGE cell. */ @@ -1444,7 +1443,7 @@ typedef struct edge_connection_t { /** True iff this connection is for a DNS request only. */ unsigned int is_dns_request:1; - /* DOCDOC exit only */ + /** True iff this connection is for a PTR DNS request. (exit only) */ unsigned int is_reverse_dns_lookup:1; unsigned int edge_has_sent_end:1; /**< For debugging; only used on edge @@ -3772,7 +3771,7 @@ typedef struct { int PathBiasScaleFactor; /** @} */ - int IPv6Exit; /**< DOCDOC*/ + int IPv6Exit; /**< Do we support exiting to IPv6 addresses? */ } or_options_t;

1 0

[tor/master] Implement a PreferIPv6 flag for SocksPorts
by nickm＠torproject.org 15 Nov '12

15 Nov '12

commit 363cf024553741524c0c8cb9fa8b9226863c903b Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Nov 14 10:09:06 2012 -0500 Implement a PreferIPv6 flag for SocksPorts --- src/or/config.c | 6 +++++- src/or/connection.c | 2 ++ src/or/connection_edge.c | 7 +++++++ src/or/or.h | 7 +++++++ 4 files changed, 21 insertions(+), 1 deletions(-) diff --git a/src/or/config.c b/src/or/config.c index 98fbb6e..e069c7c 100644 --- a/src/or/config.c +++ b/src/or/config.c @@ -4605,7 +4605,7 @@ parse_port_config(smartlist_t *out, int ok; int no_listen = 0, no_advertise = 0, all_addrs = 0, bind_ipv4_only = 0, bind_ipv6_only = 0, - ipv4_traffic = 1, ipv6_traffic = 0; + ipv4_traffic = 1, ipv6_traffic = 0, prefer_ipv6 = 0; smartlist_split_string(elts, ports->value, NULL, SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0); @@ -4737,6 +4737,9 @@ parse_port_config(smartlist_t *out, } else if (!strcasecmp(elt, "IPv6Traffic")) { ipv6_traffic = ! no; continue; + } else if (!strcasecmp(elt, "PreferIPv6")) { + prefer_ipv6 = ! no; + continue; } } @@ -4785,6 +4788,7 @@ parse_port_config(smartlist_t *out, cfg->bind_ipv6_only = bind_ipv6_only; cfg->ipv4_traffic = ipv4_traffic; cfg->ipv6_traffic = ipv6_traffic; + cfg->prefer_ipv6 = prefer_ipv6; smartlist_add(out, cfg); } diff --git a/src/or/connection.c b/src/or/connection.c index 89ac8f5..ecfb8a9 100644 --- a/src/or/connection.c +++ b/src/or/connection.c @@ -1118,6 +1118,7 @@ connection_listener_new(const struct sockaddr *listensockaddr, if (type == CONN_TYPE_AP) { lis_conn->socks_ipv4_traffic = port_cfg->ipv4_traffic; lis_conn->socks_ipv6_traffic = port_cfg->ipv6_traffic; + lis_conn->socks_prefer_ipv6 = port_cfg->prefer_ipv6; } else { lis_conn->socks_ipv4_traffic = 1; lis_conn->socks_ipv6_traffic = 1; @@ -1357,6 +1358,7 @@ connection_init_accepted_conn(connection_t *conn, TO_ENTRY_CONN(conn)->socks_request->listener_type = listener->base_.type; TO_ENTRY_CONN(conn)->ipv4_traffic_ok = listener->socks_ipv4_traffic; TO_ENTRY_CONN(conn)->ipv6_traffic_ok = listener->socks_ipv6_traffic; + TO_ENTRY_CONN(conn)->prefer_ipv6_traffic = listener->socks_prefer_ipv6; switch (TO_CONN(listener)->type) { case CONN_TYPE_AP_LISTENER: conn->state = AP_CONN_STATE_SOCKS_WAIT; diff --git a/src/or/connection_edge.c b/src/or/connection_edge.c index 758d8f5..4f3dda2 100644 --- a/src/or/connection_edge.c +++ b/src/or/connection_edge.c @@ -1682,6 +1682,13 @@ connection_ap_get_begincell_flags(entry_connection_t *ap_conn) } } + if (flags == BEGIN_FLAG_IPV6_OK) { + /* When IPv4 and IPv6 are both allowed, consider whether to say we + * prefer IPv6. Otherwise there's no point in declaring a preference */ + if (ap_conn->prefer_ipv6_traffic) + flags |= BEGIN_FLAG_IPV6_PREFERRED; + } + if (flags == BEGIN_FLAG_IPV4_NOT_OK) { log_warn(LD_BUG, "Hey; I'm about to ask a node for a connection that I " "am telling it to fulfil with neither IPv4 nor IPv6. That's " diff --git a/src/or/or.h b/src/or/or.h index f22c7df..4566f91 100644 --- a/src/or/or.h +++ b/src/or/or.h @@ -1233,6 +1233,10 @@ typedef struct listener_connection_t { unsigned int socks_ipv4_traffic : 1; unsigned int socks_ipv6_traffic : 1; /** @} */ + /** For a socks listener: should we tell the exit that we prefer IPv6 + * addresses? */ + unsigned int socks_prefer_ipv6 : 1; + } listener_connection_t; @@ -1539,6 +1543,8 @@ typedef struct entry_connection_t { unsigned int ipv4_traffic_ok : 1; unsigned int ipv6_traffic_ok : 1; /** @} */ + /** Should we say we prefer IPv6 traffic? */ + unsigned int prefer_ipv6_traffic : 1; } entry_connection_t; @@ -3064,6 +3070,7 @@ typedef struct port_cfg_t { unsigned int bind_ipv6_only : 1; unsigned int ipv4_traffic : 1; unsigned int ipv6_traffic : 1; + unsigned int prefer_ipv6 : 1; /* Unix sockets only: */ /** Path for an AF_UNIX address */

1 0

[tor/master] Remove some unused defines in dns.c
by nickm＠torproject.org 15 Nov '12

15 Nov '12

commit 6b36142bcc6f268a5312e197c4c3397065b3414e Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Nov 14 10:18:33 2012 -0500 Remove some unused defines in dns.c --- src/or/dns.c | 9 +-------- 1 files changed, 1 insertions(+), 8 deletions(-) diff --git a/src/or/dns.c b/src/or/dns.c index 5a7f07c..b7b5e0e 100644 --- a/src/or/dns.c +++ b/src/or/dns.c @@ -87,12 +87,6 @@ struct evdns_request; * that the resolver is wedged? */ #define RESOLVE_MAX_TIMEOUT 300 -/** Possible outcomes from hostname lookup: permanent failure, - * transient (retryable) failure, and success. */ -#define DNS_RESOLVE_FAILED_TRANSIENT 1 -#define DNS_RESOLVE_FAILED_PERMANENT 2 -#define DNS_RESOLVE_SUCCEEDED 3 - /** Our evdns_base; this structure handles all our name lookups. */ static struct evdns_base *the_evdns_base = NULL; @@ -1188,8 +1182,7 @@ is_test_address(const char *address) * the outcome of a DNS resolve: tell all pending connections about the result * of the lookup, and cache the value. (address is a NUL-terminated * string containing the address to look up; addr is an IPv4 address in - * host order; outcome is one of - * DNS_RESOLVE_{FAILED_TRANSIENT|FAILED_PERMANENT|SUCCEEDED}. + * host order; DOCDOC */ static void dns_found_answer(const char *address, uint8_t query_type,

1 0

[tor/master] Accept reverse resolve requests for IPv6 addresses
by nickm＠torproject.org 15 Nov '12

15 Nov '12

commit 50af1087c4e92dfb4a30ddce4f6046970d6108e2 Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Nov 14 22:20:01 2012 -0500 Accept reverse resolve requests for IPv6 addresses --- src/or/connection_edge.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/src/or/connection_edge.c b/src/or/connection_edge.c index dc58a0e..426b993 100644 --- a/src/or/connection_edge.c +++ b/src/or/connection_edge.c @@ -1879,7 +1879,7 @@ connection_ap_handshake_send_resolve(entry_connection_t *ap_conn) /* We're doing a reverse lookup. The input could be an IP address, or * could be an .in-addr.arpa or .ip6.arpa address */ - r = tor_addr_parse_PTR_name(&addr, a, AF_INET, 1); + r = tor_addr_parse_PTR_name(&addr, a, AF_UNSPEC, 1); if (r <= 0) { log_warn(LD_APP, "Rejecting ill-formed reverse lookup of %s", safe_str_client(a));

1 0

[tor/master] Fix a bug in policy_is_reject_star() that was making IPv4 exits break
by nickm＠torproject.org 15 Nov '12

15 Nov '12

commit bb2145b45ba5992eae6d647b946b430dd2367375 Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Nov 14 20:51:41 2012 -0500 Fix a bug in policy_is_reject_star() that was making IPv4 exits break IPv4-only exits have an implicit "reject [::]/0", which was making policy_is_reject_star() return 1 for them, making us refuse to do hostname lookups. This fix chanes policy_is_reject_star() to ask about which family we meant. --- src/or/dns.c | 6 ++---- src/or/policies.c | 19 ++++++++++++------- src/or/policies.h | 2 +- src/or/router.c | 3 ++- src/or/routerparse.c | 7 +++++-- src/test/test.c | 6 +++--- 6 files changed, 25 insertions(+), 18 deletions(-) diff --git a/src/or/dns.c b/src/or/dns.c index 6090c45..976d188 100644 --- a/src/or/dns.c +++ b/src/or/dns.c @@ -799,7 +799,6 @@ dns_resolve_impl(edge_connection_t *exitconn, int is_resolve, cached_resolve_t search; pending_connection_t *pending_connection; int is_reverse = 0; - const routerinfo_t *me; tor_addr_t addr; time_t now = time(NULL); int r; @@ -824,10 +823,9 @@ dns_resolve_impl(edge_connection_t *exitconn, int is_resolve, } /* If we're a non-exit, don't even do DNS lookups. */ - if (!(me = router_get_my_routerinfo()) || - policy_is_reject_star(me->exit_policy)) { + if (router_my_exit_policy_is_reject_star()) return -1; - } + if (address_is_invalid_destination(exitconn->base_.address, 0)) { log(LOG_PROTOCOL_WARN, LD_EXIT, "Rejecting invalid destination address %s", diff --git a/src/or/policies.c b/src/or/policies.c index f9646f8..dd7de70 100644 --- a/src/or/policies.c +++ b/src/or/policies.c @@ -1049,18 +1049,23 @@ exit_policy_is_general_exit(smartlist_t *policy) /** Return false if policy might permit access to some addr:port; * otherwise if we are certain it rejects everything, return true. */ int -policy_is_reject_star(const smartlist_t *policy) +policy_is_reject_star(const smartlist_t *policy, sa_family_t family) { if (!policy) /*XXXX disallow NULL policies? */ return 1; - SMARTLIST_FOREACH(policy, addr_policy_t *, p, { - if (p->policy_type == ADDR_POLICY_ACCEPT) + SMARTLIST_FOREACH_BEGIN(policy, addr_policy_t *, p) { + if (p->policy_type == ADDR_POLICY_ACCEPT && + (tor_addr_family(&p->addr) == family || + tor_addr_family(&p->addr) == AF_UNSPEC)) { return 0; - else if (p->policy_type == ADDR_POLICY_REJECT && - p->prt_min <= 1 && p->prt_max == 65535 && - p->maskbits == 0) + } else if (p->policy_type == ADDR_POLICY_REJECT && + p->prt_min <= 1 && p->prt_max == 65535 && + p->maskbits == 0 && + (tor_addr_family(&p->addr) == family || + tor_addr_family(&p->addr) == AF_UNSPEC)) { return 1; - }); + } + } SMARTLIST_FOREACH_END(p); return 1; } diff --git a/src/or/policies.h b/src/or/policies.h index f8de911..d9983e8 100644 --- a/src/or/policies.h +++ b/src/or/policies.h @@ -49,7 +49,7 @@ int policies_parse_exit_policy(config_line_t *cfg, smartlist_t **dest, void policies_exit_policy_append_reject_star(smartlist_t **dest); void policies_set_node_exitpolicy_to_reject_all(node_t *exitrouter); int exit_policy_is_general_exit(smartlist_t *policy); -int policy_is_reject_star(const smartlist_t *policy); +int policy_is_reject_star(const smartlist_t *policy, sa_family_t family); int getinfo_helper_policies(control_connection_t *conn, const char *question, char **answer, const char **errmsg); diff --git a/src/or/router.c b/src/or/router.c index f51b74e..d5ffb36 100644 --- a/src/or/router.c +++ b/src/or/router.c @@ -1621,7 +1621,8 @@ router_rebuild_descriptor(int force) ri->address, !options->BridgeRelay); } ri->policy_is_reject_star = - policy_is_reject_star(ri->exit_policy); + policy_is_reject_star(ri->exit_policy, AF_INET) && + policy_is_reject_star(ri->exit_policy, AF_INET6); if (options->IPv6Exit) { char *p_tmp = policy_summarize(ri->exit_policy, AF_INET6); diff --git a/src/or/routerparse.c b/src/or/routerparse.c index 5607479..82c062c 100644 --- a/src/or/routerparse.c +++ b/src/or/routerparse.c @@ -1574,8 +1574,6 @@ router_parse_entry_from_string(const char *s, const char *end, goto err; }); policy_expand_private(&router->exit_policy); - if (policy_is_reject_star(router->exit_policy)) - router->policy_is_reject_star = 1; if ((tok = find_opt_by_keyword(tokens, K_IPV6_POLICY)) && tok->n_args) { router->ipv6_exit_policy = parse_short_policy(tok->args[0]); @@ -1585,6 +1583,11 @@ router_parse_entry_from_string(const char *s, const char *end, } } + if (policy_is_reject_star(router->exit_policy, AF_INET) && + (!router->ipv6_exit_policy || + short_policy_is_reject_star(router->ipv6_exit_policy))) + router->policy_is_reject_star = 1; + if ((tok = find_opt_by_keyword(tokens, K_FAMILY)) && tok->n_args) { int i; router->declared_family = smartlist_new(); diff --git a/src/test/test.c b/src/test/test.c index d70f255..c96aeb7 100644 --- a/src/test/test.c +++ b/src/test/test.c @@ -1176,9 +1176,9 @@ test_policies(void) test_assert(!cmp_addr_policies(policy2, policy2)); test_assert(!cmp_addr_policies(NULL, NULL)); - test_assert(!policy_is_reject_star(policy2)); - test_assert(policy_is_reject_star(policy)); - test_assert(policy_is_reject_star(NULL)); + test_assert(!policy_is_reject_star(policy2, AF_INET)); + test_assert(policy_is_reject_star(policy, AF_INET)); + test_assert(policy_is_reject_star(NULL, AF_INET)); addr_policy_list_free(policy); policy = NULL;

1 0

[tor/master] Make DNS resolve requests work for IPv6
by nickm＠torproject.org 15 Nov '12

15 Nov '12

commit 0f899518cf13ad2b6d99845ac82e7cbf93ef0fb4 Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Nov 14 22:06:13 2012 -0500 Make DNS resolve requests work for IPv6 * If there's an IPv4 and an IPv6 address, return both in the resolved cell. * Treat all resolve requests as permitting IPv6, since by the spec they're allowed to, and by the code that won't break anything. --- src/or/dns.c | 105 ++++++++++++++++++++++++++++++++++----------------------- 1 files changed, 63 insertions(+), 42 deletions(-) diff --git a/src/or/dns.c b/src/or/dns.c index 976d188..9834bd7 100644 --- a/src/or/dns.c +++ b/src/or/dns.c @@ -148,7 +148,8 @@ typedef struct cached_resolve_t { char address[MAX_ADDRESSLEN]; /**< The hostname to be resolved. */ union { - uint32_t addr_ipv4; /**< IPv4 addr for address, if successful */ + uint32_t addr_ipv4; /**< IPv4 addr for address, if successful. + * (In host order.) */ int err_ipv4; /**< One of DNS_ERR_*, if IPv4 lookup failed. */ } result_ipv4; /**< Outcome of IPv4 lookup */ union { @@ -188,14 +189,16 @@ static void dns_found_answer(const char *address, uint8_t query_type, const tor_addr_t *addr, const char *hostname, uint32_t ttl); -static void send_resolved_cell(edge_connection_t *conn, uint8_t answer_type); +static void send_resolved_cell(edge_connection_t *conn, uint8_t answer_type, + const cached_resolve_t *resolve); static int launch_resolve(cached_resolve_t *resolve); static void add_wildcarded_test_address(const char *address); static int configure_nameservers(int force); static int answer_is_wildcarded(const char *ip); static int dns_resolve_impl(edge_connection_t *exitconn, int is_resolve, or_circuit_t *oncirc, char **resolved_to_hostname, - int *made_connection_pending_out); + int *made_connection_pending_out, + cached_resolve_t **resolve_out); static int set_exitconn_info_from_resolve(edge_connection_t *exitconn, const cached_resolve_t *resolve, char **hostname_out); @@ -593,55 +596,55 @@ purge_expired_resolves(time_t now) /** Send a response to the RESOLVE request of a connection. * answer_type must be one of - * RESOLVED_TYPE_(IPV4|IPV6|ERROR|ERROR_TRANSIENT|AUTO). + * RESOLVED_TYPE_(AUTO|ERROR|ERROR_TRANSIENT|). * * If circ is provided, and we have a cached answer, send the * answer back along circ; otherwise, send the answer back along * conn's attached circuit. */ static void -send_resolved_cell(edge_connection_t *conn, uint8_t answer_type) +send_resolved_cell(edge_connection_t *conn, uint8_t answer_type, + const cached_resolve_t *resolved) { - char buf[RELAY_PAYLOAD_SIZE]; - size_t buflen; + char buf[RELAY_PAYLOAD_SIZE], *cp = buf; + size_t buflen = 0; uint32_t ttl; - if (answer_type == RESOLVED_TYPE_AUTO) { - sa_family_t family = tor_addr_family(&conn->base_.addr); - if (family == AF_INET) - answer_type = RESOLVED_TYPE_IPV4; - else if (family == AF_INET6) - answer_type = RESOLVED_TYPE_IPV6; - else - answer_type = RESOLVED_TYPE_ERROR_TRANSIENT; - } - buf[0] = answer_type; ttl = dns_clip_ttl(conn->address_ttl); switch (answer_type) { - case RESOLVED_TYPE_IPV4: - buf[1] = 4; - set_uint32(buf+2, tor_addr_to_ipv4n(&conn->base_.addr)); - set_uint32(buf+6, htonl(ttl)); - buflen = 10; - break; - case RESOLVED_TYPE_IPV6: - { - const uint8_t *bytes = tor_addr_to_in6_addr8(&conn->base_.addr); - buf[1] = 16; - memcpy(buf+2, bytes, 16); - set_uint32(buf+18, htonl(ttl)); - buflen = 22; + case RESOLVED_TYPE_AUTO: + if (resolved && resolved->res_status_ipv4 == RES_STATUS_DONE_OK) { + cp[0] = RESOLVED_TYPE_IPV4; + cp[1] = 4; + set_uint32(cp+2, htonl(resolved->result_ipv4.addr_ipv4)); + set_uint32(cp+6, htonl(ttl)); + cp += 10; + } + if (resolved && resolved->res_status_ipv6 == RES_STATUS_DONE_OK) { + const uint8_t *bytes = resolved->result_ipv6.addr_ipv6.s6_addr; + cp[0] = RESOLVED_TYPE_IPV6; + cp[1] = 16; + memcpy(cp+2, bytes, 16); + set_uint32(cp+18, htonl(ttl)); + cp += 22; + } + if (cp != buf) { + buflen = cp - buf; + break; + } else { + answer_type = RESOLVED_TYPE_ERROR; + /* fall through. */ } - break; case RESOLVED_TYPE_ERROR_TRANSIENT: case RESOLVED_TYPE_ERROR: { const char *errmsg = "Error resolving hostname"; size_t msglen = strlen(errmsg); + buf[0] = answer_type; buf[1] = msglen; strlcpy(buf+2, errmsg, sizeof(buf)-2); set_uint32(buf+2+msglen, htonl(ttl)); @@ -719,10 +722,11 @@ dns_resolve(edge_connection_t *exitconn) int is_resolve, r; int made_connection_pending = 0; char *hostname = NULL; + cached_resolve_t *resolve = NULL; is_resolve = exitconn->base_.purpose == EXIT_PURPOSE_RESOLVE; r = dns_resolve_impl(exitconn, is_resolve, oncirc, &hostname, - &made_connection_pending); + &made_connection_pending, &resolve); switch (r) { case 1: @@ -733,7 +737,7 @@ dns_resolve(edge_connection_t *exitconn) if (hostname) send_resolved_hostname_cell(exitconn, hostname); else - send_resolved_cell(exitconn, RESOLVED_TYPE_AUTO); + send_resolved_cell(exitconn, RESOLVED_TYPE_AUTO, resolve); exitconn->on_circuit = NULL; } else { /* Add to the n_streams list; the calling function will send back a @@ -755,7 +759,8 @@ dns_resolve(edge_connection_t *exitconn) * and stop everybody waiting for the same connection. */ if (is_resolve) { send_resolved_cell(exitconn, - (r == -1) ? RESOLVED_TYPE_ERROR : RESOLVED_TYPE_ERROR_TRANSIENT); + (r == -1) ? RESOLVED_TYPE_ERROR : RESOLVED_TYPE_ERROR_TRANSIENT, + NULL); } exitconn->on_circuit = NULL; @@ -789,11 +794,14 @@ dns_resolve(edge_connection_t *exitconn) * Set *made_connection_pending_out to true if we have placed * exitconn on the list of pending connections for some resolve; set it * to false otherwise. + * + * Set *resolve_out to a cached resolve, if we found one. */ static int dns_resolve_impl(edge_connection_t *exitconn, int is_resolve, or_circuit_t *oncirc, char **hostname_out, - int *made_connection_pending_out) + int *made_connection_pending_out, + cached_resolve_t **resolve_out) { cached_resolve_t *resolve; cached_resolve_t search; @@ -891,6 +899,8 @@ dns_resolve_impl(edge_connection_t *exitconn, int is_resolve, exitconn->base_.s, escaped_safe_str(resolve->address)); + *resolve_out = resolve; + return set_exitconn_info_from_resolve(exitconn, resolve, hostname_out); case CACHE_STATE_DONE: @@ -940,6 +950,8 @@ set_exitconn_info_from_resolve(edge_connection_t *exitconn, char **hostname_out) { int ipv4_ok, ipv6_ok, answer_with_ipv4, r; + uint32_t begincell_flags; + const int is_resolve = exitconn->base_.purpose == EXIT_PURPOSE_RESOLVE; tor_assert(exitconn); tor_assert(resolve); @@ -955,14 +967,22 @@ set_exitconn_info_from_resolve(edge_connection_t *exitconn, /* If we're here then the connection wants one or either of ipv4, ipv6, and * we can give it one or both. */ + if (is_resolve) { + begincell_flags = BEGIN_FLAG_IPV6_OK; + } else { + begincell_flags = exitconn->begincell_flags; + } + ipv4_ok = (resolve->res_status_ipv4 == RES_STATUS_DONE_OK) && - ! (exitconn->begincell_flags & BEGIN_FLAG_IPV4_NOT_OK); + ! (begincell_flags & BEGIN_FLAG_IPV4_NOT_OK); ipv6_ok = (resolve->res_status_ipv6 == RES_STATUS_DONE_OK) && - (exitconn->begincell_flags & BEGIN_FLAG_IPV6_OK) && + (begincell_flags & BEGIN_FLAG_IPV6_OK) && get_options()->IPv6Exit; /* Now decide which one to actually give. */ - if (ipv4_ok && ipv6_ok) { + if (ipv4_ok && ipv6_ok && is_resolve) { + answer_with_ipv4 = 1; + } else if (ipv4_ok && ipv6_ok) { /* If we have both, see if our exit policy has an opinion. */ const uint16_t port = exitconn->base_.port; int ipv4_allowed, ipv6_allowed; @@ -978,7 +998,7 @@ set_exitconn_info_from_resolve(edge_connection_t *exitconn, } else { /* Our exit policy would permit both. Answer with whichever the user * prefers */ - answer_with_ipv4 = !(exitconn->begincell_flags & + answer_with_ipv4 = !(begincell_flags & BEGIN_FLAG_IPV6_PREFERRED); } } else { @@ -989,7 +1009,7 @@ set_exitconn_info_from_resolve(edge_connection_t *exitconn, answer_with_ipv4 = 0; } else { /* Neither one was okay. Choose based on user preference. */ - answer_with_ipv4 = !(exitconn->begincell_flags & + answer_with_ipv4 = !(begincell_flags & BEGIN_FLAG_IPV6_PREFERRED); } } @@ -1292,7 +1312,8 @@ inform_pending_connections(cached_resolve_t *resolve) circuit_detach_stream(circuit_get_by_edge_conn(pendconn), pendconn); } else { send_resolved_cell(pendconn, r == -1 ? - RESOLVED_TYPE_ERROR : RESOLVED_TYPE_ERROR_TRANSIENT); + RESOLVED_TYPE_ERROR : RESOLVED_TYPE_ERROR_TRANSIENT, + NULL); /* This detach must happen after we send the resolved cell. */ circuit_detach_stream(circuit_get_by_edge_conn(pendconn), pendconn); } @@ -1321,7 +1342,7 @@ inform_pending_connections(cached_resolve_t *resolve) if (pendconn->is_reverse_dns_lookup) send_resolved_hostname_cell(pendconn, hostname); else - send_resolved_cell(pendconn, RESOLVED_TYPE_AUTO); + send_resolved_cell(pendconn, RESOLVED_TYPE_AUTO, resolve); circ = circuit_get_by_edge_conn(pendconn); tor_assert(circ); circuit_detach_stream(circ, pendconn);

1 0

[tor/master] Let tor-resolve generate PTR requests for IPv6 addresses
by nickm＠torproject.org 15 Nov '12

15 Nov '12

commit 053f2cb7c89a4f6b52fa601f83f798d45ab8eca4 Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Nov 14 22:20:18 2012 -0500 Let tor-resolve generate PTR requests for IPv6 addresses --- src/or/dnsserv.c | 1 + src/tools/tor-resolve.c | 16 +++++++++++----- 2 files changed, 12 insertions(+), 5 deletions(-) diff --git a/src/or/dnsserv.c b/src/or/dnsserv.c index 5875d96..f5d430b 100644 --- a/src/or/dnsserv.c +++ b/src/or/dnsserv.c @@ -89,6 +89,7 @@ evdns_server_callback(struct evdns_server_request *req, void *data_) continue; switch (req->questions[i]->type) { case EVDNS_TYPE_A: + case EVDNS_TYPE_AAAA: case EVDNS_TYPE_PTR: q = req->questions[i]; default: diff --git a/src/tools/tor-resolve.c b/src/tools/tor-resolve.c index 19a67fc..cae5fbb 100644 --- a/src/tools/tor-resolve.c +++ b/src/tools/tor-resolve.c @@ -74,23 +74,29 @@ build_socks_resolve_request(char **out, memcpy((*out)+8+strlen(username)+1, hostname, strlen(hostname)+1); } else if (version == 5) { int is_ip_address; - struct in_addr in; + tor_addr_t addr; size_t addrlen; - is_ip_address = tor_inet_aton(hostname, &in); + int ipv6; + is_ip_address = tor_addr_parse(&addr, hostname) != -1; if (!is_ip_address && reverse) { log_err(LD_GENERAL, "Tried to do a reverse lookup on a non-IP!"); return -1; } - addrlen = reverse ? 4 : 1 + strlen(hostname); + ipv6 = reverse && tor_addr_family(&addr) == AF_INET6; + addrlen = reverse ? (ipv6 ? 16 : 4) : 1 + strlen(hostname); len = 6 + addrlen; *out = tor_malloc(len); (*out)[0] = 5; /* SOCKS version 5 */ (*out)[1] = reverse ? '\xF1' : '\xF0'; /* RESOLVE_PTR or RESOLVE */ (*out)[2] = 0; /* reserved. */ - (*out)[3] = reverse ? 1 : 3; if (reverse) { - set_uint32((*out)+4, in.s_addr); + (*out)[3] = ipv6 ? 4 : 1; + if (ipv6) + memcpy((*out)+4, tor_addr_to_in6_addr8(&addr), 16); + else + set_uint32((*out)+4, tor_addr_to_ipv4n(&addr)); } else { + (*out)[3] = 3; (*out)[4] = (char)(uint8_t)(addrlen - 1); memcpy((*out)+5, hostname, addrlen - 1); }

1 0

[tor/master] Add IPv6 support to tor-resolve so it can hear about IPv6 answers
by nickm＠torproject.org 15 Nov '12

15 Nov '12

commit 4db49f2b27be858fccfc646cb6ce11e9b2cb98d4 Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Nov 14 22:07:18 2012 -0500 Add IPv6 support to tor-resolve so it can hear about IPv6 answers --- src/tools/tor-resolve.c | 28 ++++++++++++++++------------ 1 files changed, 16 insertions(+), 12 deletions(-) diff --git a/src/tools/tor-resolve.c b/src/tools/tor-resolve.c index 4ef84f4..19a67fc 100644 --- a/src/tools/tor-resolve.c +++ b/src/tools/tor-resolve.c @@ -109,7 +109,7 @@ build_socks_resolve_request(char **out, static int parse_socks4a_resolve_response(const char *hostname, const char *response, size_t len, - uint32_t *addr_out) + tor_addr_t *addr_out) { uint8_t status; tor_assert(response); @@ -140,7 +140,7 @@ parse_socks4a_resolve_response(const char *hostname, return -1; } - *addr_out = ntohl(get_uint32(response+4)); + tor_addr_from_ipv4n(addr_out, get_uint32(response+4)); return 0; } @@ -179,7 +179,7 @@ socks5_reason_to_string(char reason) static int do_resolve(const char *hostname, uint32_t sockshost, uint16_t socksport, int reverse, int version, - uint32_t *result_addr, char **result_hostname) + tor_addr_t *result_addr, char **result_hostname) { int s; struct sockaddr_in socksaddr; @@ -190,7 +190,7 @@ do_resolve(const char *hostname, uint32_t sockshost, uint16_t socksport, tor_assert(result_addr); tor_assert(version == 4 || version == 5); - *result_addr = 0; + tor_addr_make_unspec(result_addr); *result_hostname = NULL; s = tor_open_socket(PF_INET,SOCK_STREAM,IPPROTO_TCP); @@ -255,7 +255,7 @@ do_resolve(const char *hostname, uint32_t sockshost, uint16_t socksport, return -1; } } else { - char reply_buf[4]; + char reply_buf[16]; if (read_all(s, reply_buf, 4, 1) != 4) { log_err(LD_NET, "Error reading SOCKS5 response."); return -1; @@ -284,8 +284,16 @@ do_resolve(const char *hostname, uint32_t sockshost, uint16_t socksport, log_err(LD_NET, "Error reading address in socks5 response."); return -1; } - *result_addr = ntohl(get_uint32(reply_buf)); + tor_addr_from_ipv4n(result_addr, get_uint32(reply_buf)); + } else if (reply_buf[3] == 4) { + /* IPv6 address */ + if (read_all(s, reply_buf, 16, 1) != 16) { + log_err(LD_NET, "Error reading address in socks5 response."); + return -1; + } + tor_addr_from_ipv6_bytes(result_addr, reply_buf); } else if (reply_buf[3] == 3) { + /* Domain name */ size_t result_len; if (read_all(s, reply_buf, 1, 1) != 1) { log_err(LD_NET, "Error reading address_length in socks5 response."); @@ -322,10 +330,8 @@ main(int argc, char **argv) int isSocks4 = 0, isVerbose = 0, isReverse = 0; char **arg; int n_args; - struct in_addr a; - uint32_t result = 0; + tor_addr_t result; char *result_hostname = NULL; - char buf[INET_NTOA_BUF_LEN]; log_severity_list_t *s = tor_malloc_zero(sizeof(log_severity_list_t)); init_logging(); @@ -423,9 +429,7 @@ main(int argc, char **argv) if (result_hostname) { printf("%s\n", result_hostname); } else { - a.s_addr = htonl(result); - tor_inet_ntoa(&a, buf, sizeof(buf)); - printf("%s\n", buf); + printf("%s\n", fmt_addr(&result)); } return 0; }

1 0

[tor/master] Initial support for AAAA requests on DNSPort.
by nickm＠torproject.org 15 Nov '12

15 Nov '12

commit d643487cc24c9f8d7c56cdf961a1e5598339538c Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Nov 14 22:29:08 2012 -0500 Initial support for AAAA requests on DNSPort. This is imperfect, since it sends back whatever we would send to a socks RESOLVE request, when in reality we should send back whatever was asked for. --- src/or/dnsserv.c | 9 +++++---- 1 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/or/dnsserv.c b/src/or/dnsserv.c index f5d430b..a211899 100644 --- a/src/or/dnsserv.c +++ b/src/or/dnsserv.c @@ -102,7 +102,7 @@ evdns_server_callback(struct evdns_server_request *req, void *data_) evdns_server_request_respond(req, DNS_ERR_NOTIMPL); return; } - if (q->type != EVDNS_TYPE_A) { + if (q->type != EVDNS_TYPE_A && q->type != EVDNS_TYPE_AAAA) { tor_assert(q->type == EVDNS_TYPE_PTR); } @@ -126,7 +126,7 @@ evdns_server_callback(struct evdns_server_request *req, void *data_) TO_CONN(conn)->port = port; TO_CONN(conn)->address = tor_dup_addr(&tor_addr); - if (q->type == EVDNS_TYPE_A) + if (q->type == EVDNS_TYPE_A || q->type == EVDNS_TYPE_AAAA) entry_conn->socks_request->command = SOCKS_COMMAND_RESOLVE; else entry_conn->socks_request->command = SOCKS_COMMAND_RESOLVE_PTR; @@ -290,8 +290,9 @@ dnsserv_resolved(entry_connection_t *conn, * or more of the questions in the request); then, call * evdns_server_request_respond. */ if (answer_type == RESOLVED_TYPE_IPV6) { - log_info(LD_APP, "Got an IPv6 answer; that's not implemented."); - err = DNS_ERR_NOTIMPL; + evdns_server_request_add_aaaa_reply(req, + name, + 1, answer, ttl); } else if (answer_type == RESOLVED_TYPE_IPV4 && answer_len == 4 && conn->socks_request->command == SOCKS_COMMAND_RESOLVE) { evdns_server_request_add_a_reply(req,

1 0

[tor/master] Add another missing function doc
by nickm＠torproject.org 15 Nov '12

15 Nov '12

commit e3ceac38d9d7b731abe5605d13735ee051eff623 Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Nov 14 22:55:23 2012 -0500 Add another missing function doc --- src/or/relay.c | 6 +++++- 1 files changed, 5 insertions(+), 1 deletions(-) diff --git a/src/or/relay.c b/src/or/relay.c index 79eb919..d862e58 100644 --- a/src/or/relay.c +++ b/src/or/relay.c @@ -858,7 +858,11 @@ remap_event_helper(entry_connection_t *conn, const tor_addr_t *new_addr) REMAP_STREAM_SOURCE_EXIT); } -/**DOCDOC*/ +/** Extract the contents of a connected cell in cell, whose relay + * header has already been parsed into rh. On success, set + * addr_out to the address we're connected to, and ttl_out to + * the ttl of that address, in seconds, and return 0. On failure, return + * -1. */ int connected_cell_parse(const relay_header_t *rh, const cell_t *cell, tor_addr_t *addr_out, int *ttl_out)

1 0

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits November 2012