1 /* Copyright (c) 2001 Matej Pfajfar.
2 * Copyright (c) 2001-2004, Roger Dingledine.
3 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
4 * Copyright (c) 2007-2011, The Tor Project, Inc. */
5 /* See LICENSE for licensing information */
8 * \file connection_edge.c
9 * \brief Handle edge streams.
14 #ifdef HAVE_LINUX_TYPES_H
15 #include <linux/types.h>
17 #ifdef HAVE_LINUX_NETFILTER_IPV4_H
18 #include <linux/netfilter_ipv4.h>
19 #define TRANS_NETFILTER
22 #if defined(HAVE_NET_IF_H) && defined(HAVE_NET_PFVAR_H)
24 #include <net/pfvar.h>
28 #define SOCKS4_GRANTED 90
29 #define SOCKS4_REJECT 91
31 static int connection_ap_handshake_process_socks(edge_connection_t
*conn
);
32 static int connection_ap_process_natd(edge_connection_t
*conn
);
33 static int connection_exit_connect_dir(edge_connection_t
*exitconn
);
34 static int address_is_in_virtual_range(const char *addr
);
35 static int consider_plaintext_ports(edge_connection_t
*conn
, uint16_t port
);
36 static void clear_trackexithost_mappings(const char *exitname
);
38 /** An AP stream has failed/finished. If it hasn't already sent back
39 * a socks reply, send one now (based on endreason). Also set
40 * has_sent_end to 1, and mark the conn.
43 _connection_mark_unattached_ap(edge_connection_t
*conn
, int endreason
,
44 int line
, const char *file
)
46 tor_assert(conn
->_base
.type
== CONN_TYPE_AP
);
47 conn
->edge_has_sent_end
= 1; /* no circ yet */
49 if (conn
->_base
.marked_for_close
) {
50 /* This call will warn as appropriate. */
51 _connection_mark_for_close(TO_CONN(conn
), line
, file
);
55 if (!conn
->socks_request
->has_finished
) {
56 if (endreason
& END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED
)
58 "stream (marked at %s:%d) sending two socks replies?",
61 if (SOCKS_COMMAND_IS_CONNECT(conn
->socks_request
->command
))
62 connection_ap_handshake_socks_reply(conn
, NULL
, 0, endreason
);
63 else if (SOCKS_COMMAND_IS_RESOLVE(conn
->socks_request
->command
))
64 connection_ap_handshake_socks_resolved(conn
,
65 RESOLVED_TYPE_ERROR_TRANSIENT
,
67 else /* unknown or no handshake at all. send no response. */
68 conn
->socks_request
->has_finished
= 1;
71 _connection_mark_for_close(TO_CONN(conn
), line
, file
);
72 conn
->_base
.hold_open_until_flushed
= 1;
73 conn
->end_reason
= endreason
;
76 /** There was an EOF. Send an end and mark the connection for close.
79 connection_edge_reached_eof(edge_connection_t
*conn
)
81 if (buf_datalen(conn
->_base
.inbuf
) &&
82 connection_state_is_open(TO_CONN(conn
))) {
83 /* it still has stuff to process. don't let it die yet. */
86 log_info(LD_EDGE
,"conn (fd %d) reached eof. Closing.", conn
->_base
.s
);
87 if (!conn
->_base
.marked_for_close
) {
88 /* only mark it if not already marked. it's possible to
89 * get the 'end' right around when the client hangs up on us. */
90 connection_edge_end(conn
, END_STREAM_REASON_DONE
);
91 if (conn
->socks_request
) /* eof, so don't send a socks reply back */
92 conn
->socks_request
->has_finished
= 1;
93 connection_mark_for_close(TO_CONN(conn
));
98 /** Handle new bytes on conn->inbuf based on state:
99 * - If it's waiting for socks info, try to read another step of the
100 * socks handshake out of conn->inbuf.
101 * - If it's waiting for the original destination, fetch it.
102 * - If it's open, then package more relay cells from the stream.
103 * - Else, leave the bytes on inbuf alone for now.
105 * Mark and return -1 if there was an unexpected error with the conn,
109 connection_edge_process_inbuf(edge_connection_t
*conn
, int package_partial
)
113 switch (conn
->_base
.state
) {
114 case AP_CONN_STATE_SOCKS_WAIT
:
115 if (connection_ap_handshake_process_socks(conn
) < 0) {
120 case AP_CONN_STATE_NATD_WAIT
:
121 if (connection_ap_process_natd(conn
) < 0) {
126 case AP_CONN_STATE_OPEN
:
127 case EXIT_CONN_STATE_OPEN
:
128 if (connection_edge_package_raw_inbuf(conn
, package_partial
) < 0) {
129 /* (We already sent an end cell if possible) */
130 connection_mark_for_close(TO_CONN(conn
));
134 case EXIT_CONN_STATE_CONNECTING
:
135 case AP_CONN_STATE_RENDDESC_WAIT
:
136 case AP_CONN_STATE_CIRCUIT_WAIT
:
137 case AP_CONN_STATE_CONNECT_WAIT
:
138 case AP_CONN_STATE_RESOLVE_WAIT
:
139 case AP_CONN_STATE_CONTROLLER_WAIT
:
141 "data from edge while in '%s' state. Leaving it on buffer.",
142 conn_state_to_string(conn
->_base
.type
, conn
->_base
.state
));
145 log_warn(LD_BUG
,"Got unexpected state %d. Closing.",conn
->_base
.state
);
146 tor_fragile_assert();
147 connection_edge_end(conn
, END_STREAM_REASON_INTERNAL
);
148 connection_mark_for_close(TO_CONN(conn
));
152 /** This edge needs to be closed, because its circuit has closed.
153 * Mark it for close and return 0.
156 connection_edge_destroy(circid_t circ_id
, edge_connection_t
*conn
)
158 if (!conn
->_base
.marked_for_close
) {
160 "CircID %d: At an edge. Marking connection for close.", circ_id
);
161 if (conn
->_base
.type
== CONN_TYPE_AP
) {
162 connection_mark_unattached_ap(conn
, END_STREAM_REASON_DESTROY
);
163 control_event_stream_bandwidth(conn
);
164 control_event_stream_status(conn
, STREAM_EVENT_CLOSED
,
165 END_STREAM_REASON_DESTROY
);
166 conn
->end_reason
|= END_STREAM_REASON_FLAG_ALREADY_SENT_CLOSED
;
168 /* closing the circuit, nothing to send an END to */
169 conn
->edge_has_sent_end
= 1;
170 conn
->end_reason
= END_STREAM_REASON_DESTROY
;
171 conn
->end_reason
|= END_STREAM_REASON_FLAG_ALREADY_SENT_CLOSED
;
172 connection_mark_for_close(TO_CONN(conn
));
173 conn
->_base
.hold_open_until_flushed
= 1;
176 conn
->cpath_layer
= NULL
;
177 conn
->on_circuit
= NULL
;
181 /** Send a raw end cell to the stream with ID <b>stream_id</b> out over the
182 * <b>circ</b> towards the hop identified with <b>cpath_layer</b>. If this
183 * is not a client connection, set the relay end cell's reason for closing
184 * as <b>reason</b> */
186 relay_send_end_cell_from_edge(streamid_t stream_id
, circuit_t
*circ
,
187 uint8_t reason
, crypt_path_t
*cpath_layer
)
191 if (CIRCUIT_PURPOSE_IS_CLIENT(circ
->purpose
)) {
192 /* Never send the server an informative reason code; it doesn't need to
193 * know why the client stream is failing. */
194 reason
= END_STREAM_REASON_MISC
;
197 payload
[0] = (char) reason
;
199 return relay_send_command_from_edge(stream_id
, circ
, RELAY_COMMAND_END
,
200 payload
, 1, cpath_layer
);
203 /** Send a relay end cell from stream <b>conn</b> down conn's circuit, and
204 * remember that we've done so. If this is not a client connection, set the
205 * relay end cell's reason for closing as <b>reason</b>.
207 * Return -1 if this function has already been called on this conn,
211 connection_edge_end(edge_connection_t
*conn
, uint8_t reason
)
213 char payload
[RELAY_PAYLOAD_SIZE
];
214 size_t payload_len
=1;
216 uint8_t control_reason
= reason
;
218 if (conn
->edge_has_sent_end
) {
219 log_warn(LD_BUG
,"(Harmless.) Calling connection_edge_end (reason %d) "
220 "on an already ended stream?", reason
);
221 tor_fragile_assert();
225 if (conn
->_base
.marked_for_close
) {
227 "called on conn that's already marked for close at %s:%d.",
228 conn
->_base
.marked_for_close_file
, conn
->_base
.marked_for_close
);
232 circ
= circuit_get_by_edge_conn(conn
);
233 if (circ
&& CIRCUIT_PURPOSE_IS_CLIENT(circ
->purpose
)) {
234 /* If this is a client circuit, don't send the server an informative
235 * reason code; it doesn't need to know why the client stream is
237 reason
= END_STREAM_REASON_MISC
;
240 payload
[0] = (char)reason
;
241 if (reason
== END_STREAM_REASON_EXITPOLICY
&&
242 !connection_edge_is_rendezvous_stream(conn
)) {
244 if (tor_addr_family(&conn
->_base
.addr
) == AF_INET
) {
245 set_uint32(payload
+1, tor_addr_to_ipv4n(&conn
->_base
.addr
));
248 memcpy(payload
+1, tor_addr_to_in6_addr8(&conn
->_base
.addr
), 16);
251 set_uint32(payload
+1+addrlen
, htonl(dns_clip_ttl(conn
->address_ttl
)));
252 payload_len
+= 4+addrlen
;
255 if (circ
&& !circ
->marked_for_close
) {
256 log_debug(LD_EDGE
,"Sending end on conn (fd %d).",conn
->_base
.s
);
257 connection_edge_send_command(conn
, RELAY_COMMAND_END
,
258 payload
, payload_len
);
260 log_debug(LD_EDGE
,"No circ to send end on conn (fd %d).",
264 conn
->edge_has_sent_end
= 1;
265 conn
->end_reason
= control_reason
;
269 /** An error has just occurred on an operation on an edge connection
270 * <b>conn</b>. Extract the errno; convert it to an end reason, and send an
271 * appropriate relay end cell to the other end of the connection's circuit.
274 connection_edge_end_errno(edge_connection_t
*conn
)
278 reason
= errno_to_stream_end_reason(tor_socket_errno(conn
->_base
.s
));
279 return connection_edge_end(conn
, reason
);
282 /** Connection <b>conn</b> has finished writing and has no bytes left on
285 * If it's in state 'open', stop writing, consider responding with a
286 * sendme, and return.
287 * Otherwise, stop writing and return.
289 * If <b>conn</b> is broken, mark it for close and return -1, else
293 connection_edge_finished_flushing(edge_connection_t
*conn
)
297 switch (conn
->_base
.state
) {
298 case AP_CONN_STATE_OPEN
:
299 case EXIT_CONN_STATE_OPEN
:
300 connection_stop_writing(TO_CONN(conn
));
301 connection_edge_consider_sending_sendme(conn
);
303 case AP_CONN_STATE_SOCKS_WAIT
:
304 case AP_CONN_STATE_NATD_WAIT
:
305 case AP_CONN_STATE_RENDDESC_WAIT
:
306 case AP_CONN_STATE_CIRCUIT_WAIT
:
307 case AP_CONN_STATE_CONNECT_WAIT
:
308 case AP_CONN_STATE_CONTROLLER_WAIT
:
309 connection_stop_writing(TO_CONN(conn
));
312 log_warn(LD_BUG
, "Called in unexpected state %d.",conn
->_base
.state
);
313 tor_fragile_assert();
319 /** Connected handler for exit connections: start writing pending
320 * data, deliver 'CONNECTED' relay cells as appropriate, and check
321 * any pending data that may have been received. */
323 connection_edge_finished_connecting(edge_connection_t
*edge_conn
)
327 tor_assert(edge_conn
);
328 tor_assert(edge_conn
->_base
.type
== CONN_TYPE_EXIT
);
329 conn
= TO_CONN(edge_conn
);
330 tor_assert(conn
->state
== EXIT_CONN_STATE_CONNECTING
);
332 log_info(LD_EXIT
,"Exit connection to %s:%u (%s) established.",
333 escaped_safe_str(conn
->address
),conn
->port
,
334 safe_str(fmt_addr(&conn
->addr
)));
336 conn
->state
= EXIT_CONN_STATE_OPEN
;
337 connection_watch_events(conn
, EV_READ
); /* stop writing, continue reading */
338 if (connection_wants_to_flush(conn
)) /* in case there are any queued relay
340 connection_start_writing(conn
);
341 /* deliver a 'connected' relay cell back through the circuit. */
342 if (connection_edge_is_rendezvous_stream(edge_conn
)) {
343 if (connection_edge_send_command(edge_conn
,
344 RELAY_COMMAND_CONNECTED
, NULL
, 0) < 0)
345 return 0; /* circuit is closed, don't continue */
347 char connected_payload
[20];
348 int connected_payload_len
;
349 if (tor_addr_family(&conn
->addr
) == AF_INET
) {
350 set_uint32(connected_payload
, tor_addr_to_ipv4n(&conn
->addr
));
351 set_uint32(connected_payload
+4,
352 htonl(dns_clip_ttl(edge_conn
->address_ttl
)));
353 connected_payload_len
= 8;
355 memcpy(connected_payload
, tor_addr_to_in6_addr8(&conn
->addr
), 16);
356 set_uint32(connected_payload
+16,
357 htonl(dns_clip_ttl(edge_conn
->address_ttl
)));
358 connected_payload_len
= 20;
360 if (connection_edge_send_command(edge_conn
,
361 RELAY_COMMAND_CONNECTED
,
362 connected_payload
, connected_payload_len
) < 0)
363 return 0; /* circuit is closed, don't continue */
365 tor_assert(edge_conn
->package_window
> 0);
366 /* in case the server has written anything */
367 return connection_edge_process_inbuf(edge_conn
, 1);
370 /** Define a schedule for how long to wait between retrying
371 * application connections. Rather than waiting a fixed amount of
372 * time between each retry, we wait 10 seconds each for the first
373 * two tries, and 15 seconds for each retry after
374 * that. Hopefully this will improve the expected user experience. */
376 compute_retry_timeout(edge_connection_t
*conn
)
378 if (conn
->num_socks_retries
< 2) /* try 0 and try 1 */
383 /** Find all general-purpose AP streams waiting for a response that sent their
384 * begin/resolve cell >=15 seconds ago. Detach from their current circuit, and
385 * mark their current circuit as unsuitable for new streams. Then call
386 * connection_ap_handshake_attach_circuit() to attach to a new circuit (if
387 * available) or launch a new one.
389 * For rendezvous streams, simply give up after SocksTimeout seconds (with no
393 connection_ap_expire_beginning(void)
395 edge_connection_t
*conn
;
397 time_t now
= time(NULL
);
398 or_options_t
*options
= get_options();
401 int seconds_idle
, seconds_since_born
;
402 smartlist_t
*conns
= get_connection_array();
404 SMARTLIST_FOREACH_BEGIN(conns
, connection_t
*, c
) {
405 if (c
->type
!= CONN_TYPE_AP
|| c
->marked_for_close
)
407 conn
= TO_EDGE_CONN(c
);
408 /* if it's an internal linked connection, don't yell its status. */
409 severity
= (tor_addr_is_null(&conn
->_base
.addr
) && !conn
->_base
.port
)
410 ? LOG_INFO
: LOG_NOTICE
;
411 seconds_idle
= (int)( now
- conn
->_base
.timestamp_lastread
);
412 seconds_since_born
= (int)( now
- conn
->_base
.timestamp_created
);
414 if (conn
->_base
.state
== AP_CONN_STATE_OPEN
)
417 /* We already consider SocksTimeout in
418 * connection_ap_handshake_attach_circuit(), but we need to consider
419 * it here too because controllers that put streams in controller_wait
420 * state never ask Tor to attach the circuit. */
421 if (AP_CONN_STATE_IS_UNATTACHED(conn
->_base
.state
)) {
422 if (seconds_since_born
>= options
->SocksTimeout
) {
423 log_fn(severity
, LD_APP
,
424 "Tried for %d seconds to get a connection to %s:%d. "
426 seconds_since_born
, safe_str(conn
->socks_request
->address
),
427 conn
->socks_request
->port
,
428 conn_state_to_string(CONN_TYPE_AP
, conn
->_base
.state
));
429 connection_mark_unattached_ap(conn
, END_STREAM_REASON_TIMEOUT
);
434 /* We're in state connect_wait or resolve_wait now -- waiting for a
435 * reply to our relay cell. See if we want to retry/give up. */
437 cutoff
= compute_retry_timeout(conn
);
438 if (seconds_idle
< cutoff
)
440 circ
= circuit_get_by_edge_conn(conn
);
441 if (!circ
) { /* it's vanished? */
442 log_info(LD_APP
,"Conn is waiting (address %s), but lost its circ.",
443 safe_str(conn
->socks_request
->address
));
444 connection_mark_unattached_ap(conn
, END_STREAM_REASON_TIMEOUT
);
447 if (circ
->purpose
== CIRCUIT_PURPOSE_C_REND_JOINED
) {
448 if (seconds_idle
>= options
->SocksTimeout
) {
449 log_fn(severity
, LD_REND
,
450 "Rend stream is %d seconds late. Giving up on address"
453 safe_str(conn
->socks_request
->address
));
454 connection_edge_end(conn
, END_STREAM_REASON_TIMEOUT
);
455 connection_mark_unattached_ap(conn
, END_STREAM_REASON_TIMEOUT
);
459 tor_assert(circ
->purpose
== CIRCUIT_PURPOSE_C_GENERAL
);
460 log_fn(cutoff
< 15 ? LOG_INFO
: severity
, LD_APP
,
461 "We tried for %d seconds to connect to '%s' using exit '%s'."
462 " Retrying on a new circuit.",
463 seconds_idle
, safe_str(conn
->socks_request
->address
),
465 conn
->cpath_layer
->extend_info
->nickname
: "*unnamed*");
466 /* send an end down the circuit */
467 connection_edge_end(conn
, END_STREAM_REASON_TIMEOUT
);
468 /* un-mark it as ending, since we're going to reuse it */
469 conn
->edge_has_sent_end
= 0;
470 conn
->end_reason
= 0;
471 /* kludge to make us not try this circuit again, yet to allow
472 * current streams on it to survive if they can: make it
473 * unattractive to use for new streams */
474 tor_assert(circ
->timestamp_dirty
);
475 circ
->timestamp_dirty
-= options
->MaxCircuitDirtiness
;
476 /* give our stream another 'cutoff' seconds to try */
477 conn
->_base
.timestamp_lastread
+= cutoff
;
478 if (conn
->num_socks_retries
< 250) /* avoid overflow */
479 conn
->num_socks_retries
++;
480 /* move it back into 'pending' state, and try to attach. */
481 if (connection_ap_detach_retriable(conn
, TO_ORIGIN_CIRCUIT(circ
),
482 END_STREAM_REASON_TIMEOUT
)<0) {
483 if (!conn
->_base
.marked_for_close
)
484 connection_mark_unattached_ap(conn
, END_STREAM_REASON_CANT_ATTACH
);
486 } SMARTLIST_FOREACH_END(conn
);
489 /** Tell any AP streams that are waiting for a new circuit to try again,
490 * either attaching to an available circ or launching a new one.
493 connection_ap_attach_pending(void)
495 edge_connection_t
*edge_conn
;
496 smartlist_t
*conns
= get_connection_array();
497 SMARTLIST_FOREACH(conns
, connection_t
*, conn
,
499 if (conn
->marked_for_close
||
500 conn
->type
!= CONN_TYPE_AP
||
501 conn
->state
!= AP_CONN_STATE_CIRCUIT_WAIT
)
503 edge_conn
= TO_EDGE_CONN(conn
);
504 if (connection_ap_handshake_attach_circuit(edge_conn
) < 0) {
505 if (!edge_conn
->_base
.marked_for_close
)
506 connection_mark_unattached_ap(edge_conn
,
507 END_STREAM_REASON_CANT_ATTACH
);
512 /** Tell any AP streams that are waiting for a one-hop tunnel to
513 * <b>failed_digest</b> that they are going to fail. */
514 /* XXX022 We should get rid of this function, and instead attach
515 * one-hop streams to circ->p_streams so they get marked in
516 * circuit_mark_for_close like normal p_streams. */
518 connection_ap_fail_onehop(const char *failed_digest
,
519 cpath_build_state_t
*build_state
)
521 edge_connection_t
*edge_conn
;
522 char digest
[DIGEST_LEN
];
523 smartlist_t
*conns
= get_connection_array();
524 SMARTLIST_FOREACH_BEGIN(conns
, connection_t
*, conn
) {
525 if (conn
->marked_for_close
||
526 conn
->type
!= CONN_TYPE_AP
||
527 conn
->state
!= AP_CONN_STATE_CIRCUIT_WAIT
)
529 edge_conn
= TO_EDGE_CONN(conn
);
530 if (!edge_conn
->want_onehop
)
532 if (hexdigest_to_digest(edge_conn
->chosen_exit_name
, digest
) < 0 ||
533 tor_memneq(digest
, failed_digest
, DIGEST_LEN
))
535 if (tor_digest_is_zero(digest
)) {
536 /* we don't know the digest; have to compare addr:port */
538 if (!build_state
|| !build_state
->chosen_exit
||
539 !edge_conn
->socks_request
|| !edge_conn
->socks_request
->address
)
541 if (tor_addr_from_str(&addr
, edge_conn
->socks_request
->address
)<0 ||
542 !tor_addr_eq(&build_state
->chosen_exit
->addr
, &addr
) ||
543 build_state
->chosen_exit
->port
!= edge_conn
->socks_request
->port
)
546 log_info(LD_APP
, "Closing one-hop stream to '%s/%s' because the OR conn "
547 "just failed.", edge_conn
->chosen_exit_name
,
548 edge_conn
->socks_request
->address
);
549 connection_mark_unattached_ap(edge_conn
, END_STREAM_REASON_TIMEOUT
);
550 } SMARTLIST_FOREACH_END(conn
);
553 /** A circuit failed to finish on its last hop <b>info</b>. If there
554 * are any streams waiting with this exit node in mind, but they
555 * don't absolutely require it, make them give up on it.
558 circuit_discard_optional_exit_enclaves(extend_info_t
*info
)
560 edge_connection_t
*edge_conn
;
561 routerinfo_t
*r1
, *r2
;
563 smartlist_t
*conns
= get_connection_array();
564 SMARTLIST_FOREACH_BEGIN(conns
, connection_t
*, conn
) {
565 if (conn
->marked_for_close
||
566 conn
->type
!= CONN_TYPE_AP
||
567 conn
->state
!= AP_CONN_STATE_CIRCUIT_WAIT
)
569 edge_conn
= TO_EDGE_CONN(conn
);
570 if (!edge_conn
->chosen_exit_optional
&&
571 !edge_conn
->chosen_exit_retries
)
573 r1
= router_get_by_nickname(edge_conn
->chosen_exit_name
, 0);
574 r2
= router_get_by_digest(info
->identity_digest
);
575 if (!r1
|| !r2
|| r1
!= r2
)
577 tor_assert(edge_conn
->socks_request
);
578 if (edge_conn
->chosen_exit_optional
) {
579 log_info(LD_APP
, "Giving up on enclave exit '%s' for destination %s.",
580 safe_str(edge_conn
->chosen_exit_name
),
581 escaped_safe_str(edge_conn
->socks_request
->address
));
582 edge_conn
->chosen_exit_optional
= 0;
583 tor_free(edge_conn
->chosen_exit_name
); /* clears it */
584 /* if this port is dangerous, warn or reject it now that we don't
585 * think it'll be using an enclave. */
586 consider_plaintext_ports(edge_conn
, edge_conn
->socks_request
->port
);
588 if (edge_conn
->chosen_exit_retries
) {
589 if (--edge_conn
->chosen_exit_retries
== 0) { /* give up! */
590 clear_trackexithost_mappings(edge_conn
->chosen_exit_name
);
591 tor_free(edge_conn
->chosen_exit_name
); /* clears it */
592 /* if this port is dangerous, warn or reject it now that we don't
593 * think it'll be using an enclave. */
594 consider_plaintext_ports(edge_conn
, edge_conn
->socks_request
->port
);
597 } SMARTLIST_FOREACH_END(conn
);
600 /** The AP connection <b>conn</b> has just failed while attaching or
601 * sending a BEGIN or resolving on <b>circ</b>, but another circuit
602 * might work. Detach the circuit, and either reattach it, launch a
603 * new circuit, tell the controller, or give up as a appropriate.
605 * Returns -1 on err, 1 on success, 0 on not-yet-sure.
608 connection_ap_detach_retriable(edge_connection_t
*conn
, origin_circuit_t
*circ
,
611 control_event_stream_status(conn
, STREAM_EVENT_FAILED_RETRIABLE
, reason
);
612 conn
->_base
.timestamp_lastread
= time(NULL
);
613 if (!get_options()->LeaveStreamsUnattached
|| conn
->use_begindir
) {
614 /* If we're attaching streams ourself, or if this connection is
615 * a tunneled directory connection, then just attach it. */
616 conn
->_base
.state
= AP_CONN_STATE_CIRCUIT_WAIT
;
617 circuit_detach_stream(TO_CIRCUIT(circ
),conn
);
618 return connection_ap_handshake_attach_circuit(conn
);
620 conn
->_base
.state
= AP_CONN_STATE_CONTROLLER_WAIT
;
621 circuit_detach_stream(TO_CIRCUIT(circ
),conn
);
626 /** A client-side struct to remember requests to rewrite addresses
627 * to new addresses. These structs are stored in the hash table
628 * "addressmap" below.
630 * There are 5 ways to set an address mapping:
631 * - A MapAddress command from the controller [permanent]
632 * - An AddressMap directive in the torrc [permanent]
633 * - When a TrackHostExits torrc directive is triggered [temporary]
634 * - When a DNS resolve succeeds [temporary]
635 * - When a DNS resolve fails [temporary]
637 * When an addressmap request is made but one is already registered,
638 * the new one is replaced only if the currently registered one has
639 * no "new_address" (that is, it's in the process of DNS resolve),
640 * or if the new one is permanent (expires==0 or 1).
642 * (We overload the 'expires' field, using "0" for mappings set via
643 * the configuration file, "1" for mappings set from the control
644 * interface, and other values for DNS and TrackHostExit mappings that can
650 addressmap_entry_source_t source
:3;
651 short num_resolve_failures
;
652 } addressmap_entry_t
;
654 /** Entry for mapping addresses to which virtual address we mapped them to. */
657 char *hostname_address
;
658 } virtaddress_entry_t
;
660 /** A hash table to store client-side address rewrite instructions. */
661 static strmap_t
*addressmap
=NULL
;
663 * Table mapping addresses to which virtual address, if any, we
666 * We maintain the following invariant: if [A,B] is in
667 * virtaddress_reversemap, then B must be a virtual address, and [A,B]
668 * must be in addressmap. We do not require that the converse hold:
669 * if it fails, then we could end up mapping two virtual addresses to
670 * the same address, which is no disaster.
672 static strmap_t
*virtaddress_reversemap
=NULL
;
674 /** Initialize addressmap. */
676 addressmap_init(void)
678 addressmap
= strmap_new();
679 virtaddress_reversemap
= strmap_new();
682 /** Free the memory associated with the addressmap entry <b>_ent</b>. */
684 addressmap_ent_free(void *_ent
)
686 addressmap_entry_t
*ent
= _ent
;
687 tor_free(ent
->new_address
);
691 /** Free storage held by a virtaddress_entry_t* entry in <b>ent</b>. */
693 addressmap_virtaddress_ent_free(void *_ent
)
695 virtaddress_entry_t
*ent
= _ent
;
696 tor_free(ent
->ipv4_address
);
697 tor_free(ent
->hostname_address
);
701 /** Free storage held by a virtaddress_entry_t* entry in <b>ent</b>. */
703 addressmap_virtaddress_remove(const char *address
, addressmap_entry_t
*ent
)
705 if (ent
&& ent
->new_address
&&
706 address_is_in_virtual_range(ent
->new_address
)) {
707 virtaddress_entry_t
*ve
=
708 strmap_get(virtaddress_reversemap
, ent
->new_address
);
709 /*log_fn(LOG_NOTICE,"remove reverse mapping for %s",ent->new_address);*/
711 if (!strcmp(address
, ve
->ipv4_address
))
712 tor_free(ve
->ipv4_address
);
713 if (!strcmp(address
, ve
->hostname_address
))
714 tor_free(ve
->hostname_address
);
715 if (!ve
->ipv4_address
&& !ve
->hostname_address
) {
717 strmap_remove(virtaddress_reversemap
, ent
->new_address
);
723 /** Remove <b>ent</b> (which must be mapped to by <b>address</b>) from the
724 * client address maps. */
726 addressmap_ent_remove(const char *address
, addressmap_entry_t
*ent
)
728 addressmap_virtaddress_remove(address
, ent
);
729 addressmap_ent_free(ent
);
732 /** Unregister all TrackHostExits mappings from any address to
733 * *.exitname.exit. */
735 clear_trackexithost_mappings(const char *exitname
)
739 if (!addressmap
|| !exitname
)
741 suffix_len
= strlen(exitname
) + 16;
742 suffix
= tor_malloc(suffix_len
);
743 tor_snprintf(suffix
, suffix_len
, ".%s.exit", exitname
);
744 tor_strlower(suffix
);
746 STRMAP_FOREACH_MODIFY(addressmap
, address
, addressmap_entry_t
*, ent
) {
747 if (ent
->source
== ADDRMAPSRC_TRACKEXIT
&& !strcmpend(address
, suffix
)) {
748 addressmap_ent_remove(address
, ent
);
749 MAP_DEL_CURRENT(address
);
751 } STRMAP_FOREACH_END
;
756 /** Remove all entries from the addressmap that were set via the
757 * configuration file or the command line. */
759 addressmap_clear_configured(void)
761 addressmap_get_mappings(NULL
, 0, 0, 0);
764 /** Remove all entries from the addressmap that are set to expire, ever. */
766 addressmap_clear_transient(void)
768 addressmap_get_mappings(NULL
, 2, TIME_MAX
, 0);
771 /** Clean out entries from the addressmap cache that were
772 * added long enough ago that they are no longer valid.
775 addressmap_clean(time_t now
)
777 addressmap_get_mappings(NULL
, 2, now
, 0);
780 /** Free all the elements in the addressmap, and free the addressmap
783 addressmap_free_all(void)
786 strmap_free(addressmap
, addressmap_ent_free
);
789 if (virtaddress_reversemap
) {
790 strmap_free(virtaddress_reversemap
, addressmap_virtaddress_ent_free
);
791 virtaddress_reversemap
= NULL
;
795 /** Look at address, and rewrite it until it doesn't want any
796 * more rewrites; but don't get into an infinite loop.
797 * Don't write more than maxlen chars into address. Return true if the
798 * address changed; false otherwise. Set *<b>expires_out</b> to the
799 * expiry time of the result, or to <b>time_max</b> if the result does
803 addressmap_rewrite(char *address
, size_t maxlen
, time_t *expires_out
)
805 addressmap_entry_t
*ent
;
808 time_t expires
= TIME_MAX
;
810 for (rewrites
= 0; rewrites
< 16; rewrites
++) {
811 ent
= strmap_get(addressmap
, address
);
813 if (!ent
|| !ent
->new_address
) {
815 *expires_out
= expires
;
816 return (rewrites
> 0); /* done, no rewrite needed */
819 cp
= tor_strdup(escaped_safe_str(ent
->new_address
));
820 log_info(LD_APP
, "Addressmap: rewriting %s to %s",
821 escaped_safe_str(address
), cp
);
822 if (ent
->expires
> 1 && ent
->expires
< expires
)
823 expires
= ent
->expires
;
825 strlcpy(address
, ent
->new_address
, maxlen
);
828 "Loop detected: we've rewritten %s 16 times! Using it as-is.",
829 escaped_safe_str(address
));
830 /* it's fine to rewrite a rewrite, but don't loop forever */
832 *expires_out
= TIME_MAX
;
836 /** If we have a cached reverse DNS entry for the address stored in the
837 * <b>maxlen</b>-byte buffer <b>address</b> (typically, a dotted quad) then
838 * rewrite to the cached value and return 1. Otherwise return 0. Set
839 * *<b>expires_out</b> to the expiry time of the result, or to <b>time_max</b>
840 * if the result does not expire. */
842 addressmap_rewrite_reverse(char *address
, size_t maxlen
, time_t *expires_out
)
844 size_t len
= maxlen
+ 16;
845 char *s
= tor_malloc(len
), *cp
;
846 addressmap_entry_t
*ent
;
848 tor_snprintf(s
, len
, "REVERSE[%s]", address
);
849 ent
= strmap_get(addressmap
, s
);
851 cp
= tor_strdup(escaped_safe_str(ent
->new_address
));
852 log_info(LD_APP
, "Rewrote reverse lookup %s -> %s",
853 escaped_safe_str(s
), cp
);
855 strlcpy(address
, ent
->new_address
, maxlen
);
860 *expires_out
= (ent
&& ent
->expires
> 1) ? ent
->expires
: TIME_MAX
;
866 /** Return 1 if <b>address</b> is already registered, else return 0. If address
867 * is already registered, and <b>update_expires</b> is non-zero, then update
868 * the expiry time on the mapping with update_expires if it is a
869 * mapping created by TrackHostExits. */
871 addressmap_have_mapping(const char *address
, int update_expiry
)
873 addressmap_entry_t
*ent
;
874 if (!(ent
=strmap_get_lc(addressmap
, address
)))
876 if (update_expiry
&& ent
->source
==ADDRMAPSRC_TRACKEXIT
)
877 ent
->expires
=time(NULL
) + update_expiry
;
881 /** Register a request to map <b>address</b> to <b>new_address</b>,
882 * which will expire on <b>expires</b> (or 0 if never expires from
883 * config file, 1 if never expires from controller, 2 if never expires
884 * (virtual address mapping) from the controller.)
886 * <b>new_address</b> should be a newly dup'ed string, which we'll use or
887 * free as appropriate. We will leave address alone.
889 * If <b>new_address</b> is NULL, or equal to <b>address</b>, remove
890 * any mappings that exist from <b>address</b>.
893 addressmap_register(const char *address
, char *new_address
, time_t expires
,
894 addressmap_entry_source_t source
)
896 addressmap_entry_t
*ent
;
898 ent
= strmap_get(addressmap
, address
);
899 if (!new_address
|| !strcasecmp(address
,new_address
)) {
900 /* Remove the mapping, if any. */
901 tor_free(new_address
);
903 addressmap_ent_remove(address
,ent
);
904 strmap_remove(addressmap
, address
);
908 if (!ent
) { /* make a new one and register it */
909 ent
= tor_malloc_zero(sizeof(addressmap_entry_t
));
910 strmap_set(addressmap
, address
, ent
);
911 } else if (ent
->new_address
) { /* we need to clean up the old mapping. */
913 log_info(LD_APP
,"Temporary addressmap ('%s' to '%s') not performed, "
914 "since it's already mapped to '%s'",
915 safe_str(address
), safe_str(new_address
), safe_str(ent
->new_address
));
916 tor_free(new_address
);
919 if (address_is_in_virtual_range(ent
->new_address
) &&
921 /* XXX This isn't the perfect test; we want to avoid removing
922 * mappings set from the control interface _as virtual mapping */
923 addressmap_virtaddress_remove(address
, ent
);
925 tor_free(ent
->new_address
);
926 } /* else { we have an in-progress resolve with no mapping. } */
928 ent
->new_address
= new_address
;
929 ent
->expires
= expires
==2 ? 1 : expires
;
930 ent
->num_resolve_failures
= 0;
931 ent
->source
= source
;
933 log_info(LD_CONFIG
, "Addressmap: (re)mapped '%s' to '%s'",
934 safe_str(address
), safe_str(ent
->new_address
));
935 control_event_address_mapped(address
, ent
->new_address
, expires
, NULL
);
938 /** An attempt to resolve <b>address</b> failed at some OR.
939 * Increment the number of resolve failures we have on record
940 * for it, and then return that number.
943 client_dns_incr_failures(const char *address
)
945 addressmap_entry_t
*ent
= strmap_get(addressmap
, address
);
947 ent
= tor_malloc_zero(sizeof(addressmap_entry_t
));
948 ent
->expires
= time(NULL
) + MAX_DNS_ENTRY_AGE
;
949 strmap_set(addressmap
,address
,ent
);
951 if (ent
->num_resolve_failures
< SHORT_MAX
)
952 ++ent
->num_resolve_failures
; /* don't overflow */
953 log_info(LD_APP
, "Address %s now has %d resolve failures.",
954 safe_str(address
), ent
->num_resolve_failures
);
955 return ent
->num_resolve_failures
;
958 /** If <b>address</b> is in the client DNS addressmap, reset
959 * the number of resolve failures we have on record for it.
960 * This is used when we fail a stream because it won't resolve:
961 * otherwise future attempts on that address will only try once.
964 client_dns_clear_failures(const char *address
)
966 addressmap_entry_t
*ent
= strmap_get(addressmap
, address
);
968 ent
->num_resolve_failures
= 0;
971 /** Record the fact that <b>address</b> resolved to <b>name</b>.
972 * We can now use this in subsequent streams via addressmap_rewrite()
973 * so we can more correctly choose an exit that will allow <b>address</b>.
975 * If <b>exitname</b> is defined, then append the addresses with
976 * ".exitname.exit" before registering the mapping.
978 * If <b>ttl</b> is nonnegative, the mapping will be valid for
979 * <b>ttl</b>seconds; otherwise, we use the default.
982 client_dns_set_addressmap_impl(const char *address
, const char *name
,
983 const char *exitname
,
986 /* <address>.<hex or nickname>.exit\0 or just <address>\0 */
987 char extendedaddress
[MAX_SOCKS_ADDR_LEN
+MAX_VERBOSE_NICKNAME_LEN
+10];
988 /* 123.123.123.123.<hex or nickname>.exit\0 or just 123.123.123.123\0 */
989 char extendedval
[INET_NTOA_BUF_LEN
+MAX_VERBOSE_NICKNAME_LEN
+10];
995 ttl
= DEFAULT_DNS_TTL
;
997 ttl
= dns_clip_ttl(ttl
);
1000 /* XXXX fails to ever get attempts to get an exit address of
1001 * google.com.digest[=~]nickname.exit; we need a syntax for this that
1002 * won't make strict RFC952-compliant applications (like us) barf. */
1003 tor_snprintf(extendedaddress
, sizeof(extendedaddress
),
1004 "%s.%s.exit", address
, exitname
);
1005 tor_snprintf(extendedval
, sizeof(extendedval
),
1006 "%s.%s.exit", name
, exitname
);
1008 tor_snprintf(extendedaddress
, sizeof(extendedaddress
),
1010 tor_snprintf(extendedval
, sizeof(extendedval
),
1013 addressmap_register(extendedaddress
, tor_strdup(extendedval
),
1014 time(NULL
) + ttl
, ADDRMAPSRC_DNS
);
1017 /** Record the fact that <b>address</b> resolved to <b>val</b>.
1018 * We can now use this in subsequent streams via addressmap_rewrite()
1019 * so we can more correctly choose an exit that will allow <b>address</b>.
1021 * If <b>exitname</b> is defined, then append the addresses with
1022 * ".exitname.exit" before registering the mapping.
1024 * If <b>ttl</b> is nonnegative, the mapping will be valid for
1025 * <b>ttl</b>seconds; otherwise, we use the default.
1028 client_dns_set_addressmap(const char *address
, uint32_t val
,
1029 const char *exitname
,
1033 char valbuf
[INET_NTOA_BUF_LEN
];
1035 tor_assert(address
);
1037 if (tor_inet_aton(address
, &in
))
1038 return; /* If address was an IP address already, don't add a mapping. */
1039 in
.s_addr
= htonl(val
);
1040 tor_inet_ntoa(&in
,valbuf
,sizeof(valbuf
));
1042 client_dns_set_addressmap_impl(address
, valbuf
, exitname
, ttl
);
1045 /** Add a cache entry noting that <b>address</b> (ordinarily a dotted quad)
1046 * resolved via a RESOLVE_PTR request to the hostname <b>v</b>.
1048 * If <b>exitname</b> is defined, then append the addresses with
1049 * ".exitname.exit" before registering the mapping.
1051 * If <b>ttl</b> is nonnegative, the mapping will be valid for
1052 * <b>ttl</b>seconds; otherwise, we use the default.
1055 client_dns_set_reverse_addressmap(const char *address
, const char *v
,
1056 const char *exitname
,
1059 size_t len
= strlen(address
) + 16;
1060 char *s
= tor_malloc(len
);
1061 tor_snprintf(s
, len
, "REVERSE[%s]", address
);
1062 client_dns_set_addressmap_impl(s
, v
, exitname
, ttl
);
1066 /* By default, we hand out 127.192.0.1 through 127.254.254.254.
1067 * These addresses should map to localhost, so even if the
1068 * application accidentally tried to connect to them directly (not
1069 * via Tor), it wouldn't get too far astray.
1071 * These options are configured by parse_virtual_addr_network().
1073 /** Which network should we use for virtual IPv4 addresses? Only the first
1074 * bits of this value are fixed. */
1075 static uint32_t virtual_addr_network
= 0x7fc00000u
;
1076 /** How many bits of <b>virtual_addr_network</b> are fixed? */
1077 static maskbits_t virtual_addr_netmask_bits
= 10;
1078 /** What's the next virtual address we will hand out? */
1079 static uint32_t next_virtual_addr
= 0x7fc00000u
;
1081 /** Read a netmask of the form 127.192.0.0/10 from "val", and check whether
1082 * it's a valid set of virtual addresses to hand out in response to MAPADDRESS
1083 * requests. Return 0 on success; set *msg (if provided) to a newly allocated
1084 * string and return -1 on failure. If validate_only is false, sets the
1085 * actual virtual address range to the parsed value. */
1087 parse_virtual_addr_network(const char *val
, int validate_only
,
1091 uint16_t port_min
, port_max
;
1094 if (parse_addr_and_port_range(val
, &addr
, &bits
, &port_min
, &port_max
)) {
1095 if (msg
) *msg
= tor_strdup("Error parsing VirtualAddressNetwork");
1099 if (port_min
!= 1 || port_max
!= 65535) {
1100 if (msg
) *msg
= tor_strdup("Can't specify ports on VirtualAddressNetwork");
1105 if (msg
) *msg
= tor_strdup("VirtualAddressNetwork expects a /16 "
1106 "network or larger");
1113 virtual_addr_network
= (uint32_t)( addr
& (0xfffffffful
<< (32-bits
)) );
1114 virtual_addr_netmask_bits
= bits
;
1116 if (addr_mask_cmp_bits(next_virtual_addr
, addr
, bits
))
1117 next_virtual_addr
= addr
;
1123 * Return true iff <b>addr</b> is likely to have been returned by
1124 * client_dns_get_unused_address.
1127 address_is_in_virtual_range(const char *address
)
1130 tor_assert(address
);
1131 if (!strcasecmpend(address
, ".virtual")) {
1133 } else if (tor_inet_aton(address
, &in
)) {
1134 uint32_t addr
= ntohl(in
.s_addr
);
1135 if (!addr_mask_cmp_bits(addr
, virtual_addr_network
,
1136 virtual_addr_netmask_bits
))
1142 /** Increment the value of next_virtual_addr; reset it to the start of the
1143 * virtual address range if it wraps around.
1146 increment_virtual_addr(void)
1148 ++next_virtual_addr
;
1149 if (addr_mask_cmp_bits(next_virtual_addr
, virtual_addr_network
,
1150 virtual_addr_netmask_bits
))
1151 next_virtual_addr
= virtual_addr_network
;
1154 /** Return a newly allocated string holding an address of <b>type</b>
1155 * (one of RESOLVED_TYPE_{IPV4|HOSTNAME}) that has not yet been mapped,
1156 * and that is very unlikely to be the address of any real host.
1158 * May return NULL if we have run out of virtual addresses.
1161 addressmap_get_virtual_address(int type
)
1165 tor_assert(addressmap
);
1167 if (type
== RESOLVED_TYPE_HOSTNAME
) {
1170 crypto_rand(rand
, sizeof(rand
));
1171 base32_encode(buf
,sizeof(buf
),rand
,sizeof(rand
));
1172 strlcat(buf
, ".virtual", sizeof(buf
));
1173 } while (strmap_get(addressmap
, buf
));
1174 return tor_strdup(buf
);
1175 } else if (type
== RESOLVED_TYPE_IPV4
) {
1176 // This is an imperfect estimate of how many addresses are available, but
1178 uint32_t available
= 1u << (32-virtual_addr_netmask_bits
);
1180 /* Don't hand out any .0 or .255 address. */
1181 while ((next_virtual_addr
& 0xff) == 0 ||
1182 (next_virtual_addr
& 0xff) == 0xff) {
1183 increment_virtual_addr();
1184 if (! --available
) {
1185 log_warn(LD_CONFIG
, "Ran out of virtual addresses!");
1189 in
.s_addr
= htonl(next_virtual_addr
);
1190 tor_inet_ntoa(&in
, buf
, sizeof(buf
));
1191 if (!strmap_get(addressmap
, buf
)) {
1192 increment_virtual_addr();
1196 increment_virtual_addr();
1198 // log_info(LD_CONFIG, "%d addrs available", (int)available);
1200 log_warn(LD_CONFIG
, "Ran out of virtual addresses!");
1204 return tor_strdup(buf
);
1206 log_warn(LD_BUG
, "Called with unsupported address type (%d)", type
);
1211 /** A controller has requested that we map some address of type
1212 * <b>type</b> to the address <b>new_address</b>. Choose an address
1213 * that is unlikely to be used, and map it, and return it in a newly
1214 * allocated string. If another address of the same type is already
1215 * mapped to <b>new_address</b>, try to return a copy of that address.
1217 * The string in <b>new_address</b> may be freed or inserted into a map
1218 * as appropriate. May return NULL if are out of virtual addresses.
1221 addressmap_register_virtual_address(int type
, char *new_address
)
1224 virtaddress_entry_t
*vent
;
1225 int vent_needs_to_be_added
= 0;
1227 tor_assert(new_address
);
1228 tor_assert(addressmap
);
1229 tor_assert(virtaddress_reversemap
);
1231 vent
= strmap_get(virtaddress_reversemap
, new_address
);
1233 vent
= tor_malloc_zero(sizeof(virtaddress_entry_t
));
1234 vent_needs_to_be_added
= 1;
1237 addrp
= (type
== RESOLVED_TYPE_IPV4
) ?
1238 &vent
->ipv4_address
: &vent
->hostname_address
;
1240 addressmap_entry_t
*ent
= strmap_get(addressmap
, *addrp
);
1241 if (ent
&& ent
->new_address
&&
1242 !strcasecmp(new_address
, ent
->new_address
)) {
1243 tor_free(new_address
);
1244 tor_assert(!vent_needs_to_be_added
);
1245 return tor_strdup(*addrp
);
1248 "Internal confusion: I thought that '%s' was mapped to by "
1249 "'%s', but '%s' really maps to '%s'. This is a harmless bug.",
1250 safe_str(new_address
), safe_str(*addrp
), safe_str(*addrp
),
1251 ent
?safe_str(ent
->new_address
):"(nothing)");
1255 *addrp
= addressmap_get_virtual_address(type
);
1258 tor_free(new_address
);
1261 log_info(LD_APP
, "Registering map from %s to %s", *addrp
, new_address
);
1262 if (vent_needs_to_be_added
)
1263 strmap_set(virtaddress_reversemap
, new_address
, vent
);
1264 addressmap_register(*addrp
, new_address
, 2, ADDRMAPSRC_CONTROLLER
);
1268 /* Try to catch possible bugs */
1269 addressmap_entry_t
*ent
;
1270 ent
= strmap_get(addressmap
, *addrp
);
1272 tor_assert(!strcasecmp(ent
->new_address
,new_address
));
1273 vent
= strmap_get(virtaddress_reversemap
, new_address
);
1275 tor_assert(!strcasecmp(*addrp
,
1276 (type
== RESOLVED_TYPE_IPV4
) ?
1277 vent
->ipv4_address
: vent
->hostname_address
));
1278 log_info(LD_APP
, "Map from %s to %s okay.",
1279 safe_str(*addrp
),safe_str(new_address
));
1286 /** Return 1 if <b>address</b> has funny characters in it like colons. Return
1287 * 0 if it's fine, or if we're configured to allow it anyway. <b>client</b>
1288 * should be true if we're using this address as a client; false if we're
1289 * using it as a server.
1292 address_is_invalid_destination(const char *address
, int client
)
1295 if (get_options()->AllowNonRFC953Hostnames
)
1298 if (get_options()->ServerDNSAllowNonRFC953Hostnames
)
1303 if (TOR_ISALNUM(*address
) ||
1306 *address
== '_') /* Underscore is not allowed, but Windows does it
1307 * sometimes, just to thumb its nose at the IETF. */
1315 /** Iterate over all address mappings which have expiry times between
1316 * min_expires and max_expires, inclusive. If sl is provided, add an
1317 * "old-addr new-addr expiry" string to sl for each mapping, omitting
1318 * the expiry time if want_expiry is false. If sl is NULL, remove the
1322 addressmap_get_mappings(smartlist_t
*sl
, time_t min_expires
,
1323 time_t max_expires
, int want_expiry
)
1325 strmap_iter_t
*iter
;
1328 addressmap_entry_t
*val
;
1333 for (iter
= strmap_iter_init(addressmap
); !strmap_iter_done(iter
); ) {
1334 strmap_iter_get(iter
, &key
, &_val
);
1336 if (val
->expires
>= min_expires
&& val
->expires
<= max_expires
) {
1338 iter
= strmap_iter_next_rmv(addressmap
,iter
);
1339 addressmap_ent_remove(key
, val
);
1341 } else if (val
->new_address
) {
1342 size_t len
= strlen(key
)+strlen(val
->new_address
)+ISO_TIME_LEN
+5;
1343 char *line
= tor_malloc(len
);
1345 if (val
->expires
< 3 || val
->expires
== TIME_MAX
)
1346 tor_snprintf(line
, len
, "%s %s NEVER", key
, val
->new_address
);
1348 char time
[ISO_TIME_LEN
+1];
1349 format_iso_time(time
, val
->expires
);
1350 tor_snprintf(line
, len
, "%s %s \"%s\"", key
, val
->new_address
,
1354 tor_snprintf(line
, len
, "%s %s", key
, val
->new_address
);
1356 smartlist_add(sl
, line
);
1359 iter
= strmap_iter_next(addressmap
,iter
);
1363 /** Check if <b>conn</b> is using a dangerous port. Then warn and/or
1364 * reject depending on our config options. */
1366 consider_plaintext_ports(edge_connection_t
*conn
, uint16_t port
)
1368 or_options_t
*options
= get_options();
1369 int reject
= smartlist_string_num_isin(options
->RejectPlaintextPorts
, port
);
1371 if (smartlist_string_num_isin(options
->WarnPlaintextPorts
, port
)) {
1372 log_warn(LD_APP
, "Application request to port %d: this port is "
1373 "commonly used for unencrypted protocols. Please make sure "
1374 "you don't send anything you would mind the rest of the "
1375 "Internet reading!%s", port
, reject
? " Closing." : "");
1376 control_event_client_status(LOG_WARN
, "DANGEROUS_PORT PORT=%d RESULT=%s",
1377 port
, reject
? "REJECT" : "WARN");
1381 log_info(LD_APP
, "Port %d listed in RejectPlaintextPorts. Closing.", port
);
1382 connection_mark_unattached_ap(conn
, END_STREAM_REASON_ENTRYPOLICY
);
1389 /** How many times do we try connecting with an exit configured via
1390 * TrackHostExits before concluding that it won't work any more and trying a
1392 #define TRACKHOSTEXITS_RETRIES 5
1394 /** Connection <b>conn</b> just finished its socks handshake, or the
1395 * controller asked us to take care of it. If <b>circ</b> is defined,
1396 * then that's where we'll want to attach it. Otherwise we have to
1397 * figure it out ourselves.
1399 * First, parse whether it's a .exit address, remap it, and so on. Then
1400 * if it's for a general circuit, try to attach it to a circuit (or launch
1401 * one as needed), else if it's for a rendezvous circuit, fetch a
1402 * rendezvous descriptor first (or attach/launch a circuit if the
1403 * rendezvous descriptor is already here and fresh enough).
1405 * The stream will exit from the hop
1406 * indicated by <b>cpath</b>, or from the last hop in circ's cpath if
1407 * <b>cpath</b> is NULL.
1410 connection_ap_handshake_rewrite_and_attach(edge_connection_t
*conn
,
1411 origin_circuit_t
*circ
,
1412 crypt_path_t
*cpath
)
1414 socks_request_t
*socks
= conn
->socks_request
;
1415 hostname_type_t addresstype
;
1416 or_options_t
*options
= get_options();
1417 struct in_addr addr_tmp
;
1419 char orig_address
[MAX_SOCKS_ADDR_LEN
];
1420 time_t map_expires
= TIME_MAX
;
1421 int remapped_to_exit
= 0;
1422 time_t now
= time(NULL
);
1424 tor_strlower(socks
->address
); /* normalize it */
1425 strlcpy(orig_address
, socks
->address
, sizeof(orig_address
));
1426 log_debug(LD_APP
,"Client asked for %s:%d",
1427 safe_str(socks
->address
),
1430 if (socks
->command
== SOCKS_COMMAND_RESOLVE
&&
1431 !tor_inet_aton(socks
->address
, &addr_tmp
) &&
1432 options
->AutomapHostsOnResolve
&& options
->AutomapHostsSuffixes
) {
1433 SMARTLIST_FOREACH(options
->AutomapHostsSuffixes
, const char *, cp
,
1434 if (!strcasecmpend(socks
->address
, cp
)) {
1439 const char *new_addr
;
1440 new_addr
= addressmap_register_virtual_address(
1441 RESOLVED_TYPE_IPV4
, tor_strdup(socks
->address
));
1443 log_warn(LD_APP
, "Unable to automap address %s",
1444 escaped_safe_str(socks
->address
));
1445 connection_mark_unattached_ap(conn
, END_STREAM_REASON_INTERNAL
);
1448 log_info(LD_APP
, "Automapping %s to %s",
1449 escaped_safe_str(socks
->address
), safe_str(new_addr
));
1450 strlcpy(socks
->address
, new_addr
, sizeof(socks
->address
));
1454 if (socks
->command
== SOCKS_COMMAND_RESOLVE_PTR
) {
1455 if (addressmap_rewrite_reverse(socks
->address
, sizeof(socks
->address
),
1457 char *result
= tor_strdup(socks
->address
);
1458 /* remember _what_ is supposed to have been resolved. */
1459 tor_snprintf(socks
->address
, sizeof(socks
->address
), "REVERSE[%s]",
1461 connection_ap_handshake_socks_resolved(conn
, RESOLVED_TYPE_HOSTNAME
,
1462 strlen(result
), (uint8_t*)result
,
1465 connection_mark_unattached_ap(conn
,
1466 END_STREAM_REASON_DONE
|
1467 END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED
);
1470 if (options
->ClientDNSRejectInternalAddresses
) {
1471 /* Don't let people try to do a reverse lookup on 10.0.0.1. */
1474 ok
= tor_addr_parse_reverse_lookup_name(
1475 &addr
, socks
->address
, AF_UNSPEC
, 1);
1476 if (ok
== 1 && tor_addr_is_internal(&addr
, 0)) {
1477 connection_ap_handshake_socks_resolved(conn
, RESOLVED_TYPE_ERROR
,
1478 0, NULL
, -1, TIME_MAX
);
1479 connection_mark_unattached_ap(conn
,
1480 END_STREAM_REASON_SOCKSPROTOCOL
|
1481 END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED
);
1485 } else if (!automap
) {
1486 int started_without_chosen_exit
= strcasecmpend(socks
->address
, ".exit");
1487 /* For address map controls, remap the address. */
1488 if (addressmap_rewrite(socks
->address
, sizeof(socks
->address
),
1490 control_event_stream_status(conn
, STREAM_EVENT_REMAP
,
1491 REMAP_STREAM_SOURCE_CACHE
);
1492 if (started_without_chosen_exit
&&
1493 !strcasecmpend(socks
->address
, ".exit") &&
1494 map_expires
< TIME_MAX
)
1495 remapped_to_exit
= 1;
1499 if (!automap
&& address_is_in_virtual_range(socks
->address
)) {
1500 /* This address was probably handed out by client_dns_get_unmapped_address,
1501 * but the mapping was discarded for some reason. We *don't* want to send
1502 * the address through Tor; that's likely to fail, and may leak
1505 log_warn(LD_APP
,"Missing mapping for virtual address '%s'. Refusing.",
1506 socks
->address
); /* don't safe_str() this yet. */
1507 connection_mark_unattached_ap(conn
, END_STREAM_REASON_INTERNAL
);
1511 /* Parse the address provided by SOCKS. Modify it in-place if it
1512 * specifies a hidden-service (.onion) or particular exit node (.exit).
1514 addresstype
= parse_extended_hostname(socks
->address
);
1516 if (addresstype
== BAD_HOSTNAME
) {
1517 log_warn(LD_APP
, "Invalid onion hostname %s; rejecting",
1518 safe_str(socks
->address
));
1519 control_event_client_status(LOG_WARN
, "SOCKS_BAD_HOSTNAME HOSTNAME=%s",
1520 escaped(socks
->address
));
1521 connection_mark_unattached_ap(conn
, END_STREAM_REASON_TORPROTOCOL
);
1525 if (addresstype
== EXIT_HOSTNAME
) {
1526 /* foo.exit -- modify conn->chosen_exit_node to specify the exit
1527 * node, and conn->address to hold only the address portion.*/
1528 char *s
= strrchr(socks
->address
,'.');
1529 tor_assert(!automap
);
1532 conn
->chosen_exit_name
= tor_strdup(s
+1);
1533 if (remapped_to_exit
) /* 5 tries before it expires the addressmap */
1534 conn
->chosen_exit_retries
= TRACKHOSTEXITS_RETRIES
;
1537 log_warn(LD_APP
,"Malformed exit address '%s.exit'. Refusing.",
1538 safe_str(socks
->address
));
1539 control_event_client_status(LOG_WARN
, "SOCKS_BAD_HOSTNAME HOSTNAME=%s",
1540 escaped(socks
->address
));
1541 connection_mark_unattached_ap(conn
, END_STREAM_REASON_TORPROTOCOL
);
1546 conn
->chosen_exit_name
= tor_strdup(socks
->address
);
1547 r
= router_get_by_nickname(conn
->chosen_exit_name
, 1);
1548 *socks
->address
= 0;
1550 strlcpy(socks
->address
, r
->address
, sizeof(socks
->address
));
1553 "Unrecognized server in exit address '%s.exit'. Refusing.",
1554 safe_str(socks
->address
));
1555 connection_mark_unattached_ap(conn
, END_STREAM_REASON_TORPROTOCOL
);
1561 if (addresstype
!= ONION_HOSTNAME
) {
1562 /* not a hidden-service request (i.e. normal or .exit) */
1563 if (address_is_invalid_destination(socks
->address
, 1)) {
1564 control_event_client_status(LOG_WARN
, "SOCKS_BAD_HOSTNAME HOSTNAME=%s",
1565 escaped(socks
->address
));
1567 "Destination '%s' seems to be an invalid hostname. Failing.",
1568 safe_str(socks
->address
));
1569 connection_mark_unattached_ap(conn
, END_STREAM_REASON_TORPROTOCOL
);
1573 if (socks
->command
== SOCKS_COMMAND_RESOLVE
) {
1576 /* Reply to resolves immediately if we can. */
1577 if (strlen(socks
->address
) > RELAY_PAYLOAD_SIZE
) {
1578 log_warn(LD_APP
,"Address to be resolved is too large. Failing.");
1579 control_event_client_status(LOG_WARN
, "SOCKS_BAD_HOSTNAME HOSTNAME=%s",
1580 escaped(socks
->address
));
1581 connection_ap_handshake_socks_resolved(conn
,
1582 RESOLVED_TYPE_ERROR_TRANSIENT
,
1583 0,NULL
,-1,TIME_MAX
);
1584 connection_mark_unattached_ap(conn
,
1585 END_STREAM_REASON_SOCKSPROTOCOL
|
1586 END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED
);
1589 if (tor_inet_aton(socks
->address
, &in
)) { /* see if it's an IP already */
1590 /* leave it in network order */
1592 /* remember _what_ is supposed to have been resolved. */
1593 strlcpy(socks
->address
, orig_address
, sizeof(socks
->address
));
1594 connection_ap_handshake_socks_resolved(conn
,RESOLVED_TYPE_IPV4
,4,
1597 connection_mark_unattached_ap(conn
,
1598 END_STREAM_REASON_DONE
|
1599 END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED
);
1602 tor_assert(!automap
);
1603 rep_hist_note_used_resolve(now
); /* help predict this next time */
1604 } else if (socks
->command
== SOCKS_COMMAND_CONNECT
) {
1605 tor_assert(!automap
);
1606 if (socks
->port
== 0) {
1607 log_notice(LD_APP
,"Application asked to connect to port 0. Refusing.");
1608 connection_mark_unattached_ap(conn
, END_STREAM_REASON_TORPROTOCOL
);
1612 if (!conn
->use_begindir
&& !conn
->chosen_exit_name
&& !circ
) {
1613 /* see if we can find a suitable enclave exit */
1615 router_find_exact_exit_enclave(socks
->address
, socks
->port
);
1618 "Redirecting address %s to exit at enclave router %s",
1619 safe_str(socks
->address
), r
->nickname
);
1620 /* use the hex digest, not nickname, in case there are two
1621 routers with this nickname */
1622 conn
->chosen_exit_name
=
1623 tor_strdup(hex_str(r
->cache_info
.identity_digest
, DIGEST_LEN
));
1624 conn
->chosen_exit_optional
= 1;
1628 /* warn or reject if it's using a dangerous port */
1629 if (!conn
->use_begindir
&& !conn
->chosen_exit_name
&& !circ
)
1630 if (consider_plaintext_ports(conn
, socks
->port
) < 0)
1633 if (!conn
->use_begindir
) {
1634 /* help predict this next time */
1635 rep_hist_note_used_port(now
, socks
->port
);
1637 } else if (socks
->command
== SOCKS_COMMAND_RESOLVE_PTR
) {
1638 rep_hist_note_used_resolve(now
); /* help predict this next time */
1639 /* no extra processing needed */
1641 tor_fragile_assert();
1643 conn
->_base
.state
= AP_CONN_STATE_CIRCUIT_WAIT
;
1644 if ((circ
&& connection_ap_handshake_attach_chosen_circuit(
1645 conn
, circ
, cpath
) < 0) ||
1647 connection_ap_handshake_attach_circuit(conn
) < 0)) {
1648 if (!conn
->_base
.marked_for_close
)
1649 connection_mark_unattached_ap(conn
, END_STREAM_REASON_CANT_ATTACH
);
1654 /* it's a hidden-service request */
1655 rend_cache_entry_t
*entry
;
1657 rend_service_authorization_t
*client_auth
;
1658 tor_assert(!automap
);
1659 if (SOCKS_COMMAND_IS_RESOLVE(socks
->command
)) {
1660 /* if it's a resolve request, fail it right now, rather than
1661 * building all the circuits and then realizing it won't work. */
1663 "Resolve requests to hidden services not allowed. Failing.");
1664 connection_ap_handshake_socks_resolved(conn
,RESOLVED_TYPE_ERROR
,
1665 0,NULL
,-1,TIME_MAX
);
1666 connection_mark_unattached_ap(conn
,
1667 END_STREAM_REASON_SOCKSPROTOCOL
|
1668 END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED
);
1673 log_warn(LD_CONTROL
, "Attachstream to a circuit is not "
1674 "supported for .onion addresses currently. Failing.");
1675 connection_mark_unattached_ap(conn
, END_STREAM_REASON_TORPROTOCOL
);
1679 conn
->rend_data
= tor_malloc_zero(sizeof(rend_data_t
));
1680 strlcpy(conn
->rend_data
->onion_address
, socks
->address
,
1681 sizeof(conn
->rend_data
->onion_address
));
1682 log_info(LD_REND
,"Got a hidden service request for ID '%s'",
1683 safe_str(conn
->rend_data
->onion_address
));
1684 /* see if we already have it cached */
1685 r
= rend_cache_lookup_entry(conn
->rend_data
->onion_address
, -1, &entry
);
1687 log_warn(LD_BUG
,"Invalid service name '%s'",
1688 safe_str(conn
->rend_data
->onion_address
));
1689 connection_mark_unattached_ap(conn
, END_STREAM_REASON_TORPROTOCOL
);
1693 /* Help predict this next time. We're not sure if it will need
1694 * a stable circuit yet, but we know we'll need *something*. */
1695 rep_hist_note_used_internal(now
, 0, 1);
1697 /* Look up if we have client authorization for it. */
1698 client_auth
= rend_client_lookup_service_authorization(
1699 conn
->rend_data
->onion_address
);
1701 log_info(LD_REND
, "Using previously configured client authorization "
1702 "for hidden service request.");
1703 memcpy(conn
->rend_data
->descriptor_cookie
,
1704 client_auth
->descriptor_cookie
, REND_DESC_COOKIE_LEN
);
1705 conn
->rend_data
->auth_type
= client_auth
->auth_type
;
1708 conn
->_base
.state
= AP_CONN_STATE_RENDDESC_WAIT
;
1709 log_info(LD_REND
, "Unknown descriptor %s. Fetching.",
1710 safe_str(conn
->rend_data
->onion_address
));
1711 /* Fetch both, v0 and v2 rend descriptors in parallel. Use whichever
1712 * arrives first. Exception: When using client authorization, only
1713 * fetch v2 descriptors.*/
1714 rend_client_refetch_v2_renddesc(conn
->rend_data
);
1715 if (conn
->rend_data
->auth_type
== REND_NO_AUTH
)
1716 rend_client_refetch_renddesc(conn
->rend_data
->onion_address
);
1717 } else { /* r > 0 */
1718 if (now
- entry
->received
< NUM_SECONDS_BEFORE_HS_REFETCH
) {
1719 conn
->_base
.state
= AP_CONN_STATE_CIRCUIT_WAIT
;
1720 log_info(LD_REND
, "Descriptor is here and fresh enough. Great.");
1721 if (connection_ap_handshake_attach_circuit(conn
) < 0) {
1722 if (!conn
->_base
.marked_for_close
)
1723 connection_mark_unattached_ap(conn
, END_STREAM_REASON_CANT_ATTACH
);
1727 conn
->_base
.state
= AP_CONN_STATE_RENDDESC_WAIT
;
1728 log_info(LD_REND
, "Stale descriptor %s. Re-fetching.",
1729 safe_str(conn
->rend_data
->onion_address
));
1730 /* Fetch both, v0 and v2 rend descriptors in parallel. Use whichever
1731 * arrives first. Exception: When using client authorization, only
1732 * fetch v2 descriptors.*/
1733 rend_client_refetch_v2_renddesc(conn
->rend_data
);
1734 if (conn
->rend_data
->auth_type
== REND_NO_AUTH
)
1735 rend_client_refetch_renddesc(conn
->rend_data
->onion_address
);
1740 return 0; /* unreached but keeps the compiler happy */
1744 static int pf_socket
= -1;
1749 /* This should be opened before dropping privileges. */
1754 /* only works on OpenBSD */
1755 pf
= open("/dev/pf", O_RDONLY
);
1757 /* works on NetBSD and FreeBSD */
1758 pf
= open("/dev/pf", O_RDWR
);
1762 log_warn(LD_NET
, "open(\"/dev/pf\") failed: %s", strerror(errno
));
1771 /** Fetch the original destination address and port from a
1772 * system-specific interface and put them into a
1773 * socks_request_t as if they came from a socks request.
1775 * Return -1 if an error prevents fetching the destination,
1779 connection_ap_get_original_destination(edge_connection_t
*conn
,
1780 socks_request_t
*req
)
1782 #ifdef TRANS_NETFILTER
1784 struct sockaddr_storage orig_dst
;
1785 socklen_t orig_dst_len
= sizeof(orig_dst
);
1788 if (getsockopt(conn
->_base
.s
, SOL_IP
, SO_ORIGINAL_DST
,
1789 (struct sockaddr
*)&orig_dst
, &orig_dst_len
) < 0) {
1790 int e
= tor_socket_errno(conn
->_base
.s
);
1791 log_warn(LD_NET
, "getsockopt() failed: %s", tor_socket_strerror(e
));
1795 tor_addr_from_sockaddr(&addr
, (struct sockaddr
*)&orig_dst
, &req
->port
);
1796 tor_addr_to_str(req
->address
, &addr
, sizeof(req
->address
), 0);
1799 #elif defined(TRANS_PF)
1800 struct sockaddr_storage proxy_addr
;
1801 socklen_t proxy_addr_len
= sizeof(proxy_addr
);
1802 struct sockaddr
*proxy_sa
= (struct sockaddr
*) &proxy_addr
;
1803 struct pfioc_natlook pnl
;
1807 if (getsockname(conn
->_base
.s
, (struct sockaddr
*)&proxy_addr
,
1808 &proxy_addr_len
) < 0) {
1809 int e
= tor_socket_errno(conn
->_base
.s
);
1810 log_warn(LD_NET
, "getsockname() to determine transocks destination "
1811 "failed: %s", tor_socket_strerror(e
));
1815 memset(&pnl
, 0, sizeof(pnl
));
1816 pnl
.proto
= IPPROTO_TCP
;
1817 pnl
.direction
= PF_OUT
;
1818 if (proxy_sa
->sa_family
== AF_INET
) {
1819 struct sockaddr_in
*sin
= (struct sockaddr_in
*)proxy_sa
;
1821 pnl
.saddr
.v4
.s_addr
= tor_addr_to_ipv4n(&conn
->_base
.addr
);
1822 pnl
.sport
= htons(conn
->_base
.port
);
1823 pnl
.daddr
.v4
.s_addr
= sin
->sin_addr
.s_addr
;
1824 pnl
.dport
= sin
->sin_port
;
1825 } else if (proxy_sa
->sa_family
== AF_INET6
) {
1826 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)proxy_sa
;
1828 memcpy(&pnl
.saddr
.v6
, tor_addr_to_in6(&conn
->_base
.addr
),
1829 sizeof(struct in6_addr
));
1830 pnl
.sport
= htons(conn
->_base
.port
);
1831 memcpy(&pnl
.daddr
.v6
, &sin6
->sin6_addr
, sizeof(struct in6_addr
));
1832 pnl
.dport
= sin6
->sin6_port
;
1834 log_warn(LD_NET
, "getsockname() gave an unexpected address family (%d)",
1835 (int)proxy_sa
->sa_family
);
1839 pf
= get_pf_socket();
1843 if (ioctl(pf
, DIOCNATLOOK
, &pnl
) < 0) {
1844 log_warn(LD_NET
, "ioctl(DIOCNATLOOK) failed: %s", strerror(errno
));
1848 if (pnl
.af
== AF_INET
) {
1849 tor_addr_from_ipv4n(&addr
, pnl
.rdaddr
.v4
.s_addr
);
1850 } else if (pnl
.af
== AF_INET6
) {
1851 tor_addr_from_in6(&addr
, &pnl
.rdaddr
.v6
);
1853 tor_fragile_assert();
1857 tor_addr_to_str(req
->address
, &addr
, sizeof(req
->address
), 0);
1858 req
->port
= ntohs(pnl
.rdport
);
1864 log_warn(LD_BUG
, "Called connection_ap_get_original_destination, but no "
1865 "transparent proxy method was configured.");
1870 /** connection_edge_process_inbuf() found a conn in state
1871 * socks_wait. See if conn->inbuf has the right bytes to proceed with
1872 * the socks handshake.
1874 * If the handshake is complete, send it to
1875 * connection_ap_handshake_rewrite_and_attach().
1877 * Return -1 if an unexpected error with conn occurs (and mark it for close),
1881 connection_ap_handshake_process_socks(edge_connection_t
*conn
)
1883 socks_request_t
*socks
;
1885 or_options_t
*options
= get_options();
1888 tor_assert(conn
->_base
.type
== CONN_TYPE_AP
);
1889 tor_assert(conn
->_base
.state
== AP_CONN_STATE_SOCKS_WAIT
);
1890 tor_assert(conn
->socks_request
);
1891 socks
= conn
->socks_request
;
1893 log_debug(LD_APP
,"entered.");
1895 sockshere
= fetch_from_buf_socks(conn
->_base
.inbuf
, socks
,
1896 options
->TestSocks
, options
->SafeSocks
);
1897 if (sockshere
== 0) {
1898 if (socks
->replylen
) {
1899 connection_write_to_buf(socks
->reply
, socks
->replylen
, TO_CONN(conn
));
1900 /* zero it out so we can do another round of negotiation */
1901 socks
->replylen
= 0;
1903 log_debug(LD_APP
,"socks handshake not all here yet.");
1906 } else if (sockshere
== -1) {
1907 if (socks
->replylen
) { /* we should send reply back */
1908 log_debug(LD_APP
,"reply is already set for us. Using it.");
1909 connection_ap_handshake_socks_reply(conn
, socks
->reply
, socks
->replylen
,
1910 END_STREAM_REASON_SOCKSPROTOCOL
);
1913 log_warn(LD_APP
,"Fetching socks handshake failed. Closing.");
1914 connection_ap_handshake_socks_reply(conn
, NULL
, 0,
1915 END_STREAM_REASON_SOCKSPROTOCOL
);
1917 connection_mark_unattached_ap(conn
,
1918 END_STREAM_REASON_SOCKSPROTOCOL
|
1919 END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED
);
1921 } /* else socks handshake is done, continue processing */
1923 if (hostname_is_noconnect_address(socks
->address
))
1925 control_event_stream_status(conn
, STREAM_EVENT_NEW
, 0);
1926 control_event_stream_status(conn
, STREAM_EVENT_CLOSED
, 0);
1927 connection_mark_unattached_ap(conn
, END_STREAM_REASON_DONE
);
1931 if (SOCKS_COMMAND_IS_CONNECT(socks
->command
))
1932 control_event_stream_status(conn
, STREAM_EVENT_NEW
, 0);
1934 control_event_stream_status(conn
, STREAM_EVENT_NEW_RESOLVE
, 0);
1936 if (options
->LeaveStreamsUnattached
) {
1937 conn
->_base
.state
= AP_CONN_STATE_CONTROLLER_WAIT
;
1940 return connection_ap_handshake_rewrite_and_attach(conn
, NULL
, NULL
);
1943 /** connection_init_accepted_conn() found a new trans AP conn.
1944 * Get the original destination and send it to
1945 * connection_ap_handshake_rewrite_and_attach().
1947 * Return -1 if an unexpected error with conn (and it should be marked
1948 * for close), else return 0.
1951 connection_ap_process_transparent(edge_connection_t
*conn
)
1953 socks_request_t
*socks
;
1954 or_options_t
*options
= get_options();
1957 tor_assert(conn
->_base
.type
== CONN_TYPE_AP
);
1958 tor_assert(conn
->socks_request
);
1959 socks
= conn
->socks_request
;
1961 /* pretend that a socks handshake completed so we don't try to
1962 * send a socks reply down a transparent conn */
1963 socks
->command
= SOCKS_COMMAND_CONNECT
;
1964 socks
->has_finished
= 1;
1966 log_debug(LD_APP
,"entered.");
1968 if (connection_ap_get_original_destination(conn
, socks
) < 0) {
1969 log_warn(LD_APP
,"Fetching original destination failed. Closing.");
1970 connection_mark_unattached_ap(conn
,
1971 END_STREAM_REASON_CANT_FETCH_ORIG_DEST
);
1974 /* we have the original destination */
1976 control_event_stream_status(conn
, STREAM_EVENT_NEW
, 0);
1978 if (options
->LeaveStreamsUnattached
) {
1979 conn
->_base
.state
= AP_CONN_STATE_CONTROLLER_WAIT
;
1982 return connection_ap_handshake_rewrite_and_attach(conn
, NULL
, NULL
);
1985 /** connection_edge_process_inbuf() found a conn in state natd_wait. See if
1986 * conn-\>inbuf has the right bytes to proceed. See FreeBSD's libalias(3) and
1987 * ProxyEncodeTcpStream() in src/lib/libalias/alias_proxy.c for the encoding
1988 * form of the original destination.
1990 * If the original destination is complete, send it to
1991 * connection_ap_handshake_rewrite_and_attach().
1993 * Return -1 if an unexpected error with conn (and it should be marked
1994 * for close), else return 0.
1997 connection_ap_process_natd(edge_connection_t
*conn
)
1999 char tmp_buf
[36], *tbuf
, *daddr
;
2002 socks_request_t
*socks
;
2003 or_options_t
*options
= get_options();
2006 tor_assert(conn
->_base
.type
== CONN_TYPE_AP
);
2007 tor_assert(conn
->_base
.state
== AP_CONN_STATE_NATD_WAIT
);
2008 tor_assert(conn
->socks_request
);
2009 socks
= conn
->socks_request
;
2011 log_debug(LD_APP
,"entered.");
2013 /* look for LF-terminated "[DEST ip_addr port]"
2014 * where ip_addr is a dotted-quad and port is in string form */
2015 err
= fetch_from_buf_line(conn
->_base
.inbuf
, tmp_buf
, &tlen
);
2019 log_warn(LD_APP
,"Natd handshake failed (DEST too long). Closing");
2020 connection_mark_unattached_ap(conn
, END_STREAM_REASON_INVALID_NATD_DEST
);
2024 if (strcmpstart(tmp_buf
, "[DEST ")) {
2025 log_warn(LD_APP
,"Natd handshake was ill-formed; closing. The client "
2028 connection_mark_unattached_ap(conn
, END_STREAM_REASON_INVALID_NATD_DEST
);
2032 daddr
= tbuf
= &tmp_buf
[0] + 6; /* after end of "[DEST " */
2033 if (!(tbuf
= strchr(tbuf
, ' '))) {
2034 log_warn(LD_APP
,"Natd handshake was ill-formed; closing. The client "
2037 connection_mark_unattached_ap(conn
, END_STREAM_REASON_INVALID_NATD_DEST
);
2042 /* pretend that a socks handshake completed so we don't try to
2043 * send a socks reply down a natd conn */
2044 strlcpy(socks
->address
, daddr
, sizeof(socks
->address
));
2045 socks
->port
= (uint16_t)
2046 tor_parse_long(tbuf
, 10, 1, 65535, &port_ok
, &daddr
);
2048 log_warn(LD_APP
,"Natd handshake failed; port %s is ill-formed or out "
2049 "of range.", escaped(tbuf
));
2050 connection_mark_unattached_ap(conn
, END_STREAM_REASON_INVALID_NATD_DEST
);
2054 socks
->command
= SOCKS_COMMAND_CONNECT
;
2055 socks
->has_finished
= 1;
2057 control_event_stream_status(conn
, STREAM_EVENT_NEW
, 0);
2059 if (options
->LeaveStreamsUnattached
) {
2060 conn
->_base
.state
= AP_CONN_STATE_CONTROLLER_WAIT
;
2063 conn
->_base
.state
= AP_CONN_STATE_CIRCUIT_WAIT
;
2065 return connection_ap_handshake_rewrite_and_attach(conn
, NULL
, NULL
);
2068 /** Iterate over the two bytes of stream_id until we get one that is not
2069 * already in use; return it. Return 0 if can't get a unique stream_id.
2072 get_unique_stream_id_by_circ(origin_circuit_t
*circ
)
2074 edge_connection_t
*tmpconn
;
2075 streamid_t test_stream_id
;
2076 uint32_t attempts
=0;
2079 test_stream_id
= circ
->next_stream_id
++;
2080 if (++attempts
> 1<<16) {
2081 /* Make sure we don't loop forever if all stream_id's are used. */
2082 log_warn(LD_APP
,"No unused stream IDs. Failing.");
2085 if (test_stream_id
== 0)
2087 for (tmpconn
= circ
->p_streams
; tmpconn
; tmpconn
=tmpconn
->next_stream
)
2088 if (tmpconn
->stream_id
== test_stream_id
)
2090 return test_stream_id
;
2093 /** Write a relay begin cell, using destaddr and destport from ap_conn's
2094 * socks_request field, and send it down circ.
2096 * If ap_conn is broken, mark it for close and return -1. Else return 0.
2099 connection_ap_handshake_send_begin(edge_connection_t
*ap_conn
)
2101 char payload
[CELL_PAYLOAD_SIZE
];
2104 origin_circuit_t
*circ
;
2105 tor_assert(ap_conn
->on_circuit
);
2106 circ
= TO_ORIGIN_CIRCUIT(ap_conn
->on_circuit
);
2108 tor_assert(ap_conn
->_base
.type
== CONN_TYPE_AP
);
2109 tor_assert(ap_conn
->_base
.state
== AP_CONN_STATE_CIRCUIT_WAIT
);
2110 tor_assert(ap_conn
->socks_request
);
2111 tor_assert(SOCKS_COMMAND_IS_CONNECT(ap_conn
->socks_request
->command
));
2113 ap_conn
->stream_id
= get_unique_stream_id_by_circ(circ
);
2114 if (ap_conn
->stream_id
==0) {
2115 connection_mark_unattached_ap(ap_conn
, END_STREAM_REASON_INTERNAL
);
2116 circuit_mark_for_close(TO_CIRCUIT(circ
), END_CIRC_REASON_RESOURCELIMIT
);
2120 tor_snprintf(payload
,RELAY_PAYLOAD_SIZE
, "%s:%d",
2121 (circ
->_base
.purpose
== CIRCUIT_PURPOSE_C_GENERAL
) ?
2122 ap_conn
->socks_request
->address
: "",
2123 ap_conn
->socks_request
->port
);
2124 payload_len
= (int)strlen(payload
)+1;
2127 "Sending relay cell to begin stream %d.", ap_conn
->stream_id
);
2129 begin_type
= ap_conn
->use_begindir
?
2130 RELAY_COMMAND_BEGIN_DIR
: RELAY_COMMAND_BEGIN
;
2131 if (begin_type
== RELAY_COMMAND_BEGIN
) {
2132 tor_assert(circ
->build_state
->onehop_tunnel
== 0);
2135 if (connection_edge_send_command(ap_conn
, begin_type
,
2136 begin_type
== RELAY_COMMAND_BEGIN
? payload
: NULL
,
2137 begin_type
== RELAY_COMMAND_BEGIN
? payload_len
: 0) < 0)
2138 return -1; /* circuit is closed, don't continue */
2140 ap_conn
->package_window
= STREAMWINDOW_START
;
2141 ap_conn
->deliver_window
= STREAMWINDOW_START
;
2142 ap_conn
->_base
.state
= AP_CONN_STATE_CONNECT_WAIT
;
2143 log_info(LD_APP
,"Address/port sent, ap socket %d, n_circ_id %d",
2144 ap_conn
->_base
.s
, circ
->_base
.n_circ_id
);
2145 control_event_stream_status(ap_conn
, STREAM_EVENT_SENT_CONNECT
, 0);
2149 /** Write a relay resolve cell, using destaddr and destport from ap_conn's
2150 * socks_request field, and send it down circ.
2152 * If ap_conn is broken, mark it for close and return -1. Else return 0.
2155 connection_ap_handshake_send_resolve(edge_connection_t
*ap_conn
)
2157 int payload_len
, command
;
2158 const char *string_addr
;
2159 char inaddr_buf
[REVERSE_LOOKUP_NAME_BUF_LEN
];
2160 origin_circuit_t
*circ
;
2161 tor_assert(ap_conn
->on_circuit
);
2162 circ
= TO_ORIGIN_CIRCUIT(ap_conn
->on_circuit
);
2164 tor_assert(ap_conn
->_base
.type
== CONN_TYPE_AP
);
2165 tor_assert(ap_conn
->_base
.state
== AP_CONN_STATE_CIRCUIT_WAIT
);
2166 tor_assert(ap_conn
->socks_request
);
2167 tor_assert(circ
->_base
.purpose
== CIRCUIT_PURPOSE_C_GENERAL
);
2169 command
= ap_conn
->socks_request
->command
;
2170 tor_assert(SOCKS_COMMAND_IS_RESOLVE(command
));
2172 ap_conn
->stream_id
= get_unique_stream_id_by_circ(circ
);
2173 if (ap_conn
->stream_id
==0) {
2174 connection_mark_unattached_ap(ap_conn
, END_STREAM_REASON_INTERNAL
);
2175 /*XXXX022 _close_ the circuit because it's full? That sounds dumb. */
2176 circuit_mark_for_close(TO_CIRCUIT(circ
), END_CIRC_REASON_RESOURCELIMIT
);
2180 if (command
== SOCKS_COMMAND_RESOLVE
) {
2181 string_addr
= ap_conn
->socks_request
->address
;
2182 payload_len
= (int)strlen(string_addr
)+1;
2184 /* command == SOCKS_COMMAND_RESOLVE_PTR */
2185 const char *a
= ap_conn
->socks_request
->address
;
2189 /* We're doing a reverse lookup. The input could be an IP address, or
2190 * could be an .in-addr.arpa or .ip6.arpa address */
2191 r
= tor_addr_parse_reverse_lookup_name(&addr
, a
, AF_INET
, 1);
2193 log_warn(LD_APP
, "Rejecting ill-formed reverse lookup of %s",
2195 connection_mark_unattached_ap(ap_conn
, END_STREAM_REASON_INTERNAL
);
2199 r
= tor_addr_to_reverse_lookup_name(inaddr_buf
, sizeof(inaddr_buf
), &addr
);
2201 log_warn(LD_BUG
, "Couldn't generate reverse lookup hostname of %s",
2203 connection_mark_unattached_ap(ap_conn
, END_STREAM_REASON_INTERNAL
);
2207 string_addr
= inaddr_buf
;
2208 payload_len
= (int)strlen(inaddr_buf
)+1;
2209 tor_assert(payload_len
<= (int)sizeof(inaddr_buf
));
2212 if (payload_len
> RELAY_PAYLOAD_SIZE
) {
2213 /* This should be impossible: we don't accept addresses this big. */
2214 connection_mark_unattached_ap(ap_conn
, END_STREAM_REASON_INTERNAL
);
2219 "Sending relay cell to begin stream %d.", ap_conn
->stream_id
);
2221 if (connection_edge_send_command(ap_conn
,
2222 RELAY_COMMAND_RESOLVE
,
2223 string_addr
, payload_len
) < 0)
2224 return -1; /* circuit is closed, don't continue */
2226 tor_free(ap_conn
->_base
.address
); /* Maybe already set by dnsserv. */
2227 ap_conn
->_base
.address
= tor_strdup("(Tor_internal)");
2228 ap_conn
->_base
.state
= AP_CONN_STATE_RESOLVE_WAIT
;
2229 log_info(LD_APP
,"Address sent for resolve, ap socket %d, n_circ_id %d",
2230 ap_conn
->_base
.s
, circ
->_base
.n_circ_id
);
2231 control_event_stream_status(ap_conn
, STREAM_EVENT_NEW
, 0);
2232 control_event_stream_status(ap_conn
, STREAM_EVENT_SENT_RESOLVE
, 0);
2236 /** Make an AP connection_t, make a new linked connection pair, and attach
2237 * one side to the conn, connection_add it, initialize it to circuit_wait,
2238 * and call connection_ap_handshake_attach_circuit(conn) on it.
2240 * Return the other end of the linked connection pair, or -1 if error.
2243 connection_ap_make_link(char *address
, uint16_t port
,
2244 const char *digest
, int use_begindir
, int want_onehop
)
2246 edge_connection_t
*conn
;
2248 log_info(LD_APP
,"Making internal %s tunnel to %s:%d ...",
2249 want_onehop
? "direct" : "anonymized" , safe_str(address
),port
);
2251 conn
= edge_connection_new(CONN_TYPE_AP
, AF_INET
);
2252 conn
->_base
.linked
= 1; /* so that we can add it safely below. */
2254 /* populate conn->socks_request */
2256 /* leave version at zero, so the socks_reply is empty */
2257 conn
->socks_request
->socks_version
= 0;
2258 conn
->socks_request
->has_finished
= 0; /* waiting for 'connected' */
2259 strlcpy(conn
->socks_request
->address
, address
,
2260 sizeof(conn
->socks_request
->address
));
2261 conn
->socks_request
->port
= port
;
2262 conn
->socks_request
->command
= SOCKS_COMMAND_CONNECT
;
2263 conn
->want_onehop
= want_onehop
;
2264 conn
->use_begindir
= use_begindir
;
2266 conn
->chosen_exit_name
= tor_malloc(HEX_DIGEST_LEN
+2);
2267 conn
->chosen_exit_name
[0] = '$';
2269 base16_encode(conn
->chosen_exit_name
+1,HEX_DIGEST_LEN
+1,
2270 digest
, DIGEST_LEN
);
2273 conn
->_base
.address
= tor_strdup("(Tor_internal)");
2274 tor_addr_make_unspec(&conn
->_base
.addr
);
2275 conn
->_base
.port
= 0;
2277 if (connection_add(TO_CONN(conn
)) < 0) { /* no space, forget it */
2278 connection_free(TO_CONN(conn
));
2282 conn
->_base
.state
= AP_CONN_STATE_CIRCUIT_WAIT
;
2284 control_event_stream_status(conn
, STREAM_EVENT_NEW
, 0);
2286 /* attaching to a dirty circuit is fine */
2287 if (connection_ap_handshake_attach_circuit(conn
) < 0) {
2288 if (!conn
->_base
.marked_for_close
)
2289 connection_mark_unattached_ap(conn
, END_STREAM_REASON_CANT_ATTACH
);
2293 log_info(LD_APP
,"... application connection created and linked.");
2297 /** Notify any interested controller connections about a new hostname resolve
2298 * or resolve error. Takes the same arguments as does
2299 * connection_ap_handshake_socks_resolved(). */
2301 tell_controller_about_resolved_result(edge_connection_t
*conn
,
2309 if (ttl
>= 0 && (answer_type
== RESOLVED_TYPE_IPV4
||
2310 answer_type
== RESOLVED_TYPE_HOSTNAME
)) {
2311 return; /* we already told the controller. */
2312 } else if (answer_type
== RESOLVED_TYPE_IPV4
&& answer_len
>= 4) {
2314 char buf
[INET_NTOA_BUF_LEN
];
2315 in
.s_addr
= get_uint32(answer
);
2316 tor_inet_ntoa(&in
, buf
, sizeof(buf
));
2317 control_event_address_mapped(conn
->socks_request
->address
,
2318 buf
, expires
, NULL
);
2319 } else if (answer_type
== RESOLVED_TYPE_HOSTNAME
&& answer_len
<256) {
2320 char *cp
= tor_strndup(answer
, answer_len
);
2321 control_event_address_mapped(conn
->socks_request
->address
,
2325 control_event_address_mapped(conn
->socks_request
->address
,
2332 /** Send an answer to an AP connection that has requested a DNS lookup via
2333 * SOCKS. The type should be one of RESOLVED_TYPE_(IPV4|IPV6|HOSTNAME) or -1
2334 * for unreachable; the answer should be in the format specified in the socks
2335 * extensions document. <b>ttl</b> is the ttl for the answer, or -1 on
2336 * certain errors or for values that didn't come via DNS. <b>expires</b> is
2337 * a time when the answer expires, or -1 or TIME_MAX if there's a good TTL.
2339 /* XXXX022 the use of the ttl and expires fields is nutty. Let's make this
2340 * interface and those that use it less ugly. */
2342 connection_ap_handshake_socks_resolved(edge_connection_t
*conn
,
2345 const uint8_t *answer
,
2353 if (answer_type
== RESOLVED_TYPE_IPV4
&& answer_len
== 4) {
2354 uint32_t a
= ntohl(get_uint32(answer
));
2356 client_dns_set_addressmap(conn
->socks_request
->address
, a
,
2357 conn
->chosen_exit_name
, ttl
);
2358 } else if (answer_type
== RESOLVED_TYPE_HOSTNAME
&& answer_len
< 256) {
2359 char *cp
= tor_strndup((char*)answer
, answer_len
);
2360 client_dns_set_reverse_addressmap(conn
->socks_request
->address
,
2362 conn
->chosen_exit_name
, ttl
);
2367 if (conn
->is_dns_request
) {
2368 if (conn
->dns_server_request
) {
2369 /* We had a request on our DNS port: answer it. */
2370 dnsserv_resolved(conn
, answer_type
, answer_len
, (char*)answer
, ttl
);
2371 conn
->socks_request
->has_finished
= 1;
2374 /* This must be a request from the controller. We already sent
2375 * a mapaddress if there's a ttl. */
2376 tell_controller_about_resolved_result(conn
, answer_type
, answer_len
,
2377 (char*)answer
, ttl
, expires
);
2378 conn
->socks_request
->has_finished
= 1;
2381 /* We shouldn't need to free conn here; it gets marked by the caller. */
2384 if (conn
->socks_request
->socks_version
== 4) {
2385 buf
[0] = 0x00; /* version */
2386 if (answer_type
== RESOLVED_TYPE_IPV4
&& answer_len
== 4) {
2387 buf
[1] = SOCKS4_GRANTED
;
2388 set_uint16(buf
+2, 0);
2389 memcpy(buf
+4, answer
, 4); /* address */
2390 replylen
= SOCKS4_NETWORK_LEN
;
2391 } else { /* "error" */
2392 buf
[1] = SOCKS4_REJECT
;
2393 memset(buf
+2, 0, 6);
2394 replylen
= SOCKS4_NETWORK_LEN
;
2396 } else if (conn
->socks_request
->socks_version
== 5) {
2398 buf
[0] = 0x05; /* version */
2399 if (answer_type
== RESOLVED_TYPE_IPV4
&& answer_len
== 4) {
2400 buf
[1] = SOCKS5_SUCCEEDED
;
2401 buf
[2] = 0; /* reserved */
2402 buf
[3] = 0x01; /* IPv4 address type */
2403 memcpy(buf
+4, answer
, 4); /* address */
2404 set_uint16(buf
+8, 0); /* port == 0. */
2406 } else if (answer_type
== RESOLVED_TYPE_IPV6
&& answer_len
== 16) {
2407 buf
[1] = SOCKS5_SUCCEEDED
;
2408 buf
[2] = 0; /* reserved */
2409 buf
[3] = 0x04; /* IPv6 address type */
2410 memcpy(buf
+4, answer
, 16); /* address */
2411 set_uint16(buf
+20, 0); /* port == 0. */
2413 } else if (answer_type
== RESOLVED_TYPE_HOSTNAME
&& answer_len
< 256) {
2414 buf
[1] = SOCKS5_SUCCEEDED
;
2415 buf
[2] = 0; /* reserved */
2416 buf
[3] = 0x03; /* Domainname address type */
2417 buf
[4] = (char)answer_len
;
2418 memcpy(buf
+5, answer
, answer_len
); /* address */
2419 set_uint16(buf
+5+answer_len
, 0); /* port == 0. */
2420 replylen
= 5+answer_len
+2;
2422 buf
[1] = SOCKS5_HOST_UNREACHABLE
;
2423 memset(buf
+2, 0, 8);
2427 /* no socks version info; don't send anything back */
2430 connection_ap_handshake_socks_reply(conn
, buf
, replylen
,
2431 (answer_type
== RESOLVED_TYPE_IPV4
||
2432 answer_type
== RESOLVED_TYPE_IPV6
) ?
2433 0 : END_STREAM_REASON_RESOLVEFAILED
);
2436 /** Send a socks reply to stream <b>conn</b>, using the appropriate
2437 * socks version, etc, and mark <b>conn</b> as completed with SOCKS
2440 * If <b>reply</b> is defined, then write <b>replylen</b> bytes of it to conn
2441 * and return, else reply based on <b>endreason</b> (one of
2442 * END_STREAM_REASON_*). If <b>reply</b> is undefined, <b>endreason</b> can't
2443 * be 0 or REASON_DONE. Send endreason to the controller, if appropriate.
2446 connection_ap_handshake_socks_reply(edge_connection_t
*conn
, char *reply
,
2447 size_t replylen
, int endreason
)
2450 socks5_reply_status_t status
=
2451 stream_end_reason_to_socks5_response(endreason
);
2453 tor_assert(conn
->socks_request
); /* make sure it's an AP stream */
2455 control_event_stream_status(conn
,
2456 status
==SOCKS5_SUCCEEDED
? STREAM_EVENT_SUCCEEDED
: STREAM_EVENT_FAILED
,
2459 if (conn
->socks_request
->has_finished
) {
2460 log_warn(LD_BUG
, "(Harmless.) duplicate calls to "
2461 "connection_ap_handshake_socks_reply.");
2464 if (replylen
) { /* we already have a reply in mind */
2465 connection_write_to_buf(reply
, replylen
, TO_CONN(conn
));
2466 conn
->socks_request
->has_finished
= 1;
2469 if (conn
->socks_request
->socks_version
== 4) {
2470 memset(buf
,0,SOCKS4_NETWORK_LEN
);
2471 buf
[1] = (status
==SOCKS5_SUCCEEDED
? SOCKS4_GRANTED
: SOCKS4_REJECT
);
2472 /* leave version, destport, destip zero */
2473 connection_write_to_buf(buf
, SOCKS4_NETWORK_LEN
, TO_CONN(conn
));
2474 } else if (conn
->socks_request
->socks_version
== 5) {
2475 buf
[0] = 5; /* version 5 */
2476 buf
[1] = (char)status
;
2478 buf
[3] = 1; /* ipv4 addr */
2479 memset(buf
+4,0,6); /* Set external addr/port to 0.
2480 The spec doesn't seem to say what to do here. -RD */
2481 connection_write_to_buf(buf
,10,TO_CONN(conn
));
2483 /* If socks_version isn't 4 or 5, don't send anything.
2484 * This can happen in the case of AP bridges. */
2485 conn
->socks_request
->has_finished
= 1;
2489 /** A relay 'begin' or 'begin_dir' cell has arrived, and either we are
2490 * an exit hop for the circuit, or we are the origin and it is a
2493 * Launch a new exit connection and initialize things appropriately.
2495 * If it's a rendezvous stream, call connection_exit_connect() on
2498 * For general streams, call dns_resolve() on it first, and only call
2499 * connection_exit_connect() if the dns answer is already known.
2501 * Note that we don't call connection_add() on the new stream! We wait
2502 * for connection_exit_connect() to do that.
2504 * Return -(some circuit end reason) if we want to tear down <b>circ</b>.
2508 connection_exit_begin_conn(cell_t
*cell
, circuit_t
*circ
)
2510 edge_connection_t
*n_stream
;
2514 or_circuit_t
*or_circ
= NULL
;
2516 assert_circuit_ok(circ
);
2517 if (!CIRCUIT_IS_ORIGIN(circ
))
2518 or_circ
= TO_OR_CIRCUIT(circ
);
2520 relay_header_unpack(&rh
, cell
->payload
);
2521 if (rh
.length
> RELAY_PAYLOAD_SIZE
)
2524 /* Note: we have to use relay_send_command_from_edge here, not
2525 * connection_edge_end or connection_edge_send_command, since those require
2526 * that we have a stream connected to a circuit, and we don't connect to a
2527 * circuit until we have a pending/successful resolve. */
2529 if (!server_mode(get_options()) &&
2530 circ
->purpose
!= CIRCUIT_PURPOSE_S_REND_JOINED
) {
2531 log_fn(LOG_PROTOCOL_WARN
, LD_PROTOCOL
,
2532 "Relay begin cell at non-server. Closing.");
2533 relay_send_end_cell_from_edge(rh
.stream_id
, circ
,
2534 END_STREAM_REASON_EXITPOLICY
, NULL
);
2538 if (rh
.command
== RELAY_COMMAND_BEGIN
) {
2539 if (!memchr(cell
->payload
+RELAY_HEADER_SIZE
, 0, rh
.length
)) {
2540 log_fn(LOG_PROTOCOL_WARN
, LD_PROTOCOL
,
2541 "Relay begin cell has no \\0. Closing.");
2542 relay_send_end_cell_from_edge(rh
.stream_id
, circ
,
2543 END_STREAM_REASON_TORPROTOCOL
, NULL
);
2546 if (parse_addr_port(LOG_PROTOCOL_WARN
,
2547 (char*)(cell
->payload
+RELAY_HEADER_SIZE
),
2548 &address
,NULL
,&port
)<0) {
2549 log_fn(LOG_PROTOCOL_WARN
, LD_PROTOCOL
,
2550 "Unable to parse addr:port in relay begin cell. Closing.");
2551 relay_send_end_cell_from_edge(rh
.stream_id
, circ
,
2552 END_STREAM_REASON_TORPROTOCOL
, NULL
);
2556 log_fn(LOG_PROTOCOL_WARN
, LD_PROTOCOL
,
2557 "Missing port in relay begin cell. Closing.");
2558 relay_send_end_cell_from_edge(rh
.stream_id
, circ
,
2559 END_STREAM_REASON_TORPROTOCOL
, NULL
);
2563 if (or_circ
&& or_circ
->is_first_hop
&&
2564 !get_options()->AllowSingleHopExits
) {
2565 /* Don't let clients use us as a single-hop proxy, unless the user
2566 * has explicitly allowed that in the config. It attracts attackers
2567 * and users who'd be better off with, well, single-hop proxies.
2569 log_fn(LOG_PROTOCOL_WARN
, LD_PROTOCOL
,
2570 "Attempt to open a stream on first hop of circuit. Closing.");
2571 relay_send_end_cell_from_edge(rh
.stream_id
, circ
,
2572 END_STREAM_REASON_TORPROTOCOL
, NULL
);
2576 } else if (rh
.command
== RELAY_COMMAND_BEGIN_DIR
) {
2577 if (!directory_permits_begindir_requests(get_options()) ||
2578 circ
->purpose
!= CIRCUIT_PURPOSE_OR
) {
2579 relay_send_end_cell_from_edge(rh
.stream_id
, circ
,
2580 END_STREAM_REASON_NOTDIRECTORY
, NULL
);
2583 /* Make sure to get the 'real' address of the previous hop: the
2584 * caller might want to know whether his IP address has changed, and
2585 * we might already have corrected _base.addr[ess] for the relay's
2586 * canonical IP address. */
2587 if (or_circ
&& or_circ
->p_conn
)
2588 address
= tor_dup_addr(&or_circ
->p_conn
->real_addr
);
2590 address
= tor_strdup("127.0.0.1");
2591 port
= 1; /* XXXX This value is never actually used anywhere, and there
2592 * isn't "really" a connection here. But we
2593 * need to set it to something nonzero. */
2595 log_warn(LD_BUG
, "Got an unexpected command %d", (int)rh
.command
);
2596 relay_send_end_cell_from_edge(rh
.stream_id
, circ
,
2597 END_STREAM_REASON_INTERNAL
, NULL
);
2601 log_debug(LD_EXIT
,"Creating new exit connection.");
2602 n_stream
= edge_connection_new(CONN_TYPE_EXIT
, AF_INET
);
2603 n_stream
->_base
.purpose
= EXIT_PURPOSE_CONNECT
;
2605 n_stream
->stream_id
= rh
.stream_id
;
2606 n_stream
->_base
.port
= port
;
2607 /* leave n_stream->s at -1, because it's not yet valid */
2608 n_stream
->package_window
= STREAMWINDOW_START
;
2609 n_stream
->deliver_window
= STREAMWINDOW_START
;
2611 if (circ
->purpose
== CIRCUIT_PURPOSE_S_REND_JOINED
) {
2612 origin_circuit_t
*origin_circ
= TO_ORIGIN_CIRCUIT(circ
);
2613 log_info(LD_REND
,"begin is for rendezvous. configuring stream.");
2614 n_stream
->_base
.address
= tor_strdup("(rendezvous)");
2615 n_stream
->_base
.state
= EXIT_CONN_STATE_CONNECTING
;
2616 n_stream
->rend_data
= rend_data_dup(origin_circ
->rend_data
);
2617 tor_assert(connection_edge_is_rendezvous_stream(n_stream
));
2618 assert_circuit_ok(circ
);
2619 if (rend_service_set_connection_addr_port(n_stream
, origin_circ
) < 0) {
2620 log_info(LD_REND
,"Didn't find rendezvous service (port %d)",
2621 n_stream
->_base
.port
);
2622 relay_send_end_cell_from_edge(rh
.stream_id
, circ
,
2623 END_STREAM_REASON_EXITPOLICY
,
2624 origin_circ
->cpath
->prev
);
2625 connection_free(TO_CONN(n_stream
));
2629 assert_circuit_ok(circ
);
2630 log_debug(LD_REND
,"Finished assigning addr/port");
2631 n_stream
->cpath_layer
= origin_circ
->cpath
->prev
; /* link it */
2633 /* add it into the linked list of n_streams on this circuit */
2634 n_stream
->next_stream
= origin_circ
->p_streams
;
2635 n_stream
->on_circuit
= circ
;
2636 origin_circ
->p_streams
= n_stream
;
2637 assert_circuit_ok(circ
);
2639 connection_exit_connect(n_stream
);
2643 tor_strlower(address
);
2644 n_stream
->_base
.address
= address
;
2645 n_stream
->_base
.state
= EXIT_CONN_STATE_RESOLVEFAILED
;
2646 /* default to failed, change in dns_resolve if it turns out not to fail */
2648 if (we_are_hibernating()) {
2649 relay_send_end_cell_from_edge(rh
.stream_id
, circ
,
2650 END_STREAM_REASON_HIBERNATING
, NULL
);
2651 connection_free(TO_CONN(n_stream
));
2655 n_stream
->on_circuit
= circ
;
2657 if (rh
.command
== RELAY_COMMAND_BEGIN_DIR
) {
2658 tor_assert(or_circ
);
2659 if (or_circ
->p_conn
&& !tor_addr_is_null(&or_circ
->p_conn
->real_addr
))
2660 tor_addr_assign(&n_stream
->_base
.addr
, &or_circ
->p_conn
->real_addr
);
2661 return connection_exit_connect_dir(n_stream
);
2664 log_debug(LD_EXIT
,"about to start the dns_resolve().");
2666 /* send it off to the gethostbyname farm */
2667 switch (dns_resolve(n_stream
)) {
2668 case 1: /* resolve worked; now n_stream is attached to circ. */
2669 assert_circuit_ok(circ
);
2670 log_debug(LD_EXIT
,"about to call connection_exit_connect().");
2671 connection_exit_connect(n_stream
);
2673 case -1: /* resolve failed */
2674 relay_send_end_cell_from_edge(rh
.stream_id
, circ
,
2675 END_STREAM_REASON_RESOLVEFAILED
, NULL
);
2676 /* n_stream got freed. don't touch it. */
2678 case 0: /* resolve added to pending list */
2679 assert_circuit_ok(circ
);
2686 * Called when we receive a RELAY_COMMAND_RESOLVE cell 'cell' along the
2687 * circuit <b>circ</b>;
2688 * begin resolving the hostname, and (eventually) reply with a RESOLVED cell.
2691 connection_exit_begin_resolve(cell_t
*cell
, or_circuit_t
*circ
)
2693 edge_connection_t
*dummy_conn
;
2696 assert_circuit_ok(TO_CIRCUIT(circ
));
2697 relay_header_unpack(&rh
, cell
->payload
);
2698 if (rh
.length
> RELAY_PAYLOAD_SIZE
)
2701 /* This 'dummy_conn' only exists to remember the stream ID
2702 * associated with the resolve request; and to make the
2703 * implementation of dns.c more uniform. (We really only need to
2704 * remember the circuit, the stream ID, and the hostname to be
2705 * resolved; but if we didn't store them in a connection like this,
2706 * the housekeeping in dns.c would get way more complicated.)
2708 dummy_conn
= edge_connection_new(CONN_TYPE_EXIT
, AF_INET
);
2709 dummy_conn
->stream_id
= rh
.stream_id
;
2710 dummy_conn
->_base
.address
= tor_strndup(
2711 (char*)cell
->payload
+RELAY_HEADER_SIZE
,
2713 dummy_conn
->_base
.port
= 0;
2714 dummy_conn
->_base
.state
= EXIT_CONN_STATE_RESOLVEFAILED
;
2715 dummy_conn
->_base
.purpose
= EXIT_PURPOSE_RESOLVE
;
2717 dummy_conn
->on_circuit
= TO_CIRCUIT(circ
);
2719 /* send it off to the gethostbyname farm */
2720 switch (dns_resolve(dummy_conn
)) {
2721 case -1: /* Impossible to resolve; a resolved cell was sent. */
2722 /* Connection freed; don't touch it. */
2724 case 1: /* The result was cached; a resolved cell was sent. */
2725 if (!dummy_conn
->_base
.marked_for_close
)
2726 connection_free(TO_CONN(dummy_conn
));
2728 case 0: /* resolve added to pending list */
2729 assert_circuit_ok(TO_CIRCUIT(circ
));
2735 /** Connect to conn's specified addr and port. If it worked, conn
2736 * has now been added to the connection_array.
2738 * Send back a connected cell. Include the resolved IP of the destination
2739 * address, but <em>only</em> if it's a general exit stream. (Rendezvous
2740 * streams must not reveal what IP they connected to.)
2743 connection_exit_connect(edge_connection_t
*edge_conn
)
2745 const tor_addr_t
*addr
;
2747 connection_t
*conn
= TO_CONN(edge_conn
);
2748 int socket_error
= 0;
2750 if (!connection_edge_is_rendezvous_stream(edge_conn
) &&
2751 router_compare_to_my_exit_policy(edge_conn
)) {
2752 log_info(LD_EXIT
,"%s:%d failed exit policy. Closing.",
2753 escaped_safe_str(conn
->address
), conn
->port
);
2754 connection_edge_end(edge_conn
, END_STREAM_REASON_EXITPOLICY
);
2755 circuit_detach_stream(circuit_get_by_edge_conn(edge_conn
), edge_conn
);
2756 connection_free(conn
);
2763 log_debug(LD_EXIT
,"about to try connecting");
2764 switch (connection_connect(conn
, conn
->address
, addr
, port
, &socket_error
)) {
2766 /* XXX021 use socket_error below rather than trying to piece things
2767 * together from the current errno, which may have been clobbered. */
2768 connection_edge_end_errno(edge_conn
);
2769 circuit_detach_stream(circuit_get_by_edge_conn(edge_conn
), edge_conn
);
2770 connection_free(conn
);
2773 conn
->state
= EXIT_CONN_STATE_CONNECTING
;
2775 connection_watch_events(conn
, EV_WRITE
| EV_READ
);
2776 /* writable indicates finish;
2777 * readable/error indicates broken link in windows-land. */
2779 /* case 1: fall through */
2782 conn
->state
= EXIT_CONN_STATE_OPEN
;
2783 if (connection_wants_to_flush(conn
)) {
2784 /* in case there are any queued data cells */
2785 log_warn(LD_BUG
,"newly connected conn had data waiting!");
2786 // connection_start_writing(conn);
2788 connection_watch_events(conn
, EV_READ
);
2790 /* also, deliver a 'connected' cell back through the circuit. */
2791 if (connection_edge_is_rendezvous_stream(edge_conn
)) {
2792 /* rendezvous stream */
2793 /* don't send an address back! */
2794 connection_edge_send_command(edge_conn
,
2795 RELAY_COMMAND_CONNECTED
,
2797 } else { /* normal stream */
2798 char connected_payload
[20];
2799 int connected_payload_len
;
2800 if (tor_addr_family(&conn
->addr
) == AF_INET
) {
2801 set_uint32(connected_payload
, tor_addr_to_ipv4n(&conn
->addr
));
2802 connected_payload_len
= 4;
2804 memcpy(connected_payload
, tor_addr_to_in6_addr8(&conn
->addr
), 16);
2805 connected_payload_len
= 16;
2807 set_uint32(connected_payload
+connected_payload_len
,
2808 htonl(dns_clip_ttl(edge_conn
->address_ttl
)));
2809 connected_payload_len
+= 4;
2810 connection_edge_send_command(edge_conn
,
2811 RELAY_COMMAND_CONNECTED
,
2812 connected_payload
, connected_payload_len
);
2816 /** Given an exit conn that should attach to us as a directory server, open a
2817 * bridge connection with a linked connection pair, create a new directory
2818 * conn, and join them together. Return 0 on success (or if there was an
2819 * error we could send back an end cell for). Return -(some circuit end
2820 * reason) if the circuit needs to be torn down. Either connects
2821 * <b>exitconn</b>, frees it, or marks it, as appropriate.
2824 connection_exit_connect_dir(edge_connection_t
*exitconn
)
2826 dir_connection_t
*dirconn
= NULL
;
2827 or_circuit_t
*circ
= TO_OR_CIRCUIT(exitconn
->on_circuit
);
2829 log_info(LD_EXIT
, "Opening local connection for anonymized directory exit");
2831 exitconn
->_base
.state
= EXIT_CONN_STATE_OPEN
;
2833 dirconn
= dir_connection_new(AF_INET
);
2835 tor_addr_assign(&dirconn
->_base
.addr
, &exitconn
->_base
.addr
);
2836 dirconn
->_base
.port
= 0;
2837 dirconn
->_base
.address
= tor_strdup(exitconn
->_base
.address
);
2838 dirconn
->_base
.type
= CONN_TYPE_DIR
;
2839 dirconn
->_base
.purpose
= DIR_PURPOSE_SERVER
;
2840 dirconn
->_base
.state
= DIR_CONN_STATE_SERVER_COMMAND_WAIT
;
2842 connection_link_connections(TO_CONN(dirconn
), TO_CONN(exitconn
));
2844 if (connection_add(TO_CONN(exitconn
))<0) {
2845 connection_edge_end(exitconn
, END_STREAM_REASON_RESOURCELIMIT
);
2846 connection_free(TO_CONN(exitconn
));
2847 connection_free(TO_CONN(dirconn
));
2851 /* link exitconn to circ, now that we know we can use it. */
2852 exitconn
->next_stream
= circ
->n_streams
;
2853 circ
->n_streams
= exitconn
;
2855 if (connection_add(TO_CONN(dirconn
))<0) {
2856 connection_edge_end(exitconn
, END_STREAM_REASON_RESOURCELIMIT
);
2857 connection_close_immediate(TO_CONN(exitconn
));
2858 connection_mark_for_close(TO_CONN(exitconn
));
2859 connection_free(TO_CONN(dirconn
));
2863 connection_start_reading(TO_CONN(dirconn
));
2864 connection_start_reading(TO_CONN(exitconn
));
2866 if (connection_edge_send_command(exitconn
,
2867 RELAY_COMMAND_CONNECTED
, NULL
, 0) < 0) {
2868 connection_mark_for_close(TO_CONN(exitconn
));
2869 connection_mark_for_close(TO_CONN(dirconn
));
2876 /** Return 1 if <b>conn</b> is a rendezvous stream, or 0 if
2877 * it is a general stream.
2880 connection_edge_is_rendezvous_stream(edge_connection_t
*conn
)
2883 if (conn
->rend_data
)
2888 /** Return 1 if router <b>exit</b> is likely to allow stream <b>conn</b>
2889 * to exit from it, or 0 if it probably will not allow it.
2890 * (We might be uncertain if conn's destination address has not yet been
2894 connection_ap_can_use_exit(edge_connection_t
*conn
, routerinfo_t
*exit
)
2897 tor_assert(conn
->_base
.type
== CONN_TYPE_AP
);
2898 tor_assert(conn
->socks_request
);
2901 /* If a particular exit node has been requested for the new connection,
2902 * make sure the exit node of the existing circuit matches exactly.
2904 if (conn
->chosen_exit_name
) {
2905 routerinfo_t
*chosen_exit
=
2906 router_get_by_nickname(conn
->chosen_exit_name
, 1);
2907 if (!chosen_exit
|| tor_memneq(chosen_exit
->cache_info
.identity_digest
,
2908 exit
->cache_info
.identity_digest
, DIGEST_LEN
)) {
2910 // log_debug(LD_APP,"Requested node '%s', considering node '%s'. No.",
2911 // conn->chosen_exit_name, exit->nickname);
2916 if (conn
->socks_request
->command
== SOCKS_COMMAND_CONNECT
&&
2917 !conn
->use_begindir
) {
2920 addr_policy_result_t r
;
2921 if (tor_inet_aton(conn
->socks_request
->address
, &in
))
2922 addr
= ntohl(in
.s_addr
);
2923 r
= compare_addr_to_addr_policy(addr
, conn
->socks_request
->port
,
2925 if (r
== ADDR_POLICY_REJECTED
)
2926 return 0; /* We know the address, and the exit policy rejects it. */
2927 if (r
== ADDR_POLICY_PROBABLY_REJECTED
&& !conn
->chosen_exit_name
)
2928 return 0; /* We don't know the addr, but the exit policy rejects most
2929 * addresses with this port. Since the user didn't ask for
2930 * this node, err on the side of caution. */
2931 } else if (SOCKS_COMMAND_IS_RESOLVE(conn
->socks_request
->command
)) {
2932 /* Can't support reverse lookups without eventdns. */
2933 if (conn
->socks_request
->command
== SOCKS_COMMAND_RESOLVE_PTR
&&
2934 exit
->has_old_dnsworkers
)
2937 /* Don't send DNS requests to non-exit servers by default. */
2938 if (!conn
->chosen_exit_name
&& policy_is_reject_star(exit
->exit_policy
))
2944 /** If address is of the form "y.onion" with a well-formed handle y:
2945 * Put a NUL after y, lower-case it, and return ONION_HOSTNAME.
2947 * If address is of the form "y.exit":
2948 * Put a NUL after y and return EXIT_HOSTNAME.
2951 * Return NORMAL_HOSTNAME and change nothing.
2954 parse_extended_hostname(char *address
)
2957 char query
[REND_SERVICE_ID_LEN_BASE32
+1];
2959 s
= strrchr(address
,'.');
2961 return NORMAL_HOSTNAME
; /* no dot, thus normal */
2962 if (!strcmp(s
+1,"exit")) {
2963 *s
= 0; /* NUL-terminate it */
2964 return EXIT_HOSTNAME
; /* .exit */
2966 if (strcmp(s
+1,"onion"))
2967 return NORMAL_HOSTNAME
; /* neither .exit nor .onion, thus normal */
2969 /* so it is .onion */
2970 *s
= 0; /* NUL-terminate it */
2971 if (strlcpy(query
, address
, REND_SERVICE_ID_LEN_BASE32
+1) >=
2972 REND_SERVICE_ID_LEN_BASE32
+1)
2974 if (rend_valid_service_id(query
)) {
2975 return ONION_HOSTNAME
; /* success */
2978 /* otherwise, return to previous state and return 0 */
2980 return BAD_HOSTNAME
;
2983 /** Check if the address is of the form "y.noconnect"
2986 hostname_is_noconnect_address(const char *address
)
2988 return ! strcasecmpend(address
, ".noconnect");