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-2016, The Tor Project, Inc. */
5 /* See LICENSE for licensing information */
9 * \brief Launch the right sort of circuits and attach streams to them.
13 #include "addressmap.h"
15 #include "circpathbias.h"
16 #include "circuitbuild.h"
17 #include "circuitlist.h"
18 #include "circuitstats.h"
19 #include "circuituse.h"
21 #include "connection.h"
22 #include "connection_edge.h"
24 #include "entrynodes.h"
26 #include "networkstatus.h"
28 #include "rendclient.h"
29 #include "rendcommon.h"
30 #include "rendservice.h"
33 #include "routerlist.h"
35 static void circuit_expire_old_circuits_clientside(void);
36 static void circuit_increment_failure_count(void);
38 /** Return 1 if <b>circ</b> could be returned by circuit_get_best().
42 circuit_is_acceptable(const origin_circuit_t
*origin_circ
,
43 const entry_connection_t
*conn
,
44 int must_be_open
, uint8_t purpose
,
45 int need_uptime
, int need_internal
,
48 const circuit_t
*circ
= TO_CIRCUIT(origin_circ
);
49 const node_t
*exitnode
;
50 cpath_build_state_t
*build_state
;
53 tor_assert(conn
->socks_request
);
55 if (must_be_open
&& (circ
->state
!= CIRCUIT_STATE_OPEN
|| !circ
->n_chan
))
56 return 0; /* ignore non-open circs */
57 if (circ
->marked_for_close
)
60 /* if this circ isn't our purpose, skip. */
61 if (purpose
== CIRCUIT_PURPOSE_C_REND_JOINED
&& !must_be_open
) {
62 if (circ
->purpose
!= CIRCUIT_PURPOSE_C_ESTABLISH_REND
&&
63 circ
->purpose
!= CIRCUIT_PURPOSE_C_REND_READY
&&
64 circ
->purpose
!= CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED
&&
65 circ
->purpose
!= CIRCUIT_PURPOSE_C_REND_JOINED
)
67 } else if (purpose
== CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
&&
69 if (circ
->purpose
!= CIRCUIT_PURPOSE_C_INTRODUCING
&&
70 circ
->purpose
!= CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
)
73 if (purpose
!= circ
->purpose
)
77 /* If this is a timed-out hidden service circuit, skip it. */
78 if (origin_circ
->hs_circ_has_timed_out
) {
82 if (purpose
== CIRCUIT_PURPOSE_C_GENERAL
||
83 purpose
== CIRCUIT_PURPOSE_C_REND_JOINED
) {
84 if (circ
->timestamp_dirty
&&
85 circ
->timestamp_dirty
+get_options()->MaxCircuitDirtiness
<= now
)
89 if (origin_circ
->unusable_for_new_conns
)
92 /* decide if this circ is suitable for this conn */
94 /* for rend circs, circ->cpath->prev is not the last router in the
95 * circuit, it's the magical extra service hop. so just check the nickname
96 * of the one we meant to finish at.
98 build_state
= origin_circ
->build_state
;
99 exitnode
= build_state_get_exit_node(build_state
);
101 if (need_uptime
&& !build_state
->need_uptime
)
103 if (need_internal
!= build_state
->is_internal
)
106 if (purpose
== CIRCUIT_PURPOSE_C_GENERAL
) {
108 const int family
= tor_addr_parse(&addr
, conn
->socks_request
->address
);
109 if (!exitnode
&& !build_state
->onehop_tunnel
) {
110 log_debug(LD_CIRC
,"Not considering circuit with unknown router.");
111 return 0; /* this circuit is screwed and doesn't know it yet,
112 * or is a rendezvous circuit. */
114 if (build_state
->onehop_tunnel
) {
115 if (!conn
->want_onehop
) {
116 log_debug(LD_CIRC
,"Skipping one-hop circuit.");
119 tor_assert(conn
->chosen_exit_name
);
120 if (build_state
->chosen_exit
) {
121 char digest
[DIGEST_LEN
];
122 if (hexdigest_to_digest(conn
->chosen_exit_name
, digest
) < 0)
123 return 0; /* broken digest, we don't want it */
124 if (tor_memneq(digest
, build_state
->chosen_exit
->identity_digest
,
126 return 0; /* this is a circuit to somewhere else */
127 if (tor_digest_is_zero(digest
)) {
128 /* we don't know the digest; have to compare addr:port */
130 !tor_addr_eq(&build_state
->chosen_exit
->addr
, &addr
) ||
131 build_state
->chosen_exit
->port
!= conn
->socks_request
->port
)
136 if (conn
->want_onehop
) {
137 /* don't use three-hop circuits -- that could hurt our anonymity. */
141 if (origin_circ
->prepend_policy
&& family
!= -1) {
142 int r
= compare_tor_addr_to_addr_policy(&addr
,
143 conn
->socks_request
->port
,
144 origin_circ
->prepend_policy
);
145 if (r
== ADDR_POLICY_REJECTED
)
148 if (exitnode
&& !connection_ap_can_use_exit(conn
, exitnode
)) {
149 /* can't exit from this router */
152 } else { /* not general */
153 const edge_connection_t
*edge_conn
= ENTRY_TO_EDGE_CONN(conn
);
154 if ((edge_conn
->rend_data
&& !origin_circ
->rend_data
) ||
155 (!edge_conn
->rend_data
&& origin_circ
->rend_data
) ||
156 (edge_conn
->rend_data
&& origin_circ
->rend_data
&&
157 rend_cmp_service_ids(edge_conn
->rend_data
->onion_address
,
158 origin_circ
->rend_data
->onion_address
))) {
159 /* this circ is not for this conn */
164 if (!connection_edge_compatible_with_circuit(conn
, origin_circ
)) {
165 /* conn needs to be isolated from other conns that have already used
173 /** Return 1 if circuit <b>a</b> is better than circuit <b>b</b> for
174 * <b>conn</b>, and return 0 otherwise. Used by circuit_get_best.
177 circuit_is_better(const origin_circuit_t
*oa
, const origin_circuit_t
*ob
,
178 const entry_connection_t
*conn
)
180 const circuit_t
*a
= TO_CIRCUIT(oa
);
181 const circuit_t
*b
= TO_CIRCUIT(ob
);
182 const uint8_t purpose
= ENTRY_TO_CONN(conn
)->purpose
;
185 /* If one of the circuits was allowed to live due to relaxing its timeout,
186 * it is definitely worse (it's probably a much slower path). */
187 if (oa
->relaxed_timeout
&& !ob
->relaxed_timeout
)
188 return 0; /* ob is better. It's not relaxed. */
189 if (!oa
->relaxed_timeout
&& ob
->relaxed_timeout
)
190 return 1; /* oa is better. It's not relaxed. */
193 case CIRCUIT_PURPOSE_C_GENERAL
:
194 /* if it's used but less dirty it's best;
195 * else if it's more recently created it's best
197 if (b
->timestamp_dirty
) {
198 if (a
->timestamp_dirty
&&
199 a
->timestamp_dirty
> b
->timestamp_dirty
)
202 if (a
->timestamp_dirty
||
203 timercmp(&a
->timestamp_began
, &b
->timestamp_began
, OP_GT
))
205 if (ob
->build_state
->is_internal
)
206 /* XXXX++ what the heck is this internal thing doing here. I
207 * think we can get rid of it. circuit_is_acceptable() already
208 * makes sure that is_internal is exactly what we need it to
213 case CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
:
214 /* the closer it is to ack_wait the better it is */
215 if (a
->purpose
> b
->purpose
)
218 case CIRCUIT_PURPOSE_C_REND_JOINED
:
219 /* the closer it is to rend_joined the better it is */
220 if (a
->purpose
> b
->purpose
)
225 /* XXXX Maybe this check should get a higher priority to avoid
226 * using up circuits too rapidly. */
228 a_bits
= connection_edge_update_circuit_isolation(conn
,
229 (origin_circuit_t
*)oa
, 1);
230 b_bits
= connection_edge_update_circuit_isolation(conn
,
231 (origin_circuit_t
*)ob
, 1);
232 /* if x_bits < 0, then we have not used x for anything; better not to dirty
233 * a connection if we can help it. */
236 } else if (b_bits
< 0) {
239 a_bits
&= ~ oa
->isolation_flags_mixed
;
240 a_bits
&= ~ ob
->isolation_flags_mixed
;
241 if (n_bits_set_u8(a_bits
) < n_bits_set_u8(b_bits
)) {
242 /* The fewer new restrictions we need to make on a circuit for stream
243 * isolation, the better. */
250 /** Find the best circ that conn can use, preferably one which is
251 * dirty. Circ must not be too old.
253 * Conn must be defined.
255 * If must_be_open, ignore circs not in CIRCUIT_STATE_OPEN.
257 * circ_purpose specifies what sort of circuit we must have.
258 * It can be C_GENERAL, C_INTRODUCE_ACK_WAIT, or C_REND_JOINED.
260 * If it's REND_JOINED and must_be_open==0, then return the closest
261 * rendezvous-purposed circuit that you can find.
263 * If it's INTRODUCE_ACK_WAIT and must_be_open==0, then return the
264 * closest introduce-purposed circuit that you can find.
266 static origin_circuit_t
*
267 circuit_get_best(const entry_connection_t
*conn
,
268 int must_be_open
, uint8_t purpose
,
269 int need_uptime
, int need_internal
)
271 origin_circuit_t
*best
=NULL
;
273 int intro_going_on_but_too_old
= 0;
277 tor_assert(purpose
== CIRCUIT_PURPOSE_C_GENERAL
||
278 purpose
== CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
||
279 purpose
== CIRCUIT_PURPOSE_C_REND_JOINED
);
281 tor_gettimeofday(&now
);
283 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
284 origin_circuit_t
*origin_circ
;
285 if (!CIRCUIT_IS_ORIGIN(circ
))
287 origin_circ
= TO_ORIGIN_CIRCUIT(circ
);
289 /* Log an info message if we're going to launch a new intro circ in
291 if (purpose
== CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
&&
292 !must_be_open
&& origin_circ
->hs_circ_has_timed_out
) {
293 intro_going_on_but_too_old
= 1;
297 if (!circuit_is_acceptable(origin_circ
,conn
,must_be_open
,purpose
,
298 need_uptime
,need_internal
, (time_t)now
.tv_sec
))
301 /* now this is an acceptable circ to hand back. but that doesn't
302 * mean it's the *best* circ to hand back. try to decide.
304 if (!best
|| circuit_is_better(origin_circ
,best
,conn
))
307 SMARTLIST_FOREACH_END(circ
);
309 if (!best
&& intro_going_on_but_too_old
)
310 log_info(LD_REND
|LD_CIRC
, "There is an intro circuit being created "
311 "right now, but it has already taken quite a while. Starting "
317 /** Return the number of not-yet-open general-purpose origin circuits. */
319 count_pending_general_client_circuits(void)
323 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
324 if (circ
->marked_for_close
||
325 circ
->state
== CIRCUIT_STATE_OPEN
||
326 circ
->purpose
!= CIRCUIT_PURPOSE_C_GENERAL
||
327 !CIRCUIT_IS_ORIGIN(circ
))
332 SMARTLIST_FOREACH_END(circ
);
338 /** Check whether, according to the policies in <b>options</b>, the
339 * circuit <b>circ</b> makes sense. */
340 /* XXXX currently only checks Exclude{Exit}Nodes; it should check more.
341 * Also, it doesn't have the right definition of an exit circuit. Also,
342 * it's never called. */
344 circuit_conforms_to_options(const origin_circuit_t
*circ
,
345 const or_options_t
*options
)
347 const crypt_path_t
*cpath
, *cpath_next
= NULL
;
349 /* first check if it includes any excluded nodes */
350 for (cpath
= circ
->cpath
; cpath_next
!= circ
->cpath
; cpath
= cpath_next
) {
351 cpath_next
= cpath
->next
;
352 if (routerset_contains_extendinfo(options
->ExcludeNodes
,
357 /* then consider the final hop */
358 if (routerset_contains_extendinfo(options
->ExcludeExitNodes
,
359 circ
->cpath
->prev
->extend_info
))
366 /** Close all circuits that start at us, aren't open, and were born
367 * at least CircuitBuildTimeout seconds ago.
370 circuit_expire_building(void)
372 /* circ_times.timeout_ms and circ_times.close_ms are from
373 * circuit_build_times_get_initial_timeout() if we haven't computed
374 * custom timeouts yet */
375 struct timeval general_cutoff
, begindir_cutoff
, fourhop_cutoff
,
376 close_cutoff
, extremely_old_cutoff
, hs_extremely_old_cutoff
,
377 cannibalized_cutoff
, c_intro_cutoff
, s_intro_cutoff
, stream_cutoff
;
378 const or_options_t
*options
= get_options();
380 cpath_build_state_t
*build_state
;
381 int any_opened_circs
= 0;
383 tor_gettimeofday(&now
);
385 /* Check to see if we have any opened circuits. If we don't,
386 * we want to be more lenient with timeouts, in case the
387 * user has relocated and/or changed network connections.
389 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, next_circ
) {
390 if (!CIRCUIT_IS_ORIGIN(next_circ
) || /* didn't originate here */
391 next_circ
->marked_for_close
) { /* don't mess with marked circs */
395 if (TO_ORIGIN_CIRCUIT(next_circ
)->has_opened
&&
396 next_circ
->state
== CIRCUIT_STATE_OPEN
&&
397 TO_ORIGIN_CIRCUIT(next_circ
)->build_state
&&
398 TO_ORIGIN_CIRCUIT(next_circ
)->build_state
->desired_path_len
399 == DEFAULT_ROUTE_LEN
) {
400 any_opened_circs
= 1;
403 } SMARTLIST_FOREACH_END(next_circ
);
405 #define SET_CUTOFF(target, msec) do { \
406 long ms = tor_lround(msec); \
407 struct timeval diff; \
408 diff.tv_sec = ms / 1000; \
409 diff.tv_usec = (int)((ms % 1000) * 1000); \
410 timersub(&now, &diff, &target); \
414 * Because circuit build timeout is calculated only based on 3 hop
415 * general purpose circuit construction, we need to scale the timeout
416 * to make it properly apply to longer circuits, and circuits of
417 * certain usage types. The following diagram illustrates how we
418 * derive the scaling below. In short, we calculate the number
419 * of times our telescoping-based circuit construction causes cells
420 * to traverse each link for the circuit purpose types in question,
421 * and then assume each link is equivalent.
423 * OP --a--> A --b--> B --c--> C
424 * OP --a--> A --b--> B --c--> C --d--> D
426 * Let h = a = b = c = d
428 * Three hops (general_cutoff)
435 * RTTs = 4a + 3b + 2c + d
437 * Client INTRODUCE1+ACK: // XXX: correct?
438 * RTTs = 5a + 4b + 3c + 2d
441 * RTTs = 4a + 3b + 2c
444 SET_CUTOFF(general_cutoff
, get_circuit_build_timeout_ms());
445 SET_CUTOFF(begindir_cutoff
, get_circuit_build_timeout_ms());
447 /* > 3hop circs seem to have a 1.0 second delay on their cannibalized
449 SET_CUTOFF(fourhop_cutoff
, get_circuit_build_timeout_ms() * (10/6.0) + 1000);
451 /* CIRCUIT_PURPOSE_C_ESTABLISH_REND behaves more like a RELAY cell.
452 * Use the stream cutoff (more or less). */
453 SET_CUTOFF(stream_cutoff
, MAX(options
->CircuitStreamTimeout
,15)*1000 + 1000);
455 /* Be lenient with cannibalized circs. They already survived the official
456 * CBT, and they're usually not performance-critical. */
457 SET_CUTOFF(cannibalized_cutoff
,
458 MAX(get_circuit_build_close_time_ms()*(4/6.0),
459 options
->CircuitStreamTimeout
* 1000) + 1000);
461 /* Intro circs have an extra round trip (and are also 4 hops long) */
462 SET_CUTOFF(c_intro_cutoff
, get_circuit_build_timeout_ms() * (14/6.0) + 1000);
464 /* Server intro circs have an extra round trip */
465 SET_CUTOFF(s_intro_cutoff
, get_circuit_build_timeout_ms() * (9/6.0) + 1000);
467 SET_CUTOFF(close_cutoff
, get_circuit_build_close_time_ms());
468 SET_CUTOFF(extremely_old_cutoff
, get_circuit_build_close_time_ms()*2 + 1000);
470 SET_CUTOFF(hs_extremely_old_cutoff
,
471 MAX(get_circuit_build_close_time_ms()*2 + 1000,
472 options
->SocksTimeout
* 1000));
474 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*,victim
) {
475 struct timeval cutoff
;
476 if (!CIRCUIT_IS_ORIGIN(victim
) || /* didn't originate here */
477 victim
->marked_for_close
) /* don't mess with marked circs */
480 /* If we haven't yet started the first hop, it means we don't have
481 * any orconns available, and thus have not started counting time yet
482 * for this circuit. See circuit_deliver_create_cell() and uses of
485 * Continue to wait in this case. The ORConn should timeout
486 * independently and kill us then.
488 if (TO_ORIGIN_CIRCUIT(victim
)->cpath
->state
== CPATH_STATE_CLOSED
) {
492 build_state
= TO_ORIGIN_CIRCUIT(victim
)->build_state
;
493 if (build_state
&& build_state
->onehop_tunnel
)
494 cutoff
= begindir_cutoff
;
495 else if (victim
->purpose
== CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT
)
496 cutoff
= close_cutoff
;
497 else if (victim
->purpose
== CIRCUIT_PURPOSE_C_INTRODUCING
||
498 victim
->purpose
== CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
)
499 cutoff
= c_intro_cutoff
;
500 else if (victim
->purpose
== CIRCUIT_PURPOSE_S_ESTABLISH_INTRO
)
501 cutoff
= s_intro_cutoff
;
502 else if (victim
->purpose
== CIRCUIT_PURPOSE_C_ESTABLISH_REND
)
503 cutoff
= stream_cutoff
;
504 else if (victim
->purpose
== CIRCUIT_PURPOSE_PATH_BIAS_TESTING
)
505 cutoff
= close_cutoff
;
506 else if (TO_ORIGIN_CIRCUIT(victim
)->has_opened
&&
507 victim
->state
!= CIRCUIT_STATE_OPEN
)
508 cutoff
= cannibalized_cutoff
;
509 else if (build_state
&& build_state
->desired_path_len
>= 4)
510 cutoff
= fourhop_cutoff
;
512 cutoff
= general_cutoff
;
514 if (TO_ORIGIN_CIRCUIT(victim
)->hs_circ_has_timed_out
)
515 cutoff
= hs_extremely_old_cutoff
;
517 if (timercmp(&victim
->timestamp_began
, &cutoff
, OP_GT
))
518 continue; /* it's still young, leave it alone */
520 /* We need to double-check the opened state here because
521 * we don't want to consider opened 1-hop dircon circuits for
522 * deciding when to relax the timeout, but we *do* want to relax
523 * those circuits too if nothing else is opened *and* they still
525 if (!any_opened_circs
&& victim
->state
!= CIRCUIT_STATE_OPEN
) {
526 /* It's still young enough that we wouldn't close it, right? */
527 if (timercmp(&victim
->timestamp_began
, &close_cutoff
, OP_GT
)) {
528 if (!TO_ORIGIN_CIRCUIT(victim
)->relaxed_timeout
) {
529 int first_hop_succeeded
= TO_ORIGIN_CIRCUIT(victim
)->cpath
->state
532 "No circuits are opened. Relaxing timeout for circuit %d "
533 "(a %s %d-hop circuit in state %s with channel state %s). "
534 "%d guards are live.",
535 TO_ORIGIN_CIRCUIT(victim
)->global_identifier
,
536 circuit_purpose_to_string(victim
->purpose
),
537 TO_ORIGIN_CIRCUIT(victim
)->build_state
?
538 TO_ORIGIN_CIRCUIT(victim
)->build_state
->desired_path_len
:
540 circuit_state_to_string(victim
->state
),
541 channel_state_to_string(victim
->n_chan
->state
),
542 num_live_entry_guards(0));
544 /* We count the timeout here for CBT, because technically this
545 * was a timeout, and the timeout value needs to reset if we
546 * see enough of them. Note this means we also need to avoid
547 * double-counting below, too. */
548 circuit_build_times_count_timeout(get_circuit_build_times_mutable(),
549 first_hop_succeeded
);
550 TO_ORIGIN_CIRCUIT(victim
)->relaxed_timeout
= 1;
554 static ratelim_t relax_timeout_limit
= RATELIM_INIT(3600);
555 const double build_close_ms
= get_circuit_build_close_time_ms();
556 log_fn_ratelim(&relax_timeout_limit
, LOG_NOTICE
, LD_CIRC
,
557 "No circuits are opened. Relaxed timeout for circuit %d "
558 "(a %s %d-hop circuit in state %s with channel state %s) to "
559 "%ldms. However, it appears the circuit has timed out "
560 "anyway. %d guards are live.",
561 TO_ORIGIN_CIRCUIT(victim
)->global_identifier
,
562 circuit_purpose_to_string(victim
->purpose
),
563 TO_ORIGIN_CIRCUIT(victim
)->build_state
?
564 TO_ORIGIN_CIRCUIT(victim
)->build_state
->desired_path_len
:
566 circuit_state_to_string(victim
->state
),
567 channel_state_to_string(victim
->n_chan
->state
),
568 (long)build_close_ms
,
569 num_live_entry_guards(0));
574 /* some debug logs, to help track bugs */
575 if (victim
->purpose
>= CIRCUIT_PURPOSE_C_INTRODUCING
&&
576 victim
->purpose
<= CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED
) {
577 if (!victim
->timestamp_dirty
)
578 log_fn(LOG_DEBUG
,"Considering %sopen purpose %d to %s (circid %d)."
580 victim
->state
== CIRCUIT_STATE_OPEN
? "" : "non",
581 victim
->purpose
, victim
->build_state
->chosen_exit_name
,
584 log_fn(LOG_DEBUG
,"Considering %sopen purpose %d to %s (circid %d). "
585 "%d secs since dirty.",
586 victim
->state
== CIRCUIT_STATE_OPEN
? "" : "non",
587 victim
->purpose
, victim
->build_state
->chosen_exit_name
,
589 (int)(now
- victim
->timestamp_dirty
));
593 /* if circ is !open, or if it's open but purpose is a non-finished
594 * intro or rend, then mark it for close */
595 if (victim
->state
== CIRCUIT_STATE_OPEN
) {
596 switch (victim
->purpose
) {
597 default: /* most open circuits can be left alone. */
598 continue; /* yes, continue inside a switch refers to the nearest
599 * enclosing loop. C is smart. */
600 case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO
:
601 break; /* too old, need to die */
602 case CIRCUIT_PURPOSE_C_REND_READY
:
603 /* it's a rend_ready circ -- has it already picked a query? */
604 /* c_rend_ready circs measure age since timestamp_dirty,
605 * because that's set when they switch purposes
607 if (TO_ORIGIN_CIRCUIT(victim
)->rend_data
||
608 victim
->timestamp_dirty
> cutoff
.tv_sec
)
611 case CIRCUIT_PURPOSE_PATH_BIAS_TESTING
:
612 /* Open path bias testing circuits are given a long
613 * time to complete the test, but not forever */
614 TO_ORIGIN_CIRCUIT(victim
)->path_state
= PATH_STATE_USE_FAILED
;
616 case CIRCUIT_PURPOSE_C_INTRODUCING
:
617 /* We keep old introducing circuits around for
618 * a while in parallel, and they can end up "opened".
619 * We decide below if we're going to mark them timed
620 * out and eventually close them.
623 case CIRCUIT_PURPOSE_C_ESTABLISH_REND
:
624 case CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED
:
625 case CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
:
626 /* rend and intro circs become dirty each time they
627 * make an introduction attempt. so timestamp_dirty
628 * will reflect the time since the last attempt.
630 if (victim
->timestamp_dirty
> cutoff
.tv_sec
)
634 } else { /* circuit not open, consider recording failure as timeout */
635 int first_hop_succeeded
= TO_ORIGIN_CIRCUIT(victim
)->cpath
&&
636 TO_ORIGIN_CIRCUIT(victim
)->cpath
->state
== CPATH_STATE_OPEN
;
638 if (TO_ORIGIN_CIRCUIT(victim
)->p_streams
!= NULL
) {
639 log_warn(LD_BUG
, "Circuit %d (purpose %d, %s) has timed out, "
640 "yet has attached streams!",
641 TO_ORIGIN_CIRCUIT(victim
)->global_identifier
,
643 circuit_purpose_to_string(victim
->purpose
));
644 tor_fragile_assert();
648 if (circuit_timeout_want_to_count_circ(TO_ORIGIN_CIRCUIT(victim
)) &&
649 circuit_build_times_enough_to_compute(get_circuit_build_times())) {
650 /* Circuits are allowed to last longer for measurement.
651 * Switch their purpose and wait. */
652 if (victim
->purpose
!= CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT
) {
653 control_event_circuit_status(TO_ORIGIN_CIRCUIT(victim
),
655 END_CIRC_REASON_TIMEOUT
);
656 circuit_change_purpose(victim
, CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT
);
657 /* Record this failure to check for too many timeouts
658 * in a row. This function does not record a time value yet
659 * (we do that later); it only counts the fact that we did
660 * have a timeout. We also want to avoid double-counting
661 * already "relaxed" circuits, which are counted above. */
662 if (!TO_ORIGIN_CIRCUIT(victim
)->relaxed_timeout
) {
663 circuit_build_times_count_timeout(
664 get_circuit_build_times_mutable(),
665 first_hop_succeeded
);
671 * If the circuit build time is much greater than we would have cut
672 * it off at, we probably had a suspend event along this codepath,
673 * and we should discard the value.
675 if (timercmp(&victim
->timestamp_began
, &extremely_old_cutoff
, OP_LT
)) {
677 "Extremely large value for circuit build timeout: %lds. "
678 "Assuming clock jump. Purpose %d (%s)",
679 (long)(now
.tv_sec
- victim
->timestamp_began
.tv_sec
),
681 circuit_purpose_to_string(victim
->purpose
));
682 } else if (circuit_build_times_count_close(
683 get_circuit_build_times_mutable(),
685 (time_t)victim
->timestamp_created
.tv_sec
)) {
686 circuit_build_times_set_timeout(get_circuit_build_times_mutable());
691 /* If this is a hidden service client circuit which is far enough
692 * along in connecting to its destination, and we haven't already
693 * flagged it as 'timed out', and the user has not told us to
694 * close such circs immediately on timeout, flag it as 'timed out'
695 * so we'll launch another intro or rend circ, but don't mark it
698 * (Circs flagged as 'timed out' are given a much longer timeout
699 * period above, so we won't close them in the next call to
700 * circuit_expire_building.) */
701 if (!(options
->CloseHSClientCircuitsImmediatelyOnTimeout
) &&
702 !(TO_ORIGIN_CIRCUIT(victim
)->hs_circ_has_timed_out
)) {
703 switch (victim
->purpose
) {
704 case CIRCUIT_PURPOSE_C_REND_READY
:
705 /* We only want to spare a rend circ if it has been specified in
706 * an INTRODUCE1 cell sent to a hidden service. A circ's
707 * pending_final_cpath field is non-NULL iff it is a rend circ
708 * and we have tried to send an INTRODUCE1 cell specifying it.
709 * Thus, if the pending_final_cpath field *is* NULL, then we
710 * want to not spare it. */
711 if (TO_ORIGIN_CIRCUIT(victim
)->build_state
&&
712 TO_ORIGIN_CIRCUIT(victim
)->build_state
->pending_final_cpath
==
716 case CIRCUIT_PURPOSE_C_INTRODUCING
:
717 /* connection_ap_handshake_attach_circuit() will relaunch for us */
718 case CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
:
719 case CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED
:
720 /* If we have reached this line, we want to spare the circ for now. */
721 log_info(LD_CIRC
,"Marking circ %u (state %d:%s, purpose %d) "
722 "as timed-out HS circ",
723 (unsigned)victim
->n_circ_id
,
724 victim
->state
, circuit_state_to_string(victim
->state
),
726 TO_ORIGIN_CIRCUIT(victim
)->hs_circ_has_timed_out
= 1;
733 /* If this is a service-side rendezvous circuit which is far
734 * enough along in connecting to its destination, consider sparing
736 if (!(options
->CloseHSServiceRendCircuitsImmediatelyOnTimeout
) &&
737 !(TO_ORIGIN_CIRCUIT(victim
)->hs_circ_has_timed_out
) &&
738 victim
->purpose
== CIRCUIT_PURPOSE_S_CONNECT_REND
) {
739 log_info(LD_CIRC
,"Marking circ %u (state %d:%s, purpose %d) "
740 "as timed-out HS circ; relaunching rendezvous attempt.",
741 (unsigned)victim
->n_circ_id
,
742 victim
->state
, circuit_state_to_string(victim
->state
),
744 TO_ORIGIN_CIRCUIT(victim
)->hs_circ_has_timed_out
= 1;
745 rend_service_relaunch_rendezvous(TO_ORIGIN_CIRCUIT(victim
));
751 "Abandoning circ %u %s:%u (state %d,%d:%s, purpose %d, "
752 "len %d)", TO_ORIGIN_CIRCUIT(victim
)->global_identifier
,
753 channel_get_canonical_remote_descr(victim
->n_chan
),
754 (unsigned)victim
->n_circ_id
,
755 TO_ORIGIN_CIRCUIT(victim
)->has_opened
,
756 victim
->state
, circuit_state_to_string(victim
->state
),
758 TO_ORIGIN_CIRCUIT(victim
)->build_state
?
759 TO_ORIGIN_CIRCUIT(victim
)->build_state
->desired_path_len
:
763 "Abandoning circ %u %u (state %d,%d:%s, purpose %d, len %d)",
764 TO_ORIGIN_CIRCUIT(victim
)->global_identifier
,
765 (unsigned)victim
->n_circ_id
,
766 TO_ORIGIN_CIRCUIT(victim
)->has_opened
,
768 circuit_state_to_string(victim
->state
), victim
->purpose
,
769 TO_ORIGIN_CIRCUIT(victim
)->build_state
?
770 TO_ORIGIN_CIRCUIT(victim
)->build_state
->desired_path_len
:
773 circuit_log_path(LOG_INFO
,LD_CIRC
,TO_ORIGIN_CIRCUIT(victim
));
774 if (victim
->purpose
== CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT
)
775 circuit_mark_for_close(victim
, END_CIRC_REASON_MEASUREMENT_EXPIRED
);
777 circuit_mark_for_close(victim
, END_CIRC_REASON_TIMEOUT
);
779 pathbias_count_timeout(TO_ORIGIN_CIRCUIT(victim
));
780 } SMARTLIST_FOREACH_END(victim
);
783 /** For debugging #8387: track when we last called
784 * circuit_expire_old_circuits_clientside. */
785 static time_t last_expired_clientside_circuits
= 0;
788 * As a diagnostic for bug 8387, log information about how many one-hop
789 * circuits we have around that have been there for at least <b>age</b>
790 * seconds. Log a few of them.
791 * Ignores Single Onion Service intro and Tor2web redezvous circuits, they are
792 * expected to be long-term one-hop circuits.
795 circuit_log_ancient_one_hop_circuits(int age
)
797 #define MAX_ANCIENT_ONEHOP_CIRCUITS_TO_LOG 10
798 time_t now
= time(NULL
);
799 time_t cutoff
= now
- age
;
801 smartlist_t
*log_these
= smartlist_new();
802 const or_options_t
*options
= get_options();
804 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
805 const origin_circuit_t
*ocirc
;
806 if (! CIRCUIT_IS_ORIGIN(circ
))
808 if (circ
->timestamp_created
.tv_sec
>= cutoff
)
810 /* Single Onion Services deliberately make long term one-hop intro
811 * and rendezvous connections. Don't log the established ones. */
812 if (rend_service_allow_non_anonymous_connection(options
) &&
813 (circ
->purpose
== CIRCUIT_PURPOSE_S_INTRO
||
814 circ
->purpose
== CIRCUIT_PURPOSE_S_REND_JOINED
))
816 /* Tor2web deliberately makes long term one-hop rend connections,
817 * particularly when Tor2webRendezvousPoints is used. We only ignore
818 * active rend point connections, if we take a long time to rendezvous,
819 * that's worth logging. */
820 if (rend_client_allow_non_anonymous_connection(options
) &&
821 circ
->purpose
== CIRCUIT_PURPOSE_C_REND_JOINED
)
823 ocirc
= CONST_TO_ORIGIN_CIRCUIT(circ
);
825 if (ocirc
->build_state
&& ocirc
->build_state
->onehop_tunnel
) {
828 if (smartlist_len(log_these
) < MAX_ANCIENT_ONEHOP_CIRCUITS_TO_LOG
)
829 smartlist_add(log_these
, (origin_circuit_t
*) ocirc
);
832 SMARTLIST_FOREACH_END(circ
);
837 log_notice(LD_HEARTBEAT
,
838 "Diagnostic for issue 8387: Found %d one-hop circuits more "
839 "than %d seconds old! Logging %d...",
840 n_found
, age
, smartlist_len(log_these
));
842 SMARTLIST_FOREACH_BEGIN(log_these
, const origin_circuit_t
*, ocirc
) {
843 char created
[ISO_TIME_LEN
+1];
845 const edge_connection_t
*conn
;
847 const circuit_t
*circ
= TO_CIRCUIT(ocirc
);
849 format_local_iso_time(created
,
850 (time_t)circ
->timestamp_created
.tv_sec
);
852 if (circ
->timestamp_dirty
) {
853 char dirty_since
[ISO_TIME_LEN
+1];
854 format_local_iso_time(dirty_since
, circ
->timestamp_dirty
);
856 tor_asprintf(&dirty
, "Dirty since %s (%ld seconds vs %ld-second cutoff)",
857 dirty_since
, (long)(now
- circ
->timestamp_dirty
),
858 (long) options
->MaxCircuitDirtiness
);
860 dirty
= tor_strdup("Not marked dirty");
863 log_notice(LD_HEARTBEAT
, " #%d created at %s. %s, %s. %s for close. "
864 "Package window: %d. "
865 "%s for new conns. %s.",
868 circuit_state_to_string(circ
->state
),
869 circuit_purpose_to_string(circ
->purpose
),
870 circ
->marked_for_close
? "Marked" : "Not marked",
871 circ
->package_window
,
872 ocirc
->unusable_for_new_conns
? "Not usable" : "usable",
877 for (conn
= ocirc
->p_streams
; conn
; conn
= conn
->next_stream
) {
878 const connection_t
*c
= TO_CONN(conn
);
879 char stream_created
[ISO_TIME_LEN
+1];
880 if (++stream_num
>= 5)
883 format_local_iso_time(stream_created
, c
->timestamp_created
);
885 log_notice(LD_HEARTBEAT
, " Stream#%d created at %s. "
886 "%s conn in state %s. "
887 "It is %slinked and %sreading from a linked connection %p. "
888 "Package window %d. "
889 "%s for close (%s:%d). Hold-open is %sset. "
890 "Has %ssent RELAY_END. %s on circuit.",
893 conn_type_to_string(c
->type
),
894 conn_state_to_string(c
->type
, c
->state
),
895 c
->linked
? "" : "not ",
896 c
->reading_from_linked_conn
? "": "not",
898 conn
->package_window
,
899 c
->marked_for_close
? "Marked" : "Not marked",
900 c
->marked_for_close_file
? c
->marked_for_close_file
: "--",
902 c
->hold_open_until_flushed
? "" : "not ",
903 conn
->edge_has_sent_end
? "" : "not ",
904 conn
->edge_blocked_on_circ
? "Blocked" : "Not blocked");
905 if (! c
->linked_conn
)
910 log_notice(LD_HEARTBEAT
, " Linked to %s connection in state %s "
911 "(Purpose %d). %s for close (%s:%d). Hold-open is %sset. ",
912 conn_type_to_string(c
->type
),
913 conn_state_to_string(c
->type
, c
->state
),
915 c
->marked_for_close
? "Marked" : "Not marked",
916 c
->marked_for_close_file
? c
->marked_for_close_file
: "--",
918 c
->hold_open_until_flushed
? "" : "not ");
920 } SMARTLIST_FOREACH_END(ocirc
);
922 log_notice(LD_HEARTBEAT
, "It has been %ld seconds since I last called "
923 "circuit_expire_old_circuits_clientside().",
924 (long)(now
- last_expired_clientside_circuits
));
927 smartlist_free(log_these
);
930 /** Remove any elements in <b>needed_ports</b> that are handled by an
931 * open or in-progress circuit.
934 circuit_remove_handled_ports(smartlist_t
*needed_ports
)
939 for (i
= 0; i
< smartlist_len(needed_ports
); ++i
) {
940 port
= smartlist_get(needed_ports
, i
);
942 if (circuit_stream_is_being_handled(NULL
, *port
,
943 MIN_CIRCUITS_HANDLING_STREAM
)) {
944 // log_debug(LD_CIRC,"Port %d is already being handled; removing.", port);
945 smartlist_del(needed_ports
, i
--);
948 log_debug(LD_CIRC
,"Port %d is not handled.", *port
);
953 /** Return 1 if at least <b>min</b> general-purpose non-internal circuits
954 * will have an acceptable exit node for exit stream <b>conn</b> if it
955 * is defined, else for "*:port".
959 circuit_stream_is_being_handled(entry_connection_t
*conn
,
960 uint16_t port
, int min
)
962 const node_t
*exitnode
;
964 time_t now
= time(NULL
);
965 int need_uptime
= smartlist_contains_int_as_string(
966 get_options()->LongLivedPorts
,
967 conn
? conn
->socks_request
->port
: port
);
969 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
970 if (CIRCUIT_IS_ORIGIN(circ
) &&
971 !circ
->marked_for_close
&&
972 circ
->purpose
== CIRCUIT_PURPOSE_C_GENERAL
&&
973 (!circ
->timestamp_dirty
||
974 circ
->timestamp_dirty
+ get_options()->MaxCircuitDirtiness
> now
)) {
975 origin_circuit_t
*origin_circ
= TO_ORIGIN_CIRCUIT(circ
);
976 cpath_build_state_t
*build_state
= origin_circ
->build_state
;
977 if (build_state
->is_internal
|| build_state
->onehop_tunnel
)
979 if (origin_circ
->unusable_for_new_conns
)
982 exitnode
= build_state_get_exit_node(build_state
);
983 if (exitnode
&& (!need_uptime
|| build_state
->need_uptime
)) {
986 ok
= connection_ap_can_use_exit(conn
, exitnode
);
988 addr_policy_result_t r
;
989 r
= compare_tor_addr_to_node_policy(NULL
, port
, exitnode
);
990 ok
= r
!= ADDR_POLICY_REJECTED
&& r
!= ADDR_POLICY_PROBABLY_REJECTED
;
999 SMARTLIST_FOREACH_END(circ
);
1003 /** Don't keep more than this many unused open circuits around. */
1004 #define MAX_UNUSED_OPEN_CIRCUITS 14
1006 /** Figure out how many circuits we have open that are clean. Make
1007 * sure it's enough for all the upcoming behaviors we predict we'll have.
1008 * But put an upper bound on the total number of circuits.
1011 circuit_predict_and_launch_new(void)
1013 int num
=0, num_internal
=0, num_uptime_internal
=0;
1014 int hidserv_needs_uptime
=0, hidserv_needs_capacity
=1;
1015 int port_needs_uptime
=0, port_needs_capacity
=1;
1016 time_t now
= time(NULL
);
1019 /* First, count how many of each type of circuit we have already. */
1020 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
1021 cpath_build_state_t
*build_state
;
1022 origin_circuit_t
*origin_circ
;
1023 if (!CIRCUIT_IS_ORIGIN(circ
))
1025 if (circ
->marked_for_close
)
1026 continue; /* don't mess with marked circs */
1027 if (circ
->timestamp_dirty
)
1028 continue; /* only count clean circs */
1029 if (circ
->purpose
!= CIRCUIT_PURPOSE_C_GENERAL
)
1030 continue; /* only pay attention to general-purpose circs */
1031 origin_circ
= TO_ORIGIN_CIRCUIT(circ
);
1032 if (origin_circ
->unusable_for_new_conns
)
1034 build_state
= origin_circ
->build_state
;
1035 if (build_state
->onehop_tunnel
)
1038 if (build_state
->is_internal
)
1040 if (build_state
->need_uptime
&& build_state
->is_internal
)
1041 num_uptime_internal
++;
1043 SMARTLIST_FOREACH_END(circ
);
1045 /* If that's enough, then stop now. */
1046 if (num
>= MAX_UNUSED_OPEN_CIRCUITS
)
1047 return; /* we already have many, making more probably will hurt */
1049 /* Second, see if we need any more exit circuits. */
1050 /* check if we know of a port that's been requested recently
1051 * and no circuit is currently available that can handle it.
1052 * Exits (obviously) require an exit circuit. */
1053 if (!circuit_all_predicted_ports_handled(now
, &port_needs_uptime
,
1054 &port_needs_capacity
)
1055 && router_have_consensus_path() == CONSENSUS_PATH_EXIT
) {
1056 if (port_needs_uptime
)
1057 flags
|= CIRCLAUNCH_NEED_UPTIME
;
1058 if (port_needs_capacity
)
1059 flags
|= CIRCLAUNCH_NEED_CAPACITY
;
1061 "Have %d clean circs (%d internal), need another exit circ.",
1063 circuit_launch(CIRCUIT_PURPOSE_C_GENERAL
, flags
);
1067 /* Third, see if we need any more hidden service (server) circuits.
1068 * HS servers only need an internal circuit. */
1069 if (num_rend_services() && num_uptime_internal
< 3
1070 && router_have_consensus_path() != CONSENSUS_PATH_UNKNOWN
) {
1071 flags
= (CIRCLAUNCH_NEED_CAPACITY
| CIRCLAUNCH_NEED_UPTIME
|
1072 CIRCLAUNCH_IS_INTERNAL
);
1074 "Have %d clean circs (%d internal), need another internal "
1075 "circ for my hidden service.",
1077 circuit_launch(CIRCUIT_PURPOSE_C_GENERAL
, flags
);
1081 /* Fourth, see if we need any more hidden service (client) circuits.
1082 * HS clients only need an internal circuit. */
1083 if (rep_hist_get_predicted_internal(now
, &hidserv_needs_uptime
,
1084 &hidserv_needs_capacity
) &&
1085 ((num_uptime_internal
<2 && hidserv_needs_uptime
) ||
1087 && router_have_consensus_path() != CONSENSUS_PATH_UNKNOWN
) {
1088 if (hidserv_needs_uptime
)
1089 flags
|= CIRCLAUNCH_NEED_UPTIME
;
1090 if (hidserv_needs_capacity
)
1091 flags
|= CIRCLAUNCH_NEED_CAPACITY
;
1092 flags
|= CIRCLAUNCH_IS_INTERNAL
;
1094 "Have %d clean circs (%d uptime-internal, %d internal), need"
1095 " another hidden service circ.",
1096 num
, num_uptime_internal
, num_internal
);
1097 circuit_launch(CIRCUIT_PURPOSE_C_GENERAL
, flags
);
1101 /* Finally, check to see if we still need more circuits to learn
1102 * a good build timeout. But if we're close to our max number we
1103 * want, don't do another -- we want to leave a few slots open so
1104 * we can still build circuits preemptively as needed.
1105 * XXXX make the assumption that build timeout streams should be
1106 * created whenever we can build internal circuits. */
1107 if (router_have_consensus_path() != CONSENSUS_PATH_UNKNOWN
) {
1108 if (num
< MAX_UNUSED_OPEN_CIRCUITS
-2 &&
1109 ! circuit_build_times_disabled() &&
1110 circuit_build_times_needs_circuits_now(get_circuit_build_times())) {
1111 flags
= CIRCLAUNCH_NEED_CAPACITY
;
1112 /* if there are no exits in the consensus, make timeout
1113 * circuits internal */
1114 if (router_have_consensus_path() == CONSENSUS_PATH_INTERNAL
)
1115 flags
|= CIRCLAUNCH_IS_INTERNAL
;
1117 "Have %d clean circs need another buildtime test circ.", num
);
1118 circuit_launch(CIRCUIT_PURPOSE_C_GENERAL
, flags
);
1124 /** Build a new test circuit every 5 minutes */
1125 #define TESTING_CIRCUIT_INTERVAL 300
1127 /** This function is called once a second, if router_have_min_dir_info() is
1128 * true. Its job is to make sure all services we offer have enough circuits
1129 * available. Some services just want enough circuits for current tasks,
1130 * whereas others want a minimum set of idle circuits hanging around.
1133 circuit_build_needed_circs(time_t now
)
1135 const or_options_t
*options
= get_options();
1137 /* launch a new circ for any pending streams that need one
1138 * XXXX make the assumption that (some) AP streams (i.e. HS clients)
1139 * don't require an exit circuit, review in #13814.
1140 * This allows HSs to function in a consensus without exits. */
1141 if (router_have_consensus_path() != CONSENSUS_PATH_UNKNOWN
)
1142 connection_ap_rescan_and_attach_pending();
1144 /* make sure any hidden services have enough intro points
1145 * HS intro point streams only require an internal circuit */
1146 if (router_have_consensus_path() != CONSENSUS_PATH_UNKNOWN
)
1147 rend_consider_services_intro_points();
1149 circuit_expire_old_circs_as_needed(now
);
1151 if (!options
->DisablePredictedCircuits
)
1152 circuit_predict_and_launch_new();
1156 * Called once a second either directly or from
1157 * circuit_build_needed_circs(). As appropriate (once per NewCircuitPeriod)
1158 * resets failure counts and expires old circuits.
1161 circuit_expire_old_circs_as_needed(time_t now
)
1163 static time_t time_to_expire_and_reset
= 0;
1165 if (time_to_expire_and_reset
< now
) {
1166 circuit_reset_failure_count(1);
1167 time_to_expire_and_reset
= now
+ get_options()->NewCircuitPeriod
;
1168 if (proxy_mode(get_options()))
1169 addressmap_clean(now
);
1170 circuit_expire_old_circuits_clientside();
1172 #if 0 /* disable for now, until predict-and-launch-new can cull leftovers */
1174 /* If we ever re-enable, this has to move into
1175 * circuit_build_needed_circs */
1177 circ
= circuit_get_youngest_clean_open(CIRCUIT_PURPOSE_C_GENERAL
);
1178 if (get_options()->RunTesting
&&
1180 circ
->timestamp_began
.tv_sec
+ TESTING_CIRCUIT_INTERVAL
< now
) {
1181 log_fn(LOG_INFO
,"Creating a new testing circuit.");
1182 circuit_launch(CIRCUIT_PURPOSE_C_GENERAL
, 0);
1188 /** If the stream <b>conn</b> is a member of any of the linked
1189 * lists of <b>circ</b>, then remove it from the list.
1192 circuit_detach_stream(circuit_t
*circ
, edge_connection_t
*conn
)
1194 edge_connection_t
*prevconn
;
1199 if (conn
->base_
.type
== CONN_TYPE_AP
) {
1200 entry_connection_t
*entry_conn
= EDGE_TO_ENTRY_CONN(conn
);
1201 entry_conn
->may_use_optimistic_data
= 0;
1203 conn
->cpath_layer
= NULL
; /* don't keep a stale pointer */
1204 conn
->on_circuit
= NULL
;
1206 if (CIRCUIT_IS_ORIGIN(circ
)) {
1207 origin_circuit_t
*origin_circ
= TO_ORIGIN_CIRCUIT(circ
);
1209 if (conn
== origin_circ
->p_streams
) {
1210 origin_circ
->p_streams
= conn
->next_stream
;
1213 for (prevconn
= origin_circ
->p_streams
;
1214 prevconn
&& prevconn
->next_stream
&& prevconn
->next_stream
!= conn
;
1215 prevconn
= prevconn
->next_stream
)
1217 if (prevconn
&& prevconn
->next_stream
) {
1218 prevconn
->next_stream
= conn
->next_stream
;
1223 log_debug(LD_APP
, "Removing stream %d from circ %u",
1224 conn
->stream_id
, (unsigned)circ
->n_circ_id
);
1226 /* If the stream was removed, and it was a rend stream, decrement the
1227 * number of streams on the circuit associated with the rend service.
1229 if (circ
->purpose
== CIRCUIT_PURPOSE_S_REND_JOINED
) {
1230 tor_assert(origin_circ
->rend_data
);
1231 origin_circ
->rend_data
->nr_streams
--;
1236 or_circuit_t
*or_circ
= TO_OR_CIRCUIT(circ
);
1237 if (conn
== or_circ
->n_streams
) {
1238 or_circ
->n_streams
= conn
->next_stream
;
1241 if (conn
== or_circ
->resolving_streams
) {
1242 or_circ
->resolving_streams
= conn
->next_stream
;
1246 for (prevconn
= or_circ
->n_streams
;
1247 prevconn
&& prevconn
->next_stream
&& prevconn
->next_stream
!= conn
;
1248 prevconn
= prevconn
->next_stream
)
1250 if (prevconn
&& prevconn
->next_stream
) {
1251 prevconn
->next_stream
= conn
->next_stream
;
1255 for (prevconn
= or_circ
->resolving_streams
;
1256 prevconn
&& prevconn
->next_stream
&& prevconn
->next_stream
!= conn
;
1257 prevconn
= prevconn
->next_stream
)
1259 if (prevconn
&& prevconn
->next_stream
) {
1260 prevconn
->next_stream
= conn
->next_stream
;
1265 log_warn(LD_BUG
,"Edge connection not in circuit's list.");
1266 /* Don't give an error here; it's harmless. */
1267 tor_fragile_assert();
1270 /** If we haven't yet decided on a good timeout value for circuit
1271 * building, we close idles circuits aggressively so we can get more
1273 #define IDLE_TIMEOUT_WHILE_LEARNING (10*60)
1275 /** Find each circuit that has been unused for too long, or dirty
1276 * for too long and has no streams on it: mark it for close.
1279 circuit_expire_old_circuits_clientside(void)
1281 struct timeval cutoff
, now
;
1283 tor_gettimeofday(&now
);
1285 last_expired_clientside_circuits
= now
.tv_sec
;
1287 if (! circuit_build_times_disabled() &&
1288 circuit_build_times_needs_circuits(get_circuit_build_times())) {
1289 /* Circuits should be shorter lived if we need more of them
1290 * for learning a good build timeout */
1291 cutoff
.tv_sec
-= IDLE_TIMEOUT_WHILE_LEARNING
;
1293 cutoff
.tv_sec
-= get_options()->CircuitIdleTimeout
;
1296 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
1297 if (circ
->marked_for_close
|| !CIRCUIT_IS_ORIGIN(circ
))
1299 /* If the circuit has been dirty for too long, and there are no streams
1300 * on it, mark it for close.
1302 if (circ
->timestamp_dirty
&&
1303 circ
->timestamp_dirty
+ get_options()->MaxCircuitDirtiness
<
1305 !TO_ORIGIN_CIRCUIT(circ
)->p_streams
/* nothing attached */ ) {
1306 log_debug(LD_CIRC
, "Closing n_circ_id %u (dirty %ld sec ago, "
1308 (unsigned)circ
->n_circ_id
,
1309 (long)(now
.tv_sec
- circ
->timestamp_dirty
),
1311 /* Don't do this magic for testing circuits. Their death is governed
1312 * by circuit_expire_building */
1313 if (circ
->purpose
!= CIRCUIT_PURPOSE_PATH_BIAS_TESTING
)
1314 circuit_mark_for_close(circ
, END_CIRC_REASON_FINISHED
);
1315 } else if (!circ
->timestamp_dirty
&& circ
->state
== CIRCUIT_STATE_OPEN
) {
1316 if (timercmp(&circ
->timestamp_began
, &cutoff
, OP_LT
)) {
1317 if (circ
->purpose
== CIRCUIT_PURPOSE_C_GENERAL
||
1318 circ
->purpose
== CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT
||
1319 circ
->purpose
== CIRCUIT_PURPOSE_S_ESTABLISH_INTRO
||
1320 circ
->purpose
== CIRCUIT_PURPOSE_TESTING
||
1321 (circ
->purpose
>= CIRCUIT_PURPOSE_C_INTRODUCING
&&
1322 circ
->purpose
<= CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED
) ||
1323 circ
->purpose
== CIRCUIT_PURPOSE_S_CONNECT_REND
) {
1325 "Closing circuit that has been unused for %ld msec.",
1326 tv_mdiff(&circ
->timestamp_began
, &now
));
1327 circuit_mark_for_close(circ
, END_CIRC_REASON_FINISHED
);
1328 } else if (!TO_ORIGIN_CIRCUIT(circ
)->is_ancient
) {
1329 /* Server-side rend joined circuits can end up really old, because
1330 * they are reused by clients for longer than normal. The client
1331 * controls their lifespan. (They never become dirty, because
1332 * connection_exit_begin_conn() never marks anything as dirty.)
1333 * Similarly, server-side intro circuits last a long time. */
1334 if (circ
->purpose
!= CIRCUIT_PURPOSE_S_REND_JOINED
&&
1335 circ
->purpose
!= CIRCUIT_PURPOSE_S_INTRO
) {
1337 "Ancient non-dirty circuit %d is still around after "
1338 "%ld milliseconds. Purpose: %d (%s)",
1339 TO_ORIGIN_CIRCUIT(circ
)->global_identifier
,
1340 tv_mdiff(&circ
->timestamp_began
, &now
),
1342 circuit_purpose_to_string(circ
->purpose
));
1343 TO_ORIGIN_CIRCUIT(circ
)->is_ancient
= 1;
1348 } SMARTLIST_FOREACH_END(circ
);
1351 /** How long do we wait before killing circuits with the properties
1354 * Probably we could choose a number here as low as 5 to 10 seconds,
1355 * since these circs are used for begindir, and a) generally you either
1356 * ask another begindir question right after or you don't for a long time,
1357 * b) clients at least through 0.2.1.x choose from the whole set of
1358 * directory mirrors at each choice, and c) re-establishing a one-hop
1359 * circuit via create-fast is a light operation assuming the TLS conn is
1362 * I expect "b" to go away one day when we move to using directory
1363 * guards, but I think "a" and "c" are good enough reasons that a low
1364 * number is safe even then.
1366 #define IDLE_ONE_HOP_CIRC_TIMEOUT 60
1368 /** Find each non-origin circuit that has been unused for too long,
1369 * has no streams on it, used a create_fast, and ends here: mark it
1373 circuit_expire_old_circuits_serverside(time_t now
)
1375 or_circuit_t
*or_circ
;
1376 time_t cutoff
= now
- IDLE_ONE_HOP_CIRC_TIMEOUT
;
1378 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
1379 if (circ
->marked_for_close
|| CIRCUIT_IS_ORIGIN(circ
))
1381 or_circ
= TO_OR_CIRCUIT(circ
);
1382 /* If the circuit has been idle for too long, and there are no streams
1383 * on it, and it ends here, and it used a create_fast, mark it for close.
1385 if (or_circ
->is_first_hop
&& !circ
->n_chan
&&
1386 !or_circ
->n_streams
&& !or_circ
->resolving_streams
&&
1388 channel_when_last_xmit(or_circ
->p_chan
) <= cutoff
) {
1389 log_info(LD_CIRC
, "Closing circ_id %u (empty %d secs ago)",
1390 (unsigned)or_circ
->p_circ_id
,
1391 (int)(now
- channel_when_last_xmit(or_circ
->p_chan
)));
1392 circuit_mark_for_close(circ
, END_CIRC_REASON_FINISHED
);
1395 SMARTLIST_FOREACH_END(circ
);
1398 /** Number of testing circuits we want open before testing our bandwidth. */
1399 #define NUM_PARALLEL_TESTING_CIRCS 4
1401 /** True iff we've ever had enough testing circuits open to test our
1403 static int have_performed_bandwidth_test
= 0;
1405 /** Reset have_performed_bandwidth_test, so we'll start building
1406 * testing circuits again so we can exercise our bandwidth. */
1408 reset_bandwidth_test(void)
1410 have_performed_bandwidth_test
= 0;
1413 /** Return 1 if we've already exercised our bandwidth, or if we
1414 * have fewer than NUM_PARALLEL_TESTING_CIRCS testing circuits
1415 * established or on the way. Else return 0.
1418 circuit_enough_testing_circs(void)
1422 if (have_performed_bandwidth_test
)
1425 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
1426 if (!circ
->marked_for_close
&& CIRCUIT_IS_ORIGIN(circ
) &&
1427 circ
->purpose
== CIRCUIT_PURPOSE_TESTING
&&
1428 circ
->state
== CIRCUIT_STATE_OPEN
)
1431 SMARTLIST_FOREACH_END(circ
);
1432 return num
>= NUM_PARALLEL_TESTING_CIRCS
;
1435 /** A testing circuit has completed. Take whatever stats we want.
1436 * Noticing reachability is taken care of in onionskin_answer(),
1437 * so there's no need to record anything here. But if we still want
1438 * to do the bandwidth test, and we now have enough testing circuits
1442 circuit_testing_opened(origin_circuit_t
*circ
)
1444 if (have_performed_bandwidth_test
||
1445 !check_whether_orport_reachable(get_options())) {
1446 /* either we've already done everything we want with testing circuits,
1447 * or this testing circuit became open due to a fluke, e.g. we picked
1448 * a last hop where we already had the connection open due to an
1449 * outgoing local circuit. */
1450 circuit_mark_for_close(TO_CIRCUIT(circ
), END_CIRC_AT_ORIGIN
);
1451 } else if (circuit_enough_testing_circs()) {
1452 router_perform_bandwidth_test(NUM_PARALLEL_TESTING_CIRCS
, time(NULL
));
1453 have_performed_bandwidth_test
= 1;
1455 consider_testing_reachability(1, 0);
1458 /** A testing circuit has failed to build. Take whatever stats we want. */
1460 circuit_testing_failed(origin_circuit_t
*circ
, int at_last_hop
)
1462 const or_options_t
*options
= get_options();
1463 if (server_mode(options
) && check_whether_orport_reachable(options
))
1466 log_info(LD_GENERAL
,
1467 "Our testing circuit (to see if your ORPort is reachable) "
1468 "has failed. I'll try again later.");
1470 /* These aren't used yet. */
1475 /** The circuit <b>circ</b> has just become open. Take the next
1476 * step: for rendezvous circuits, we pass circ to the appropriate
1477 * function in rendclient or rendservice. For general circuits, we
1478 * call connection_ap_attach_pending, which looks for pending streams
1479 * that could use circ.
1482 circuit_has_opened(origin_circuit_t
*circ
)
1484 control_event_circuit_status(circ
, CIRC_EVENT_BUILT
, 0);
1486 /* Remember that this circuit has finished building. Now if we start
1487 * it building again later (e.g. by extending it), we will know not
1488 * to consider its build time. */
1489 circ
->has_opened
= 1;
1491 switch (TO_CIRCUIT(circ
)->purpose
) {
1492 case CIRCUIT_PURPOSE_C_ESTABLISH_REND
:
1493 rend_client_rendcirc_has_opened(circ
);
1494 /* Start building an intro circ if we don't have one yet. */
1495 connection_ap_attach_pending(1);
1496 /* This isn't a call to circuit_try_attaching_streams because a
1497 * circuit in _C_ESTABLISH_REND state isn't connected to its
1498 * hidden service yet, thus we can't attach streams to it yet,
1499 * thus circuit_try_attaching_streams would always clear the
1500 * circuit's isolation state. circuit_try_attaching_streams is
1501 * called later, when the rend circ enters _C_REND_JOINED
1504 case CIRCUIT_PURPOSE_C_INTRODUCING
:
1505 rend_client_introcirc_has_opened(circ
);
1507 case CIRCUIT_PURPOSE_C_GENERAL
:
1508 /* Tell any AP connections that have been waiting for a new
1509 * circuit that one is ready. */
1510 circuit_try_attaching_streams(circ
);
1512 case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO
:
1513 /* at the service, waiting for introductions */
1514 rend_service_intro_has_opened(circ
);
1516 case CIRCUIT_PURPOSE_S_CONNECT_REND
:
1517 /* at the service, connecting to rend point */
1518 rend_service_rendezvous_has_opened(circ
);
1520 case CIRCUIT_PURPOSE_TESTING
:
1521 circuit_testing_opened(circ
);
1524 * This won't happen in normal operation, but might happen if the
1525 * controller did it. Just let it slide. */
1529 /** If the stream-isolation state of <b>circ</b> can be cleared, clear
1530 * it. Return non-zero iff <b>circ</b>'s isolation state was cleared. */
1532 circuit_try_clearing_isolation_state(origin_circuit_t
*circ
)
1534 if (/* The circuit may have become non-open if it was cannibalized.*/
1535 circ
->base_
.state
== CIRCUIT_STATE_OPEN
&&
1536 /* If !isolation_values_set, there is nothing to clear. */
1537 circ
->isolation_values_set
&&
1538 /* It's not legal to clear a circuit's isolation info if it's ever had
1539 * streams attached */
1540 !circ
->isolation_any_streams_attached
) {
1541 /* If we have any isolation information set on this circuit, and
1542 * we didn't manage to attach any streams to it, then we can
1543 * and should clear it and try again. */
1544 circuit_clear_isolation(circ
);
1551 /** Called when a circuit becomes ready for streams to be attached to
1554 circuit_try_attaching_streams(origin_circuit_t
*circ
)
1556 /* Attach streams to this circuit if we can. */
1557 connection_ap_attach_pending(1);
1559 /* The call to circuit_try_clearing_isolation_state here will do
1560 * nothing and return 0 if we didn't attach any streams to circ
1562 if (circuit_try_clearing_isolation_state(circ
)) {
1563 /* Maybe *now* we can attach some streams to this circuit. */
1564 connection_ap_attach_pending(1);
1568 /** Called whenever a circuit could not be successfully built.
1571 circuit_build_failed(origin_circuit_t
*circ
)
1573 channel_t
*n_chan
= NULL
;
1574 /* we should examine circ and see if it failed because of
1575 * the last hop or an earlier hop. then use this info below.
1577 int failed_at_last_hop
= 0;
1578 /* If the last hop isn't open, and the second-to-last is, we failed
1579 * at the last hop. */
1581 circ
->cpath
->prev
->state
!= CPATH_STATE_OPEN
&&
1582 circ
->cpath
->prev
->prev
->state
== CPATH_STATE_OPEN
) {
1583 failed_at_last_hop
= 1;
1586 circ
->cpath
->state
!= CPATH_STATE_OPEN
&&
1587 ! circ
->base_
.received_destroy
) {
1588 /* We failed at the first hop for some reason other than a DESTROY cell.
1589 * If there's an OR connection to blame, blame it. Also, avoid this relay
1590 * for a while, and fail any one-hop directory fetches destined for it. */
1591 const char *n_chan_id
= circ
->cpath
->extend_info
->identity_digest
;
1592 int already_marked
= 0;
1593 if (circ
->base_
.n_chan
) {
1594 n_chan
= circ
->base_
.n_chan
;
1596 if (n_chan
->is_bad_for_new_circs
) {
1597 /* We only want to blame this router when a fresh healthy
1598 * connection fails. So don't mark this router as newly failed,
1599 * since maybe this was just an old circuit attempt that's
1600 * finally timing out now. Also, there's no need to blow away
1601 * circuits/streams/etc, since the failure of an unhealthy conn
1602 * doesn't tell us much about whether a healthy conn would
1607 "Our circuit failed to get a response from the first hop "
1608 "(%s). I'm going to try to rotate to a better connection.",
1609 channel_get_canonical_remote_descr(n_chan
));
1610 n_chan
->is_bad_for_new_circs
= 1;
1613 "Our circuit died before the first hop with no connection");
1615 if (n_chan_id
&& !already_marked
) {
1616 entry_guard_register_connect_status(n_chan_id
, 0, 1, time(NULL
));
1617 /* if there are any one-hop streams waiting on this circuit, fail
1618 * them now so they can retry elsewhere. */
1619 connection_ap_fail_onehop(n_chan_id
, circ
->build_state
);
1623 switch (circ
->base_
.purpose
) {
1624 case CIRCUIT_PURPOSE_C_GENERAL
:
1625 /* If we never built the circuit, note it as a failure. */
1626 circuit_increment_failure_count();
1627 if (failed_at_last_hop
) {
1628 /* Make sure any streams that demand our last hop as their exit
1629 * know that it's unlikely to happen. */
1630 circuit_discard_optional_exit_enclaves(circ
->cpath
->prev
->extend_info
);
1633 case CIRCUIT_PURPOSE_TESTING
:
1634 circuit_testing_failed(circ
, failed_at_last_hop
);
1636 case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO
:
1637 /* at the service, waiting for introductions */
1638 if (circ
->base_
.state
!= CIRCUIT_STATE_OPEN
) {
1639 circuit_increment_failure_count();
1641 /* no need to care here, because the service will rebuild intro
1642 * points periodically. */
1644 case CIRCUIT_PURPOSE_C_INTRODUCING
:
1645 /* at the client, connecting to intro point */
1646 /* Don't increment failure count, since the service may have picked
1647 * the introduction point maliciously */
1648 /* The client will pick a new intro point when this one dies, if
1649 * the stream in question still cares. No need to act here. */
1651 case CIRCUIT_PURPOSE_C_ESTABLISH_REND
:
1652 /* at the client, waiting for the service */
1653 circuit_increment_failure_count();
1654 /* the client will pick a new rend point when this one dies, if
1655 * the stream in question still cares. No need to act here. */
1657 case CIRCUIT_PURPOSE_S_CONNECT_REND
:
1658 /* at the service, connecting to rend point */
1659 /* Don't increment failure count, since the client may have picked
1660 * the rendezvous point maliciously */
1662 "Couldn't connect to the client's chosen rend point %s "
1664 escaped(build_state_get_exit_nickname(circ
->build_state
)),
1665 failed_at_last_hop
?"last":"non-last");
1666 rend_service_relaunch_rendezvous(circ
);
1669 * This won't happen in normal operation, but might happen if the
1670 * controller did it. Just let it slide. */
1674 /** Number of consecutive failures so far; should only be touched by
1675 * circuit_launch_new and circuit_*_failure_count.
1677 static int n_circuit_failures
= 0;
1678 /** Before the last time we called circuit_reset_failure_count(), were
1679 * there a lot of failures? */
1680 static int did_circs_fail_last_period
= 0;
1682 /** Don't retry launching a new circuit if we try this many times with no
1684 #define MAX_CIRCUIT_FAILURES 5
1686 /** Launch a new circuit; see circuit_launch_by_extend_info() for
1687 * details on arguments. */
1689 circuit_launch(uint8_t purpose
, int flags
)
1691 return circuit_launch_by_extend_info(purpose
, NULL
, flags
);
1694 /* Do we have enough descriptors to build paths?
1695 * If need_exit is true, return 1 if we can build exit paths.
1696 * (We need at least one Exit in the consensus to build exit paths.)
1697 * If need_exit is false, return 1 if we can build internal paths.
1700 have_enough_path_info(int need_exit
)
1703 return router_have_consensus_path() == CONSENSUS_PATH_EXIT
;
1705 return router_have_consensus_path() != CONSENSUS_PATH_UNKNOWN
;
1708 /** Launch a new circuit with purpose <b>purpose</b> and exit node
1709 * <b>extend_info</b> (or NULL to select a random exit node). If flags
1710 * contains CIRCLAUNCH_NEED_UPTIME, choose among routers with high uptime. If
1711 * CIRCLAUNCH_NEED_CAPACITY is set, choose among routers with high bandwidth.
1712 * If CIRCLAUNCH_IS_INTERNAL is true, the last hop need not be an exit node.
1713 * If CIRCLAUNCH_ONEHOP_TUNNEL is set, the circuit will have only one hop.
1714 * Return the newly allocated circuit on success, or NULL on failure. */
1716 circuit_launch_by_extend_info(uint8_t purpose
,
1717 extend_info_t
*extend_info
,
1720 origin_circuit_t
*circ
;
1721 int onehop_tunnel
= (flags
& CIRCLAUNCH_ONEHOP_TUNNEL
) != 0;
1722 int have_path
= have_enough_path_info(! (flags
& CIRCLAUNCH_IS_INTERNAL
) );
1723 int need_specific_rp
= 0;
1725 if (!onehop_tunnel
&& (!router_have_minimum_dir_info() || !have_path
)) {
1726 log_debug(LD_CIRC
,"Haven't %s yet; canceling "
1728 !router_have_minimum_dir_info() ?
1729 "fetched enough directory info" :
1730 "received a consensus with exits");
1734 /* If Tor2webRendezvousPoints is enabled and we are dealing with an
1735 RP circuit, we want a specific RP node so we shouldn't canibalize
1736 an already existing circuit. */
1737 if (get_options()->Tor2webRendezvousPoints
&&
1738 purpose
== CIRCUIT_PURPOSE_C_ESTABLISH_REND
) {
1739 need_specific_rp
= 1;
1742 if ((extend_info
|| purpose
!= CIRCUIT_PURPOSE_C_GENERAL
) &&
1743 purpose
!= CIRCUIT_PURPOSE_TESTING
&&
1744 !onehop_tunnel
&& !need_specific_rp
) {
1745 /* see if there are appropriate circs available to cannibalize. */
1746 /* XXX if we're planning to add a hop, perhaps we want to look for
1747 * internal circs rather than exit circs? -RD */
1748 circ
= circuit_find_to_cannibalize(purpose
, extend_info
, flags
);
1750 uint8_t old_purpose
= circ
->base_
.purpose
;
1751 struct timeval old_timestamp_began
= circ
->base_
.timestamp_began
;
1753 log_info(LD_CIRC
,"Cannibalizing circ '%s' for purpose %d (%s)",
1754 build_state_get_exit_nickname(circ
->build_state
), purpose
,
1755 circuit_purpose_to_string(purpose
));
1757 if ((purpose
== CIRCUIT_PURPOSE_S_CONNECT_REND
||
1758 purpose
== CIRCUIT_PURPOSE_C_INTRODUCING
) &&
1759 circ
->path_state
== PATH_STATE_BUILD_SUCCEEDED
) {
1760 /* Path bias: Cannibalized rends pre-emptively count as a
1761 * successfully built but unused closed circuit. We don't
1762 * wait until the extend (or the close) because the rend
1763 * point could be malicious.
1765 * Same deal goes for client side introductions. Clients
1766 * can be manipulated to connect repeatedly to them
1767 * (especially web clients).
1769 * If we decide to probe the initial portion of these circs,
1770 * (up to the adversary's final hop), we need to remove this,
1771 * or somehow mark the circuit with a special path state.
1774 /* This must be called before the purpose change */
1775 pathbias_check_close(circ
, END_CIRC_REASON_FINISHED
);
1778 circuit_change_purpose(TO_CIRCUIT(circ
), purpose
);
1779 /* Reset the start date of this circ, else expire_building
1780 * will see it and think it's been trying to build since it
1783 * Technically, the code should reset this when the
1784 * create cell is finally sent, but we're close enough
1786 tor_gettimeofday(&circ
->base_
.timestamp_began
);
1788 control_event_circuit_cannibalized(circ
, old_purpose
,
1789 &old_timestamp_began
);
1792 case CIRCUIT_PURPOSE_C_ESTABLISH_REND
:
1793 /* it's ready right now */
1795 case CIRCUIT_PURPOSE_C_INTRODUCING
:
1796 case CIRCUIT_PURPOSE_S_CONNECT_REND
:
1797 case CIRCUIT_PURPOSE_C_GENERAL
:
1798 case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO
:
1799 /* need to add a new hop */
1800 tor_assert(extend_info
);
1801 if (circuit_extend_to_new_exit(circ
, extend_info
) < 0)
1806 "unexpected purpose %d when cannibalizing a circ.",
1808 tor_fragile_assert();
1815 if (did_circs_fail_last_period
&&
1816 n_circuit_failures
> MAX_CIRCUIT_FAILURES
) {
1817 /* too many failed circs in a row. don't try. */
1818 // log_fn(LOG_INFO,"%d failures so far, not trying.",n_circuit_failures);
1822 /* try a circ. if it fails, circuit_mark_for_close will increment
1823 * n_circuit_failures */
1824 return circuit_establish_circuit(purpose
, extend_info
, flags
);
1827 /** Record another failure at opening a general circuit. When we have
1828 * too many, we'll stop trying for the remainder of this minute.
1831 circuit_increment_failure_count(void)
1833 ++n_circuit_failures
;
1834 log_debug(LD_CIRC
,"n_circuit_failures now %d.",n_circuit_failures
);
1837 /** Reset the failure count for opening general circuits. This means
1838 * we will try MAX_CIRCUIT_FAILURES times more (if necessary) before
1842 circuit_reset_failure_count(int timeout
)
1844 if (timeout
&& n_circuit_failures
> MAX_CIRCUIT_FAILURES
)
1845 did_circs_fail_last_period
= 1;
1847 did_circs_fail_last_period
= 0;
1848 n_circuit_failures
= 0;
1851 /** Find an open circ that we're happy to use for <b>conn</b> and return 1. If
1852 * there isn't one, and there isn't one on the way, launch one and return
1853 * 0. If it will never work, return -1.
1855 * Write the found or in-progress or launched circ into *circp.
1858 circuit_get_open_circ_or_launch(entry_connection_t
*conn
,
1859 uint8_t desired_circuit_purpose
,
1860 origin_circuit_t
**circp
)
1862 origin_circuit_t
*circ
;
1863 int check_exit_policy
;
1864 int need_uptime
, need_internal
;
1866 const or_options_t
*options
= get_options();
1870 if (ENTRY_TO_CONN(conn
)->state
!= AP_CONN_STATE_CIRCUIT_WAIT
) {
1871 connection_t
*c
= ENTRY_TO_CONN(conn
);
1872 log_err(LD_BUG
, "Connection state mismatch: wanted "
1873 "AP_CONN_STATE_CIRCUIT_WAIT, but got %d (%s)",
1874 c
->state
, conn_state_to_string(c
->type
, c
->state
));
1876 tor_assert(ENTRY_TO_CONN(conn
)->state
== AP_CONN_STATE_CIRCUIT_WAIT
);
1878 conn
->socks_request
->command
== SOCKS_COMMAND_CONNECT
&&
1879 !conn
->use_begindir
&&
1880 !connection_edge_is_rendezvous_stream(ENTRY_TO_EDGE_CONN(conn
));
1881 want_onehop
= conn
->want_onehop
;
1883 need_uptime
= !conn
->want_onehop
&& !conn
->use_begindir
&&
1884 smartlist_contains_int_as_string(options
->LongLivedPorts
,
1885 conn
->socks_request
->port
);
1887 if (desired_circuit_purpose
!= CIRCUIT_PURPOSE_C_GENERAL
)
1889 else if (conn
->use_begindir
|| conn
->want_onehop
)
1894 circ
= circuit_get_best(conn
, 1, desired_circuit_purpose
,
1895 need_uptime
, need_internal
);
1899 return 1; /* we're happy */
1902 int have_path
= have_enough_path_info(!need_internal
);
1904 if (!want_onehop
&& (!router_have_minimum_dir_info() || !have_path
)) {
1905 if (!connection_get_by_type(CONN_TYPE_DIR
)) {
1906 int severity
= LOG_NOTICE
;
1907 /* FFFF if this is a tunneled directory fetch, don't yell
1908 * as loudly. the user doesn't even know it's happening. */
1909 if (entry_list_is_constrained(options
) &&
1910 entries_known_but_down(options
)) {
1911 log_fn(severity
, LD_APP
|LD_DIR
,
1912 "Application request when we haven't %s. "
1913 "Optimistically trying known %s again.",
1914 !router_have_minimum_dir_info() ?
1915 "used client functionality lately" :
1916 "received a consensus with exits",
1917 options
->UseBridges
? "bridges" : "entrynodes");
1918 entries_retry_all(options
);
1919 } else if (!options
->UseBridges
|| any_bridge_descriptors_known()) {
1920 log_fn(severity
, LD_APP
|LD_DIR
,
1921 "Application request when we haven't %s. "
1922 "Optimistically trying directory fetches again.",
1923 !router_have_minimum_dir_info() ?
1924 "used client functionality lately" :
1925 "received a consensus with exits");
1926 routerlist_retry_directory_downloads(time(NULL
));
1929 /* the stream will be dealt with when router_have_minimum_dir_info becomes
1930 * 1, or when all directory attempts fail and directory_all_unreachable()
1936 /* Do we need to check exit policy? */
1937 if (check_exit_policy
) {
1938 if (!conn
->chosen_exit_name
) {
1940 tor_addr_t addr
, *addrp
=NULL
;
1941 if (tor_inet_aton(conn
->socks_request
->address
, &in
)) {
1942 tor_addr_from_in(&addr
, &in
);
1945 if (router_exit_policy_all_nodes_reject(addrp
,
1946 conn
->socks_request
->port
,
1949 "No Tor server allows exit to %s:%d. Rejecting.",
1950 safe_str_client(conn
->socks_request
->address
),
1951 conn
->socks_request
->port
);
1955 /* XXXX Duplicates checks in connection_ap_handshake_attach_circuit:
1956 * refactor into a single function. */
1957 const node_t
*node
= node_get_by_nickname(conn
->chosen_exit_name
, 1);
1958 int opt
= conn
->chosen_exit_optional
;
1959 if (node
&& !connection_ap_can_use_exit(conn
, node
)) {
1960 log_fn(opt
? LOG_INFO
: LOG_WARN
, LD_APP
,
1961 "Requested exit point '%s' is excluded or "
1962 "would refuse request. %s.",
1963 conn
->chosen_exit_name
, opt
? "Trying others" : "Closing");
1965 conn
->chosen_exit_optional
= 0;
1966 tor_free(conn
->chosen_exit_name
);
1968 return circuit_get_open_circ_or_launch(conn
,
1969 desired_circuit_purpose
,
1977 /* is one already on the way? */
1978 circ
= circuit_get_best(conn
, 0, desired_circuit_purpose
,
1979 need_uptime
, need_internal
);
1981 log_debug(LD_CIRC
, "one on the way!");
1983 extend_info_t
*extend_info
=NULL
;
1984 uint8_t new_circ_purpose
;
1985 const int n_pending
= count_pending_general_client_circuits();
1987 if (n_pending
>= options
->MaxClientCircuitsPending
) {
1988 static ratelim_t delay_limit
= RATELIM_INIT(10*60);
1990 if ((m
= rate_limit_log(&delay_limit
, approx_time()))) {
1991 log_notice(LD_APP
, "We'd like to launch a circuit to handle a "
1992 "connection, but we already have %d general-purpose client "
1993 "circuits pending. Waiting until some finish.%s",
2000 if (desired_circuit_purpose
== CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
) {
2001 /* need to pick an intro point */
2002 rend_data_t
*rend_data
= ENTRY_TO_EDGE_CONN(conn
)->rend_data
;
2003 tor_assert(rend_data
);
2004 extend_info
= rend_client_get_random_intro(rend_data
);
2007 "No intro points for '%s': re-fetching service descriptor.",
2008 safe_str_client(rend_data
->onion_address
));
2009 rend_client_refetch_v2_renddesc(rend_data
);
2010 connection_ap_mark_as_non_pending_circuit(conn
);
2011 ENTRY_TO_CONN(conn
)->state
= AP_CONN_STATE_RENDDESC_WAIT
;
2014 log_info(LD_REND
,"Chose %s as intro point for '%s'.",
2015 extend_info_describe(extend_info
),
2016 safe_str_client(rend_data
->onion_address
));
2019 /* If we have specified a particular exit node for our
2020 * connection, then be sure to open a circuit to that exit node.
2022 if (desired_circuit_purpose
== CIRCUIT_PURPOSE_C_GENERAL
) {
2023 if (conn
->chosen_exit_name
) {
2025 int opt
= conn
->chosen_exit_optional
;
2026 r
= node_get_by_nickname(conn
->chosen_exit_name
, 1);
2027 if (r
&& node_has_descriptor(r
)) {
2028 /* We might want to connect to an IPv6 bridge for loading
2029 descriptors so we use the preferred address rather than
2031 extend_info
= extend_info_from_node(r
, conn
->want_onehop
? 1 : 0);
2033 log_warn(LD_CIRC
,"Could not make a one-hop connection to %s. "
2034 "Discarding this circuit.", conn
->chosen_exit_name
);
2038 log_debug(LD_DIR
, "considering %d, %s",
2039 want_onehop
, conn
->chosen_exit_name
);
2040 if (want_onehop
&& conn
->chosen_exit_name
[0] == '$') {
2041 /* We're asking for a one-hop circuit to a router that
2042 * we don't have a routerinfo about. Make up an extend_info. */
2043 char digest
[DIGEST_LEN
];
2044 char *hexdigest
= conn
->chosen_exit_name
+1;
2046 if (strlen(hexdigest
) < HEX_DIGEST_LEN
||
2047 base16_decode(digest
,DIGEST_LEN
,
2048 hexdigest
,HEX_DIGEST_LEN
) != DIGEST_LEN
) {
2049 log_info(LD_DIR
, "Broken exit digest on tunnel conn. Closing.");
2052 if (tor_addr_parse(&addr
, conn
->socks_request
->address
) < 0) {
2053 log_info(LD_DIR
, "Broken address %s on tunnel conn. Closing.",
2054 escaped_safe_str_client(conn
->socks_request
->address
));
2057 extend_info
= extend_info_new(conn
->chosen_exit_name
+1,
2058 digest
, NULL
, NULL
, &addr
,
2059 conn
->socks_request
->port
);
2061 /* We will need an onion key for the router, and we
2062 * don't have one. Refuse or relax requirements. */
2063 log_fn(opt
? LOG_INFO
: LOG_WARN
, LD_APP
,
2064 "Requested exit point '%s' is not known. %s.",
2065 conn
->chosen_exit_name
, opt
? "Trying others" : "Closing");
2067 conn
->chosen_exit_optional
= 0;
2068 tor_free(conn
->chosen_exit_name
);
2069 /* Try again with no requested exit */
2070 return circuit_get_open_circ_or_launch(conn
,
2071 desired_circuit_purpose
,
2080 if (desired_circuit_purpose
== CIRCUIT_PURPOSE_C_REND_JOINED
)
2081 new_circ_purpose
= CIRCUIT_PURPOSE_C_ESTABLISH_REND
;
2082 else if (desired_circuit_purpose
== CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
)
2083 new_circ_purpose
= CIRCUIT_PURPOSE_C_INTRODUCING
;
2085 new_circ_purpose
= desired_circuit_purpose
;
2087 #ifdef ENABLE_TOR2WEB_MODE
2088 if (options
->Tor2webMode
&&
2089 (new_circ_purpose
== CIRCUIT_PURPOSE_C_ESTABLISH_REND
||
2090 new_circ_purpose
== CIRCUIT_PURPOSE_C_INTRODUCING
)) {
2096 int flags
= CIRCLAUNCH_NEED_CAPACITY
;
2097 if (want_onehop
) flags
|= CIRCLAUNCH_ONEHOP_TUNNEL
;
2098 if (need_uptime
) flags
|= CIRCLAUNCH_NEED_UPTIME
;
2099 if (need_internal
) flags
|= CIRCLAUNCH_IS_INTERNAL
;
2100 circ
= circuit_launch_by_extend_info(new_circ_purpose
, extend_info
,
2104 extend_info_free(extend_info
);
2106 if (desired_circuit_purpose
== CIRCUIT_PURPOSE_C_GENERAL
) {
2107 /* We just caused a circuit to get built because of this stream.
2108 * If this stream has caused a _lot_ of circuits to be built, that's
2109 * a bad sign: we should tell the user. */
2110 if (conn
->num_circuits_launched
< NUM_CIRCUITS_LAUNCHED_THRESHOLD
&&
2111 ++conn
->num_circuits_launched
== NUM_CIRCUITS_LAUNCHED_THRESHOLD
)
2112 log_info(LD_CIRC
, "The application request to %s:%d has launched "
2113 "%d circuits without finding one it likes.",
2114 escaped_safe_str_client(conn
->socks_request
->address
),
2115 conn
->socks_request
->port
,
2116 conn
->num_circuits_launched
);
2118 /* help predict this next time */
2119 rep_hist_note_used_internal(time(NULL
), need_uptime
, 1);
2121 /* write the service_id into circ */
2122 circ
->rend_data
= rend_data_dup(ENTRY_TO_EDGE_CONN(conn
)->rend_data
);
2123 if (circ
->base_
.purpose
== CIRCUIT_PURPOSE_C_ESTABLISH_REND
&&
2124 circ
->base_
.state
== CIRCUIT_STATE_OPEN
)
2125 circuit_has_opened(circ
);
2128 } /* endif (!circ) */
2130 /* Mark the circuit with the isolation fields for this connection.
2131 * When the circuit arrives, we'll clear these flags: this is
2132 * just some internal bookkeeping to make sure that we have
2133 * launched enough circuits.
2135 connection_edge_update_circuit_isolation(conn
, circ
, 0);
2138 "No safe circuit (purpose %d) ready for edge "
2139 "connection; delaying.",
2140 desired_circuit_purpose
);
2146 /** Return true iff <b>crypt_path</b> is one of the crypt_paths for
2149 cpath_is_on_circuit(origin_circuit_t
*circ
, crypt_path_t
*crypt_path
)
2151 crypt_path_t
*cpath
, *cpath_next
= NULL
;
2152 for (cpath
= circ
->cpath
; cpath_next
!= circ
->cpath
; cpath
= cpath_next
) {
2153 cpath_next
= cpath
->next
;
2154 if (crypt_path
== cpath
)
2160 /** Return true iff client-side optimistic data is supported. */
2162 optimistic_data_enabled(void)
2164 const or_options_t
*options
= get_options();
2165 if (options
->OptimisticData
< 0) {
2166 /* Note: this default was 0 before #18815 was merged. We can't take the
2167 * parameter out of the consensus until versions before that are all
2169 const int32_t enabled
=
2170 networkstatus_get_param(NULL
, "UseOptimisticData", /*default*/ 1, 0, 1);
2171 return (int)enabled
;
2173 return options
->OptimisticData
;
2176 /** Attach the AP stream <b>apconn</b> to circ's linked list of
2177 * p_streams. Also set apconn's cpath_layer to <b>cpath</b>, or to the last
2178 * hop in circ's cpath if <b>cpath</b> is NULL.
2181 link_apconn_to_circ(entry_connection_t
*apconn
, origin_circuit_t
*circ
,
2182 crypt_path_t
*cpath
)
2184 const node_t
*exitnode
= NULL
;
2186 /* add it into the linked list of streams on this circuit */
2187 log_debug(LD_APP
|LD_CIRC
, "attaching new conn to circ. n_circ_id %u.",
2188 (unsigned)circ
->base_
.n_circ_id
);
2189 /* reset it, so we can measure circ timeouts */
2190 ENTRY_TO_CONN(apconn
)->timestamp_lastread
= time(NULL
);
2191 ENTRY_TO_EDGE_CONN(apconn
)->next_stream
= circ
->p_streams
;
2192 ENTRY_TO_EDGE_CONN(apconn
)->on_circuit
= TO_CIRCUIT(circ
);
2193 /* assert_connection_ok(conn, time(NULL)); */
2194 circ
->p_streams
= ENTRY_TO_EDGE_CONN(apconn
);
2196 if (connection_edge_is_rendezvous_stream(ENTRY_TO_EDGE_CONN(apconn
))) {
2197 /* We are attaching a stream to a rendezvous circuit. That means
2198 * that an attempt to connect to a hidden service just
2199 * succeeded. Tell rendclient.c. */
2200 rend_client_note_connection_attempt_ended(
2201 ENTRY_TO_EDGE_CONN(apconn
)->rend_data
);
2204 if (cpath
) { /* we were given one; use it */
2205 tor_assert(cpath_is_on_circuit(circ
, cpath
));
2207 /* use the last hop in the circuit */
2208 tor_assert(circ
->cpath
);
2209 tor_assert(circ
->cpath
->prev
);
2210 tor_assert(circ
->cpath
->prev
->state
== CPATH_STATE_OPEN
);
2211 cpath
= circ
->cpath
->prev
;
2213 ENTRY_TO_EDGE_CONN(apconn
)->cpath_layer
= cpath
;
2215 circ
->isolation_any_streams_attached
= 1;
2216 connection_edge_update_circuit_isolation(apconn
, circ
, 0);
2218 /* Compute the exitnode if possible, for logging below */
2219 if (cpath
->extend_info
)
2220 exitnode
= node_get_by_id(cpath
->extend_info
->identity_digest
);
2222 /* See if we can use optimistic data on this circuit */
2223 if (optimistic_data_enabled() &&
2224 (circ
->base_
.purpose
== CIRCUIT_PURPOSE_C_GENERAL
||
2225 circ
->base_
.purpose
== CIRCUIT_PURPOSE_C_REND_JOINED
))
2226 apconn
->may_use_optimistic_data
= 1;
2228 apconn
->may_use_optimistic_data
= 0;
2229 log_info(LD_APP
, "Looks like completed circuit to %s %s allow "
2230 "optimistic data for connection to %s",
2231 circ
->base_
.purpose
== CIRCUIT_PURPOSE_C_GENERAL
?
2232 /* node_describe() does the right thing if exitnode is NULL */
2233 safe_str_client(node_describe(exitnode
)) :
2235 apconn
->may_use_optimistic_data
? "does" : "doesn't",
2236 safe_str_client(apconn
->socks_request
->address
));
2239 /** Return true iff <b>address</b> is matched by one of the entries in
2240 * TrackHostExits. */
2242 hostname_in_track_host_exits(const or_options_t
*options
, const char *address
)
2244 if (!options
->TrackHostExits
)
2246 SMARTLIST_FOREACH_BEGIN(options
->TrackHostExits
, const char *, cp
) {
2247 if (cp
[0] == '.') { /* match end */
2248 if (cp
[1] == '\0' ||
2249 !strcasecmpend(address
, cp
) ||
2250 !strcasecmp(address
, &cp
[1]))
2252 } else if (strcasecmp(cp
, address
) == 0) {
2255 } SMARTLIST_FOREACH_END(cp
);
2259 /** If an exit wasn't explicitly specified for <b>conn</b>, consider saving
2260 * the exit that we *did* choose for use by future connections to
2261 * <b>conn</b>'s destination.
2264 consider_recording_trackhost(const entry_connection_t
*conn
,
2265 const origin_circuit_t
*circ
)
2267 const or_options_t
*options
= get_options();
2268 char *new_address
= NULL
;
2269 char fp
[HEX_DIGEST_LEN
+1];
2271 /* Search the addressmap for this conn's destination. */
2272 /* If they're not in the address map.. */
2273 if (!options
->TrackHostExits
||
2274 addressmap_have_mapping(conn
->socks_request
->address
,
2275 options
->TrackHostExitsExpire
))
2276 return; /* nothing to track, or already mapped */
2278 if (!hostname_in_track_host_exits(options
, conn
->socks_request
->address
) ||
2279 !circ
->build_state
->chosen_exit
)
2282 /* write down the fingerprint of the chosen exit, not the nickname,
2283 * because the chosen exit might not be named. */
2284 base16_encode(fp
, sizeof(fp
),
2285 circ
->build_state
->chosen_exit
->identity_digest
, DIGEST_LEN
);
2287 /* Add this exit/hostname pair to the addressmap. */
2288 tor_asprintf(&new_address
, "%s.%s.exit",
2289 conn
->socks_request
->address
, fp
);
2291 addressmap_register(conn
->socks_request
->address
, new_address
,
2292 time(NULL
) + options
->TrackHostExitsExpire
,
2293 ADDRMAPSRC_TRACKEXIT
, 0, 0);
2296 /** Attempt to attach the connection <b>conn</b> to <b>circ</b>, and send a
2297 * begin or resolve cell as appropriate. Return values are as for
2298 * connection_ap_handshake_attach_circuit. The stream will exit from the hop
2299 * indicated by <b>cpath</b>, or from the last hop in circ's cpath if
2300 * <b>cpath</b> is NULL. */
2302 connection_ap_handshake_attach_chosen_circuit(entry_connection_t
*conn
,
2303 origin_circuit_t
*circ
,
2304 crypt_path_t
*cpath
)
2306 connection_t
*base_conn
= ENTRY_TO_CONN(conn
);
2308 tor_assert(base_conn
->state
== AP_CONN_STATE_CIRCUIT_WAIT
||
2309 base_conn
->state
== AP_CONN_STATE_CONTROLLER_WAIT
);
2310 tor_assert(conn
->socks_request
);
2312 tor_assert(circ
->base_
.state
== CIRCUIT_STATE_OPEN
);
2314 base_conn
->state
= AP_CONN_STATE_CIRCUIT_WAIT
;
2316 if (!circ
->base_
.timestamp_dirty
||
2317 ((conn
->entry_cfg
.isolation_flags
& ISO_SOCKSAUTH
) &&
2318 (conn
->entry_cfg
.socks_iso_keep_alive
) &&
2319 (conn
->socks_request
->usernamelen
||
2320 conn
->socks_request
->passwordlen
))) {
2321 /* When stream isolation is in use and controlled by an application
2322 * we are willing to keep using the stream. */
2323 circ
->base_
.timestamp_dirty
= approx_time();
2326 pathbias_count_use_attempt(circ
);
2328 link_apconn_to_circ(conn
, circ
, cpath
);
2329 tor_assert(conn
->socks_request
);
2330 if (conn
->socks_request
->command
== SOCKS_COMMAND_CONNECT
) {
2331 if (!conn
->use_begindir
)
2332 consider_recording_trackhost(conn
, circ
);
2333 if (connection_ap_handshake_send_begin(conn
) < 0)
2336 if (connection_ap_handshake_send_resolve(conn
) < 0)
2343 /** Try to find a safe live circuit for CONN_TYPE_AP connection conn. If
2344 * we don't find one: if conn cannot be handled by any known nodes,
2345 * warn and return -1 (conn needs to die, and is maybe already marked);
2346 * else launch new circuit (if necessary) and return 0.
2347 * Otherwise, associate conn with a safe live circuit, do the
2348 * right next step, and return 1.
2350 /* XXXX this function should mark for close whenever it returns -1;
2351 * its callers shouldn't have to worry about that. */
2353 connection_ap_handshake_attach_circuit(entry_connection_t
*conn
)
2355 connection_t
*base_conn
= ENTRY_TO_CONN(conn
);
2361 tor_assert(base_conn
->state
== AP_CONN_STATE_CIRCUIT_WAIT
);
2362 tor_assert(conn
->socks_request
);
2363 want_onehop
= conn
->want_onehop
;
2365 conn_age
= (int)(time(NULL
) - base_conn
->timestamp_created
);
2367 if (conn_age
>= get_options()->SocksTimeout
) {
2368 int severity
= (tor_addr_is_null(&base_conn
->addr
) && !base_conn
->port
) ?
2369 LOG_INFO
: LOG_NOTICE
;
2370 log_fn(severity
, LD_APP
,
2371 "Tried for %d seconds to get a connection to %s:%d. Giving up.",
2372 conn_age
, safe_str_client(conn
->socks_request
->address
),
2373 conn
->socks_request
->port
);
2377 if (!connection_edge_is_rendezvous_stream(ENTRY_TO_EDGE_CONN(conn
))) {
2378 /* we're a general conn */
2379 origin_circuit_t
*circ
=NULL
;
2381 /* Are we linked to a dir conn that aims to fetch a consensus?
2382 * We check here because this conn might no longer be needed. */
2383 if (base_conn
->linked_conn
&&
2384 base_conn
->linked_conn
->type
== CONN_TYPE_DIR
&&
2385 base_conn
->linked_conn
->purpose
== DIR_PURPOSE_FETCH_CONSENSUS
) {
2387 /* Yes we are. Is there a consensus fetch farther along than us? */
2388 if (networkstatus_consensus_is_already_downloading(
2389 TO_DIR_CONN(base_conn
->linked_conn
)->requested_resource
)) {
2390 /* We're doing the "multiple consensus fetch attempts" game from
2391 * proposal 210, and we're late to the party. Just close this conn.
2392 * The circuit and TLS conn that we made will time out after a while
2393 * if nothing else wants to use them. */
2394 log_info(LD_DIR
, "Closing extra consensus fetch (to %s) since one "
2395 "is already downloading.", base_conn
->linked_conn
->address
);
2400 if (conn
->chosen_exit_name
) {
2401 const node_t
*node
= node_get_by_nickname(conn
->chosen_exit_name
, 1);
2402 int opt
= conn
->chosen_exit_optional
;
2403 if (!node
&& !want_onehop
) {
2404 /* We ran into this warning when trying to extend a circuit to a
2405 * hidden service directory for which we didn't have a router
2406 * descriptor. See flyspray task 767 for more details. We should
2407 * keep this in mind when deciding to use BEGIN_DIR cells for other
2408 * directory requests as well. -KL*/
2409 log_fn(opt
? LOG_INFO
: LOG_WARN
, LD_APP
,
2410 "Requested exit point '%s' is not known. %s.",
2411 conn
->chosen_exit_name
, opt
? "Trying others" : "Closing");
2413 conn
->chosen_exit_optional
= 0;
2414 tor_free(conn
->chosen_exit_name
);
2419 if (node
&& !connection_ap_can_use_exit(conn
, node
)) {
2420 log_fn(opt
? LOG_INFO
: LOG_WARN
, LD_APP
,
2421 "Requested exit point '%s' is excluded or "
2422 "would refuse request. %s.",
2423 conn
->chosen_exit_name
, opt
? "Trying others" : "Closing");
2425 conn
->chosen_exit_optional
= 0;
2426 tor_free(conn
->chosen_exit_name
);
2433 /* find the circuit that we should use, if there is one. */
2434 retval
= circuit_get_open_circ_or_launch(
2435 conn
, CIRCUIT_PURPOSE_C_GENERAL
, &circ
);
2436 if (retval
< 1) // XXXX++ if we totally fail, this still returns 0 -RD
2439 log_debug(LD_APP
|LD_CIRC
,
2440 "Attaching apconn to circ %u (stream %d sec old).",
2441 (unsigned)circ
->base_
.n_circ_id
, conn_age
);
2442 /* print the circ's path, so people can figure out which circs are
2444 circuit_log_path(LOG_INFO
,LD_APP
|LD_CIRC
,circ
);
2446 /* We have found a suitable circuit for our conn. Hurray. */
2447 return connection_ap_handshake_attach_chosen_circuit(conn
, circ
, NULL
);
2449 } else { /* we're a rendezvous conn */
2450 origin_circuit_t
*rendcirc
=NULL
, *introcirc
=NULL
;
2452 tor_assert(!ENTRY_TO_EDGE_CONN(conn
)->cpath_layer
);
2454 /* start by finding a rendezvous circuit for us */
2456 retval
= circuit_get_open_circ_or_launch(
2457 conn
, CIRCUIT_PURPOSE_C_REND_JOINED
, &rendcirc
);
2458 if (retval
< 0) return -1; /* failed */
2461 tor_assert(rendcirc
);
2462 /* one is already established, attach */
2464 "rend joined circ %u already here. attaching. "
2465 "(stream %d sec old)",
2466 (unsigned)rendcirc
->base_
.n_circ_id
, conn_age
);
2467 /* Mark rendezvous circuits as 'newly dirty' every time you use
2468 * them, since the process of rebuilding a rendezvous circ is so
2469 * expensive. There is a tradeoff between linkability and
2470 * feasibility, at this point.
2472 rendcirc
->base_
.timestamp_dirty
= time(NULL
);
2474 /* We've also attempted to use them. If they fail, we need to
2475 * probe them for path bias */
2476 pathbias_count_use_attempt(rendcirc
);
2478 link_apconn_to_circ(conn
, rendcirc
, NULL
);
2479 if (connection_ap_handshake_send_begin(conn
) < 0)
2480 return 0; /* already marked, let them fade away */
2484 /* At this point we need to re-check the state, since it's possible that
2485 * our call to circuit_get_open_circ_or_launch() changed the connection's
2486 * state from "CIRCUIT_WAIT" to "RENDDESC_WAIT" because we decided to
2487 * re-fetch the descriptor.
2489 if (ENTRY_TO_CONN(conn
)->state
!= AP_CONN_STATE_CIRCUIT_WAIT
) {
2490 log_info(LD_REND
, "This connection is no longer ready to attach; its "
2492 "(We probably have to re-fetch its descriptor.)");
2496 if (rendcirc
&& (rendcirc
->base_
.purpose
==
2497 CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED
)) {
2499 "pending-join circ %u already here, with intro ack. "
2500 "Stalling. (stream %d sec old)",
2501 (unsigned)rendcirc
->base_
.n_circ_id
, conn_age
);
2505 /* it's on its way. find an intro circ. */
2506 retval
= circuit_get_open_circ_or_launch(
2507 conn
, CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
, &introcirc
);
2508 if (retval
< 0) return -1; /* failed */
2511 /* one has already sent the intro. keep waiting. */
2512 tor_assert(introcirc
);
2513 log_info(LD_REND
, "Intro circ %u present and awaiting ack (rend %u). "
2514 "Stalling. (stream %d sec old)",
2515 (unsigned)introcirc
->base_
.n_circ_id
,
2516 rendcirc
? (unsigned)rendcirc
->base_
.n_circ_id
: 0,
2521 /* now rendcirc and introcirc are each either undefined or not finished */
2523 if (rendcirc
&& introcirc
&&
2524 rendcirc
->base_
.purpose
== CIRCUIT_PURPOSE_C_REND_READY
) {
2526 "ready rend circ %u already here (no intro-ack yet on "
2527 "intro %u). (stream %d sec old)",
2528 (unsigned)rendcirc
->base_
.n_circ_id
,
2529 (unsigned)introcirc
->base_
.n_circ_id
, conn_age
);
2531 tor_assert(introcirc
->base_
.purpose
== CIRCUIT_PURPOSE_C_INTRODUCING
);
2532 if (introcirc
->base_
.state
== CIRCUIT_STATE_OPEN
) {
2533 log_info(LD_REND
,"found open intro circ %u (rend %u); sending "
2534 "introduction. (stream %d sec old)",
2535 (unsigned)introcirc
->base_
.n_circ_id
,
2536 (unsigned)rendcirc
->base_
.n_circ_id
,
2538 switch (rend_client_send_introduction(introcirc
, rendcirc
)) {
2539 case 0: /* success */
2540 rendcirc
->base_
.timestamp_dirty
= time(NULL
);
2541 introcirc
->base_
.timestamp_dirty
= time(NULL
);
2543 pathbias_count_use_attempt(introcirc
);
2544 pathbias_count_use_attempt(rendcirc
);
2546 assert_circuit_ok(TO_CIRCUIT(rendcirc
));
2547 assert_circuit_ok(TO_CIRCUIT(introcirc
));
2549 case -1: /* transient error */
2551 case -2: /* permanent error */
2554 tor_fragile_assert();
2560 log_info(LD_REND
, "Intro (%u) and rend (%u) circs are not both ready. "
2561 "Stalling conn. (%d sec old)",
2562 introcirc
? (unsigned)introcirc
->base_
.n_circ_id
: 0,
2563 rendcirc
? (unsigned)rendcirc
->base_
.n_circ_id
: 0, conn_age
);
2568 /** Change <b>circ</b>'s purpose to <b>new_purpose</b>. */
2570 circuit_change_purpose(circuit_t
*circ
, uint8_t new_purpose
)
2572 uint8_t old_purpose
;
2573 /* Don't allow an OR circ to become an origin circ or vice versa. */
2574 tor_assert(!!(CIRCUIT_IS_ORIGIN(circ
)) ==
2575 !!(CIRCUIT_PURPOSE_IS_ORIGIN(new_purpose
)));
2577 if (circ
->purpose
== new_purpose
) return;
2579 if (CIRCUIT_IS_ORIGIN(circ
)) {
2580 char old_purpose_desc
[80] = "";
2582 strncpy(old_purpose_desc
, circuit_purpose_to_string(circ
->purpose
), 80-1);
2583 old_purpose_desc
[80-1] = '\0';
2586 "changing purpose of origin circ %d "
2587 "from \"%s\" (%d) to \"%s\" (%d)",
2588 TO_ORIGIN_CIRCUIT(circ
)->global_identifier
,
2591 circuit_purpose_to_string(new_purpose
),
2595 old_purpose
= circ
->purpose
;
2596 circ
->purpose
= new_purpose
;
2598 if (CIRCUIT_IS_ORIGIN(circ
)) {
2599 control_event_circuit_purpose_changed(TO_ORIGIN_CIRCUIT(circ
),
2604 /** Mark <b>circ</b> so that no more connections can be attached to it. */
2606 mark_circuit_unusable_for_new_conns(origin_circuit_t
*circ
)
2608 const or_options_t
*options
= get_options();
2611 /* XXXX This is a kludge; we're only keeping it around in case there's
2612 * something that doesn't check unusable_for_new_conns, and to avoid
2613 * deeper refactoring of our expiration logic. */
2614 if (! circ
->base_
.timestamp_dirty
)
2615 circ
->base_
.timestamp_dirty
= approx_time();
2616 if (options
->MaxCircuitDirtiness
>= circ
->base_
.timestamp_dirty
)
2617 circ
->base_
.timestamp_dirty
= 1; /* prevent underflow */
2619 circ
->base_
.timestamp_dirty
-= options
->MaxCircuitDirtiness
;
2621 circ
->unusable_for_new_conns
= 1;