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 /* XXX023 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 /* XXXX023 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.
793 circuit_log_ancient_one_hop_circuits(int age
)
795 #define MAX_ANCIENT_ONEHOP_CIRCUITS_TO_LOG 10
796 time_t now
= time(NULL
);
797 time_t cutoff
= now
- age
;
799 smartlist_t
*log_these
= smartlist_new();
801 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
802 const origin_circuit_t
*ocirc
;
803 if (! CIRCUIT_IS_ORIGIN(circ
))
805 if (circ
->timestamp_created
.tv_sec
>= cutoff
)
807 ocirc
= CONST_TO_ORIGIN_CIRCUIT(circ
);
809 if (ocirc
->build_state
&& ocirc
->build_state
->onehop_tunnel
) {
812 if (smartlist_len(log_these
) < MAX_ANCIENT_ONEHOP_CIRCUITS_TO_LOG
)
813 smartlist_add(log_these
, (origin_circuit_t
*) ocirc
);
816 SMARTLIST_FOREACH_END(circ
);
821 log_notice(LD_HEARTBEAT
,
822 "Diagnostic for issue 8387: Found %d one-hop circuits more "
823 "than %d seconds old! Logging %d...",
824 n_found
, age
, smartlist_len(log_these
));
826 SMARTLIST_FOREACH_BEGIN(log_these
, const origin_circuit_t
*, ocirc
) {
827 char created
[ISO_TIME_LEN
+1];
829 const edge_connection_t
*conn
;
831 const circuit_t
*circ
= TO_CIRCUIT(ocirc
);
833 format_local_iso_time(created
,
834 (time_t)circ
->timestamp_created
.tv_sec
);
836 if (circ
->timestamp_dirty
) {
837 char dirty_since
[ISO_TIME_LEN
+1];
838 format_local_iso_time(dirty_since
, circ
->timestamp_dirty
);
840 tor_asprintf(&dirty
, "Dirty since %s (%ld seconds vs %ld-second cutoff)",
841 dirty_since
, (long)(now
- circ
->timestamp_dirty
),
842 (long) get_options()->MaxCircuitDirtiness
);
844 dirty
= tor_strdup("Not marked dirty");
847 log_notice(LD_HEARTBEAT
, " #%d created at %s. %s, %s. %s for close. "
848 "Package window: %d. "
849 "%s for new conns. %s.",
852 circuit_state_to_string(circ
->state
),
853 circuit_purpose_to_string(circ
->purpose
),
854 circ
->marked_for_close
? "Marked" : "Not marked",
855 circ
->package_window
,
856 ocirc
->unusable_for_new_conns
? "Not usable" : "usable",
861 for (conn
= ocirc
->p_streams
; conn
; conn
= conn
->next_stream
) {
862 const connection_t
*c
= TO_CONN(conn
);
863 char stream_created
[ISO_TIME_LEN
+1];
864 if (++stream_num
>= 5)
867 format_local_iso_time(stream_created
, c
->timestamp_created
);
869 log_notice(LD_HEARTBEAT
, " Stream#%d created at %s. "
870 "%s conn in state %s. "
871 "It is %slinked and %sreading from a linked connection %p. "
872 "Package window %d. "
873 "%s for close (%s:%d). Hold-open is %sset. "
874 "Has %ssent RELAY_END. %s on circuit.",
877 conn_type_to_string(c
->type
),
878 conn_state_to_string(c
->type
, c
->state
),
879 c
->linked
? "" : "not ",
880 c
->reading_from_linked_conn
? "": "not",
882 conn
->package_window
,
883 c
->marked_for_close
? "Marked" : "Not marked",
884 c
->marked_for_close_file
? c
->marked_for_close_file
: "--",
886 c
->hold_open_until_flushed
? "" : "not ",
887 conn
->edge_has_sent_end
? "" : "not ",
888 conn
->edge_blocked_on_circ
? "Blocked" : "Not blocked");
889 if (! c
->linked_conn
)
894 log_notice(LD_HEARTBEAT
, " Linked to %s connection in state %s "
895 "(Purpose %d). %s for close (%s:%d). Hold-open is %sset. ",
896 conn_type_to_string(c
->type
),
897 conn_state_to_string(c
->type
, c
->state
),
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 ");
904 } SMARTLIST_FOREACH_END(ocirc
);
906 log_notice(LD_HEARTBEAT
, "It has been %ld seconds since I last called "
907 "circuit_expire_old_circuits_clientside().",
908 (long)(now
- last_expired_clientside_circuits
));
911 smartlist_free(log_these
);
914 /** Remove any elements in <b>needed_ports</b> that are handled by an
915 * open or in-progress circuit.
918 circuit_remove_handled_ports(smartlist_t
*needed_ports
)
923 for (i
= 0; i
< smartlist_len(needed_ports
); ++i
) {
924 port
= smartlist_get(needed_ports
, i
);
926 if (circuit_stream_is_being_handled(NULL
, *port
,
927 MIN_CIRCUITS_HANDLING_STREAM
)) {
928 // log_debug(LD_CIRC,"Port %d is already being handled; removing.", port);
929 smartlist_del(needed_ports
, i
--);
932 log_debug(LD_CIRC
,"Port %d is not handled.", *port
);
937 /** Return 1 if at least <b>min</b> general-purpose non-internal circuits
938 * will have an acceptable exit node for exit stream <b>conn</b> if it
939 * is defined, else for "*:port".
943 circuit_stream_is_being_handled(entry_connection_t
*conn
,
944 uint16_t port
, int min
)
946 const node_t
*exitnode
;
948 time_t now
= time(NULL
);
949 int need_uptime
= smartlist_contains_int_as_string(
950 get_options()->LongLivedPorts
,
951 conn
? conn
->socks_request
->port
: port
);
953 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
954 if (CIRCUIT_IS_ORIGIN(circ
) &&
955 !circ
->marked_for_close
&&
956 circ
->purpose
== CIRCUIT_PURPOSE_C_GENERAL
&&
957 (!circ
->timestamp_dirty
||
958 circ
->timestamp_dirty
+ get_options()->MaxCircuitDirtiness
> now
)) {
959 origin_circuit_t
*origin_circ
= TO_ORIGIN_CIRCUIT(circ
);
960 cpath_build_state_t
*build_state
= origin_circ
->build_state
;
961 if (build_state
->is_internal
|| build_state
->onehop_tunnel
)
963 if (origin_circ
->unusable_for_new_conns
)
966 exitnode
= build_state_get_exit_node(build_state
);
967 if (exitnode
&& (!need_uptime
|| build_state
->need_uptime
)) {
970 ok
= connection_ap_can_use_exit(conn
, exitnode
);
972 addr_policy_result_t r
;
973 r
= compare_tor_addr_to_node_policy(NULL
, port
, exitnode
);
974 ok
= r
!= ADDR_POLICY_REJECTED
&& r
!= ADDR_POLICY_PROBABLY_REJECTED
;
983 SMARTLIST_FOREACH_END(circ
);
987 /** Don't keep more than this many unused open circuits around. */
988 #define MAX_UNUSED_OPEN_CIRCUITS 14
990 /** Figure out how many circuits we have open that are clean. Make
991 * sure it's enough for all the upcoming behaviors we predict we'll have.
992 * But put an upper bound on the total number of circuits.
995 circuit_predict_and_launch_new(void)
997 int num
=0, num_internal
=0, num_uptime_internal
=0;
998 int hidserv_needs_uptime
=0, hidserv_needs_capacity
=1;
999 int port_needs_uptime
=0, port_needs_capacity
=1;
1000 time_t now
= time(NULL
);
1003 /* First, count how many of each type of circuit we have already. */
1004 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
1005 cpath_build_state_t
*build_state
;
1006 origin_circuit_t
*origin_circ
;
1007 if (!CIRCUIT_IS_ORIGIN(circ
))
1009 if (circ
->marked_for_close
)
1010 continue; /* don't mess with marked circs */
1011 if (circ
->timestamp_dirty
)
1012 continue; /* only count clean circs */
1013 if (circ
->purpose
!= CIRCUIT_PURPOSE_C_GENERAL
)
1014 continue; /* only pay attention to general-purpose circs */
1015 origin_circ
= TO_ORIGIN_CIRCUIT(circ
);
1016 if (origin_circ
->unusable_for_new_conns
)
1018 build_state
= origin_circ
->build_state
;
1019 if (build_state
->onehop_tunnel
)
1022 if (build_state
->is_internal
)
1024 if (build_state
->need_uptime
&& build_state
->is_internal
)
1025 num_uptime_internal
++;
1027 SMARTLIST_FOREACH_END(circ
);
1029 /* If that's enough, then stop now. */
1030 if (num
>= MAX_UNUSED_OPEN_CIRCUITS
)
1031 return; /* we already have many, making more probably will hurt */
1033 /* Second, see if we need any more exit circuits. */
1034 /* check if we know of a port that's been requested recently
1035 * and no circuit is currently available that can handle it.
1036 * Exits (obviously) require an exit circuit. */
1037 if (!circuit_all_predicted_ports_handled(now
, &port_needs_uptime
,
1038 &port_needs_capacity
)
1039 && router_have_consensus_path() == CONSENSUS_PATH_EXIT
) {
1040 if (port_needs_uptime
)
1041 flags
|= CIRCLAUNCH_NEED_UPTIME
;
1042 if (port_needs_capacity
)
1043 flags
|= CIRCLAUNCH_NEED_CAPACITY
;
1045 "Have %d clean circs (%d internal), need another exit circ.",
1047 circuit_launch(CIRCUIT_PURPOSE_C_GENERAL
, flags
);
1051 /* Third, see if we need any more hidden service (server) circuits.
1052 * HS servers only need an internal circuit. */
1053 if (num_rend_services() && num_uptime_internal
< 3
1054 && router_have_consensus_path() != CONSENSUS_PATH_UNKNOWN
) {
1055 flags
= (CIRCLAUNCH_NEED_CAPACITY
| CIRCLAUNCH_NEED_UPTIME
|
1056 CIRCLAUNCH_IS_INTERNAL
);
1058 "Have %d clean circs (%d internal), need another internal "
1059 "circ for my hidden service.",
1061 circuit_launch(CIRCUIT_PURPOSE_C_GENERAL
, flags
);
1065 /* Fourth, see if we need any more hidden service (client) circuits.
1066 * HS clients only need an internal circuit. */
1067 if (rep_hist_get_predicted_internal(now
, &hidserv_needs_uptime
,
1068 &hidserv_needs_capacity
) &&
1069 ((num_uptime_internal
<2 && hidserv_needs_uptime
) ||
1071 && router_have_consensus_path() != CONSENSUS_PATH_UNKNOWN
) {
1072 if (hidserv_needs_uptime
)
1073 flags
|= CIRCLAUNCH_NEED_UPTIME
;
1074 if (hidserv_needs_capacity
)
1075 flags
|= CIRCLAUNCH_NEED_CAPACITY
;
1076 flags
|= CIRCLAUNCH_IS_INTERNAL
;
1078 "Have %d clean circs (%d uptime-internal, %d internal), need"
1079 " another hidden service circ.",
1080 num
, num_uptime_internal
, num_internal
);
1081 circuit_launch(CIRCUIT_PURPOSE_C_GENERAL
, flags
);
1085 /* Finally, check to see if we still need more circuits to learn
1086 * a good build timeout. But if we're close to our max number we
1087 * want, don't do another -- we want to leave a few slots open so
1088 * we can still build circuits preemptively as needed.
1089 * XXXX make the assumption that build timeout streams should be
1090 * created whenever we can build internal circuits. */
1091 if (router_have_consensus_path() != CONSENSUS_PATH_UNKNOWN
) {
1092 if (num
< MAX_UNUSED_OPEN_CIRCUITS
-2 &&
1093 ! circuit_build_times_disabled() &&
1094 circuit_build_times_needs_circuits_now(get_circuit_build_times())) {
1095 flags
= CIRCLAUNCH_NEED_CAPACITY
;
1096 /* if there are no exits in the consensus, make timeout
1097 * circuits internal */
1098 if (router_have_consensus_path() == CONSENSUS_PATH_INTERNAL
)
1099 flags
|= CIRCLAUNCH_IS_INTERNAL
;
1101 "Have %d clean circs need another buildtime test circ.", num
);
1102 circuit_launch(CIRCUIT_PURPOSE_C_GENERAL
, flags
);
1108 /** Build a new test circuit every 5 minutes */
1109 #define TESTING_CIRCUIT_INTERVAL 300
1111 /** This function is called once a second, if router_have_min_dir_info() is
1112 * true. Its job is to make sure all services we offer have enough circuits
1113 * available. Some services just want enough circuits for current tasks,
1114 * whereas others want a minimum set of idle circuits hanging around.
1117 circuit_build_needed_circs(time_t now
)
1119 const or_options_t
*options
= get_options();
1121 /* launch a new circ for any pending streams that need one
1122 * XXXX make the assumption that (some) AP streams (i.e. HS clients)
1123 * don't require an exit circuit, review in #13814.
1124 * This allows HSs to function in a consensus without exits. */
1125 if (router_have_consensus_path() != CONSENSUS_PATH_UNKNOWN
)
1126 connection_ap_rescan_and_attach_pending();
1128 /* make sure any hidden services have enough intro points
1129 * HS intro point streams only require an internal circuit */
1130 if (router_have_consensus_path() != CONSENSUS_PATH_UNKNOWN
)
1131 rend_consider_services_intro_points();
1133 circuit_expire_old_circs_as_needed(now
);
1135 if (!options
->DisablePredictedCircuits
)
1136 circuit_predict_and_launch_new();
1140 * Called once a second either directly or from
1141 * circuit_build_needed_circs(). As appropriate (once per NewCircuitPeriod)
1142 * resets failure counts and expires old circuits.
1145 circuit_expire_old_circs_as_needed(time_t now
)
1147 static time_t time_to_expire_and_reset
= 0;
1149 if (time_to_expire_and_reset
< now
) {
1150 circuit_reset_failure_count(1);
1151 time_to_expire_and_reset
= now
+ get_options()->NewCircuitPeriod
;
1152 if (proxy_mode(get_options()))
1153 addressmap_clean(now
);
1154 circuit_expire_old_circuits_clientside();
1156 #if 0 /* disable for now, until predict-and-launch-new can cull leftovers */
1158 /* If we ever re-enable, this has to move into
1159 * circuit_build_needed_circs */
1161 circ
= circuit_get_youngest_clean_open(CIRCUIT_PURPOSE_C_GENERAL
);
1162 if (get_options()->RunTesting
&&
1164 circ
->timestamp_began
.tv_sec
+ TESTING_CIRCUIT_INTERVAL
< now
) {
1165 log_fn(LOG_INFO
,"Creating a new testing circuit.");
1166 circuit_launch(CIRCUIT_PURPOSE_C_GENERAL
, 0);
1172 /** If the stream <b>conn</b> is a member of any of the linked
1173 * lists of <b>circ</b>, then remove it from the list.
1176 circuit_detach_stream(circuit_t
*circ
, edge_connection_t
*conn
)
1178 edge_connection_t
*prevconn
;
1183 if (conn
->base_
.type
== CONN_TYPE_AP
) {
1184 entry_connection_t
*entry_conn
= EDGE_TO_ENTRY_CONN(conn
);
1185 entry_conn
->may_use_optimistic_data
= 0;
1187 conn
->cpath_layer
= NULL
; /* don't keep a stale pointer */
1188 conn
->on_circuit
= NULL
;
1190 if (CIRCUIT_IS_ORIGIN(circ
)) {
1191 origin_circuit_t
*origin_circ
= TO_ORIGIN_CIRCUIT(circ
);
1193 if (conn
== origin_circ
->p_streams
) {
1194 origin_circ
->p_streams
= conn
->next_stream
;
1197 for (prevconn
= origin_circ
->p_streams
;
1198 prevconn
&& prevconn
->next_stream
&& prevconn
->next_stream
!= conn
;
1199 prevconn
= prevconn
->next_stream
)
1201 if (prevconn
&& prevconn
->next_stream
) {
1202 prevconn
->next_stream
= conn
->next_stream
;
1207 log_debug(LD_APP
, "Removing stream %d from circ %u",
1208 conn
->stream_id
, (unsigned)circ
->n_circ_id
);
1210 /* If the stream was removed, and it was a rend stream, decrement the
1211 * number of streams on the circuit associated with the rend service.
1213 if (circ
->purpose
== CIRCUIT_PURPOSE_S_REND_JOINED
) {
1214 tor_assert(origin_circ
->rend_data
);
1215 origin_circ
->rend_data
->nr_streams
--;
1220 or_circuit_t
*or_circ
= TO_OR_CIRCUIT(circ
);
1221 if (conn
== or_circ
->n_streams
) {
1222 or_circ
->n_streams
= conn
->next_stream
;
1225 if (conn
== or_circ
->resolving_streams
) {
1226 or_circ
->resolving_streams
= conn
->next_stream
;
1230 for (prevconn
= or_circ
->n_streams
;
1231 prevconn
&& prevconn
->next_stream
&& prevconn
->next_stream
!= conn
;
1232 prevconn
= prevconn
->next_stream
)
1234 if (prevconn
&& prevconn
->next_stream
) {
1235 prevconn
->next_stream
= conn
->next_stream
;
1239 for (prevconn
= or_circ
->resolving_streams
;
1240 prevconn
&& prevconn
->next_stream
&& prevconn
->next_stream
!= conn
;
1241 prevconn
= prevconn
->next_stream
)
1243 if (prevconn
&& prevconn
->next_stream
) {
1244 prevconn
->next_stream
= conn
->next_stream
;
1249 log_warn(LD_BUG
,"Edge connection not in circuit's list.");
1250 /* Don't give an error here; it's harmless. */
1251 tor_fragile_assert();
1254 /** If we haven't yet decided on a good timeout value for circuit
1255 * building, we close idles circuits aggressively so we can get more
1257 #define IDLE_TIMEOUT_WHILE_LEARNING (10*60)
1259 /** Find each circuit that has been unused for too long, or dirty
1260 * for too long and has no streams on it: mark it for close.
1263 circuit_expire_old_circuits_clientside(void)
1265 struct timeval cutoff
, now
;
1267 tor_gettimeofday(&now
);
1269 last_expired_clientside_circuits
= now
.tv_sec
;
1271 if (! circuit_build_times_disabled() &&
1272 circuit_build_times_needs_circuits(get_circuit_build_times())) {
1273 /* Circuits should be shorter lived if we need more of them
1274 * for learning a good build timeout */
1275 cutoff
.tv_sec
-= IDLE_TIMEOUT_WHILE_LEARNING
;
1277 cutoff
.tv_sec
-= get_options()->CircuitIdleTimeout
;
1280 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
1281 if (circ
->marked_for_close
|| !CIRCUIT_IS_ORIGIN(circ
))
1283 /* If the circuit has been dirty for too long, and there are no streams
1284 * on it, mark it for close.
1286 if (circ
->timestamp_dirty
&&
1287 circ
->timestamp_dirty
+ get_options()->MaxCircuitDirtiness
<
1289 !TO_ORIGIN_CIRCUIT(circ
)->p_streams
/* nothing attached */ ) {
1290 log_debug(LD_CIRC
, "Closing n_circ_id %u (dirty %ld sec ago, "
1292 (unsigned)circ
->n_circ_id
,
1293 (long)(now
.tv_sec
- circ
->timestamp_dirty
),
1295 /* Don't do this magic for testing circuits. Their death is governed
1296 * by circuit_expire_building */
1297 if (circ
->purpose
!= CIRCUIT_PURPOSE_PATH_BIAS_TESTING
)
1298 circuit_mark_for_close(circ
, END_CIRC_REASON_FINISHED
);
1299 } else if (!circ
->timestamp_dirty
&& circ
->state
== CIRCUIT_STATE_OPEN
) {
1300 if (timercmp(&circ
->timestamp_began
, &cutoff
, OP_LT
)) {
1301 if (circ
->purpose
== CIRCUIT_PURPOSE_C_GENERAL
||
1302 circ
->purpose
== CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT
||
1303 circ
->purpose
== CIRCUIT_PURPOSE_S_ESTABLISH_INTRO
||
1304 circ
->purpose
== CIRCUIT_PURPOSE_TESTING
||
1305 (circ
->purpose
>= CIRCUIT_PURPOSE_C_INTRODUCING
&&
1306 circ
->purpose
<= CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED
) ||
1307 circ
->purpose
== CIRCUIT_PURPOSE_S_CONNECT_REND
) {
1309 "Closing circuit that has been unused for %ld msec.",
1310 tv_mdiff(&circ
->timestamp_began
, &now
));
1311 circuit_mark_for_close(circ
, END_CIRC_REASON_FINISHED
);
1312 } else if (!TO_ORIGIN_CIRCUIT(circ
)->is_ancient
) {
1313 /* Server-side rend joined circuits can end up really old, because
1314 * they are reused by clients for longer than normal. The client
1315 * controls their lifespan. (They never become dirty, because
1316 * connection_exit_begin_conn() never marks anything as dirty.)
1317 * Similarly, server-side intro circuits last a long time. */
1318 if (circ
->purpose
!= CIRCUIT_PURPOSE_S_REND_JOINED
&&
1319 circ
->purpose
!= CIRCUIT_PURPOSE_S_INTRO
) {
1321 "Ancient non-dirty circuit %d is still around after "
1322 "%ld milliseconds. Purpose: %d (%s)",
1323 TO_ORIGIN_CIRCUIT(circ
)->global_identifier
,
1324 tv_mdiff(&circ
->timestamp_began
, &now
),
1326 circuit_purpose_to_string(circ
->purpose
));
1327 TO_ORIGIN_CIRCUIT(circ
)->is_ancient
= 1;
1332 } SMARTLIST_FOREACH_END(circ
);
1335 /** How long do we wait before killing circuits with the properties
1338 * Probably we could choose a number here as low as 5 to 10 seconds,
1339 * since these circs are used for begindir, and a) generally you either
1340 * ask another begindir question right after or you don't for a long time,
1341 * b) clients at least through 0.2.1.x choose from the whole set of
1342 * directory mirrors at each choice, and c) re-establishing a one-hop
1343 * circuit via create-fast is a light operation assuming the TLS conn is
1346 * I expect "b" to go away one day when we move to using directory
1347 * guards, but I think "a" and "c" are good enough reasons that a low
1348 * number is safe even then.
1350 #define IDLE_ONE_HOP_CIRC_TIMEOUT 60
1352 /** Find each non-origin circuit that has been unused for too long,
1353 * has no streams on it, used a create_fast, and ends here: mark it
1357 circuit_expire_old_circuits_serverside(time_t now
)
1359 or_circuit_t
*or_circ
;
1360 time_t cutoff
= now
- IDLE_ONE_HOP_CIRC_TIMEOUT
;
1362 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
1363 if (circ
->marked_for_close
|| CIRCUIT_IS_ORIGIN(circ
))
1365 or_circ
= TO_OR_CIRCUIT(circ
);
1366 /* If the circuit has been idle for too long, and there are no streams
1367 * on it, and it ends here, and it used a create_fast, mark it for close.
1369 if (or_circ
->is_first_hop
&& !circ
->n_chan
&&
1370 !or_circ
->n_streams
&& !or_circ
->resolving_streams
&&
1372 channel_when_last_xmit(or_circ
->p_chan
) <= cutoff
) {
1373 log_info(LD_CIRC
, "Closing circ_id %u (empty %d secs ago)",
1374 (unsigned)or_circ
->p_circ_id
,
1375 (int)(now
- channel_when_last_xmit(or_circ
->p_chan
)));
1376 circuit_mark_for_close(circ
, END_CIRC_REASON_FINISHED
);
1379 SMARTLIST_FOREACH_END(circ
);
1382 /** Number of testing circuits we want open before testing our bandwidth. */
1383 #define NUM_PARALLEL_TESTING_CIRCS 4
1385 /** True iff we've ever had enough testing circuits open to test our
1387 static int have_performed_bandwidth_test
= 0;
1389 /** Reset have_performed_bandwidth_test, so we'll start building
1390 * testing circuits again so we can exercise our bandwidth. */
1392 reset_bandwidth_test(void)
1394 have_performed_bandwidth_test
= 0;
1397 /** Return 1 if we've already exercised our bandwidth, or if we
1398 * have fewer than NUM_PARALLEL_TESTING_CIRCS testing circuits
1399 * established or on the way. Else return 0.
1402 circuit_enough_testing_circs(void)
1406 if (have_performed_bandwidth_test
)
1409 SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t
*, circ
) {
1410 if (!circ
->marked_for_close
&& CIRCUIT_IS_ORIGIN(circ
) &&
1411 circ
->purpose
== CIRCUIT_PURPOSE_TESTING
&&
1412 circ
->state
== CIRCUIT_STATE_OPEN
)
1415 SMARTLIST_FOREACH_END(circ
);
1416 return num
>= NUM_PARALLEL_TESTING_CIRCS
;
1419 /** A testing circuit has completed. Take whatever stats we want.
1420 * Noticing reachability is taken care of in onionskin_answer(),
1421 * so there's no need to record anything here. But if we still want
1422 * to do the bandwidth test, and we now have enough testing circuits
1426 circuit_testing_opened(origin_circuit_t
*circ
)
1428 if (have_performed_bandwidth_test
||
1429 !check_whether_orport_reachable(get_options())) {
1430 /* either we've already done everything we want with testing circuits,
1431 * or this testing circuit became open due to a fluke, e.g. we picked
1432 * a last hop where we already had the connection open due to an
1433 * outgoing local circuit. */
1434 circuit_mark_for_close(TO_CIRCUIT(circ
), END_CIRC_AT_ORIGIN
);
1435 } else if (circuit_enough_testing_circs()) {
1436 router_perform_bandwidth_test(NUM_PARALLEL_TESTING_CIRCS
, time(NULL
));
1437 have_performed_bandwidth_test
= 1;
1439 consider_testing_reachability(1, 0);
1442 /** A testing circuit has failed to build. Take whatever stats we want. */
1444 circuit_testing_failed(origin_circuit_t
*circ
, int at_last_hop
)
1446 const or_options_t
*options
= get_options();
1447 if (server_mode(options
) && check_whether_orport_reachable(options
))
1450 log_info(LD_GENERAL
,
1451 "Our testing circuit (to see if your ORPort is reachable) "
1452 "has failed. I'll try again later.");
1454 /* These aren't used yet. */
1459 /** The circuit <b>circ</b> has just become open. Take the next
1460 * step: for rendezvous circuits, we pass circ to the appropriate
1461 * function in rendclient or rendservice. For general circuits, we
1462 * call connection_ap_attach_pending, which looks for pending streams
1463 * that could use circ.
1466 circuit_has_opened(origin_circuit_t
*circ
)
1468 control_event_circuit_status(circ
, CIRC_EVENT_BUILT
, 0);
1470 /* Remember that this circuit has finished building. Now if we start
1471 * it building again later (e.g. by extending it), we will know not
1472 * to consider its build time. */
1473 circ
->has_opened
= 1;
1475 switch (TO_CIRCUIT(circ
)->purpose
) {
1476 case CIRCUIT_PURPOSE_C_ESTABLISH_REND
:
1477 rend_client_rendcirc_has_opened(circ
);
1478 /* Start building an intro circ if we don't have one yet. */
1479 connection_ap_attach_pending(1);
1480 /* This isn't a call to circuit_try_attaching_streams because a
1481 * circuit in _C_ESTABLISH_REND state isn't connected to its
1482 * hidden service yet, thus we can't attach streams to it yet,
1483 * thus circuit_try_attaching_streams would always clear the
1484 * circuit's isolation state. circuit_try_attaching_streams is
1485 * called later, when the rend circ enters _C_REND_JOINED
1488 case CIRCUIT_PURPOSE_C_INTRODUCING
:
1489 rend_client_introcirc_has_opened(circ
);
1491 case CIRCUIT_PURPOSE_C_GENERAL
:
1492 /* Tell any AP connections that have been waiting for a new
1493 * circuit that one is ready. */
1494 circuit_try_attaching_streams(circ
);
1496 case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO
:
1497 /* at the service, waiting for introductions */
1498 rend_service_intro_has_opened(circ
);
1500 case CIRCUIT_PURPOSE_S_CONNECT_REND
:
1501 /* at the service, connecting to rend point */
1502 rend_service_rendezvous_has_opened(circ
);
1504 case CIRCUIT_PURPOSE_TESTING
:
1505 circuit_testing_opened(circ
);
1508 * This won't happen in normal operation, but might happen if the
1509 * controller did it. Just let it slide. */
1513 /** If the stream-isolation state of <b>circ</b> can be cleared, clear
1514 * it. Return non-zero iff <b>circ</b>'s isolation state was cleared. */
1516 circuit_try_clearing_isolation_state(origin_circuit_t
*circ
)
1518 if (/* The circuit may have become non-open if it was cannibalized.*/
1519 circ
->base_
.state
== CIRCUIT_STATE_OPEN
&&
1520 /* If !isolation_values_set, there is nothing to clear. */
1521 circ
->isolation_values_set
&&
1522 /* It's not legal to clear a circuit's isolation info if it's ever had
1523 * streams attached */
1524 !circ
->isolation_any_streams_attached
) {
1525 /* If we have any isolation information set on this circuit, and
1526 * we didn't manage to attach any streams to it, then we can
1527 * and should clear it and try again. */
1528 circuit_clear_isolation(circ
);
1535 /** Called when a circuit becomes ready for streams to be attached to
1538 circuit_try_attaching_streams(origin_circuit_t
*circ
)
1540 /* Attach streams to this circuit if we can. */
1541 connection_ap_attach_pending(1);
1543 /* The call to circuit_try_clearing_isolation_state here will do
1544 * nothing and return 0 if we didn't attach any streams to circ
1546 if (circuit_try_clearing_isolation_state(circ
)) {
1547 /* Maybe *now* we can attach some streams to this circuit. */
1548 connection_ap_attach_pending(1);
1552 /** Called whenever a circuit could not be successfully built.
1555 circuit_build_failed(origin_circuit_t
*circ
)
1557 channel_t
*n_chan
= NULL
;
1558 /* we should examine circ and see if it failed because of
1559 * the last hop or an earlier hop. then use this info below.
1561 int failed_at_last_hop
= 0;
1562 /* If the last hop isn't open, and the second-to-last is, we failed
1563 * at the last hop. */
1565 circ
->cpath
->prev
->state
!= CPATH_STATE_OPEN
&&
1566 circ
->cpath
->prev
->prev
->state
== CPATH_STATE_OPEN
) {
1567 failed_at_last_hop
= 1;
1570 circ
->cpath
->state
!= CPATH_STATE_OPEN
&&
1571 ! circ
->base_
.received_destroy
) {
1572 /* We failed at the first hop for some reason other than a DESTROY cell.
1573 * If there's an OR connection to blame, blame it. Also, avoid this relay
1574 * for a while, and fail any one-hop directory fetches destined for it. */
1575 const char *n_chan_id
= circ
->cpath
->extend_info
->identity_digest
;
1576 int already_marked
= 0;
1577 if (circ
->base_
.n_chan
) {
1578 n_chan
= circ
->base_
.n_chan
;
1580 if (n_chan
->is_bad_for_new_circs
) {
1581 /* We only want to blame this router when a fresh healthy
1582 * connection fails. So don't mark this router as newly failed,
1583 * since maybe this was just an old circuit attempt that's
1584 * finally timing out now. Also, there's no need to blow away
1585 * circuits/streams/etc, since the failure of an unhealthy conn
1586 * doesn't tell us much about whether a healthy conn would
1591 "Our circuit failed to get a response from the first hop "
1592 "(%s). I'm going to try to rotate to a better connection.",
1593 channel_get_canonical_remote_descr(n_chan
));
1594 n_chan
->is_bad_for_new_circs
= 1;
1597 "Our circuit died before the first hop with no connection");
1599 if (n_chan_id
&& !already_marked
) {
1600 entry_guard_register_connect_status(n_chan_id
, 0, 1, time(NULL
));
1601 /* if there are any one-hop streams waiting on this circuit, fail
1602 * them now so they can retry elsewhere. */
1603 connection_ap_fail_onehop(n_chan_id
, circ
->build_state
);
1607 switch (circ
->base_
.purpose
) {
1608 case CIRCUIT_PURPOSE_C_GENERAL
:
1609 /* If we never built the circuit, note it as a failure. */
1610 circuit_increment_failure_count();
1611 if (failed_at_last_hop
) {
1612 /* Make sure any streams that demand our last hop as their exit
1613 * know that it's unlikely to happen. */
1614 circuit_discard_optional_exit_enclaves(circ
->cpath
->prev
->extend_info
);
1617 case CIRCUIT_PURPOSE_TESTING
:
1618 circuit_testing_failed(circ
, failed_at_last_hop
);
1620 case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO
:
1621 /* at the service, waiting for introductions */
1622 if (circ
->base_
.state
!= CIRCUIT_STATE_OPEN
) {
1623 circuit_increment_failure_count();
1625 /* no need to care here, because the service will rebuild intro
1626 * points periodically. */
1628 case CIRCUIT_PURPOSE_C_INTRODUCING
:
1629 /* at the client, connecting to intro point */
1630 /* Don't increment failure count, since the service may have picked
1631 * the introduction point maliciously */
1632 /* The client will pick a new intro point when this one dies, if
1633 * the stream in question still cares. No need to act here. */
1635 case CIRCUIT_PURPOSE_C_ESTABLISH_REND
:
1636 /* at the client, waiting for the service */
1637 circuit_increment_failure_count();
1638 /* the client will pick a new rend point when this one dies, if
1639 * the stream in question still cares. No need to act here. */
1641 case CIRCUIT_PURPOSE_S_CONNECT_REND
:
1642 /* at the service, connecting to rend point */
1643 /* Don't increment failure count, since the client may have picked
1644 * the rendezvous point maliciously */
1646 "Couldn't connect to the client's chosen rend point %s "
1648 escaped(build_state_get_exit_nickname(circ
->build_state
)),
1649 failed_at_last_hop
?"last":"non-last");
1650 rend_service_relaunch_rendezvous(circ
);
1653 * This won't happen in normal operation, but might happen if the
1654 * controller did it. Just let it slide. */
1658 /** Number of consecutive failures so far; should only be touched by
1659 * circuit_launch_new and circuit_*_failure_count.
1661 static int n_circuit_failures
= 0;
1662 /** Before the last time we called circuit_reset_failure_count(), were
1663 * there a lot of failures? */
1664 static int did_circs_fail_last_period
= 0;
1666 /** Don't retry launching a new circuit if we try this many times with no
1668 #define MAX_CIRCUIT_FAILURES 5
1670 /** Launch a new circuit; see circuit_launch_by_extend_info() for
1671 * details on arguments. */
1673 circuit_launch(uint8_t purpose
, int flags
)
1675 return circuit_launch_by_extend_info(purpose
, NULL
, flags
);
1678 /* Do we have enough descriptors to build paths?
1679 * If need_exit is true, return 1 if we can build exit paths.
1680 * (We need at least one Exit in the consensus to build exit paths.)
1681 * If need_exit is false, return 1 if we can build internal paths.
1684 have_enough_path_info(int need_exit
)
1687 return router_have_consensus_path() == CONSENSUS_PATH_EXIT
;
1689 return router_have_consensus_path() != CONSENSUS_PATH_UNKNOWN
;
1692 /** Launch a new circuit with purpose <b>purpose</b> and exit node
1693 * <b>extend_info</b> (or NULL to select a random exit node). If flags
1694 * contains CIRCLAUNCH_NEED_UPTIME, choose among routers with high uptime. If
1695 * CIRCLAUNCH_NEED_CAPACITY is set, choose among routers with high bandwidth.
1696 * If CIRCLAUNCH_IS_INTERNAL is true, the last hop need not be an exit node.
1697 * If CIRCLAUNCH_ONEHOP_TUNNEL is set, the circuit will have only one hop.
1698 * Return the newly allocated circuit on success, or NULL on failure. */
1700 circuit_launch_by_extend_info(uint8_t purpose
,
1701 extend_info_t
*extend_info
,
1704 origin_circuit_t
*circ
;
1705 int onehop_tunnel
= (flags
& CIRCLAUNCH_ONEHOP_TUNNEL
) != 0;
1706 int have_path
= have_enough_path_info(! (flags
& CIRCLAUNCH_IS_INTERNAL
) );
1707 int need_specific_rp
= 0;
1709 if (!onehop_tunnel
&& (!router_have_minimum_dir_info() || !have_path
)) {
1710 log_debug(LD_CIRC
,"Haven't %s yet; canceling "
1712 !router_have_minimum_dir_info() ?
1713 "fetched enough directory info" :
1714 "received a consensus with exits");
1718 /* If Tor2webRendezvousPoints is enabled and we are dealing with an
1719 RP circuit, we want a specific RP node so we shouldn't canibalize
1720 an already existing circuit. */
1721 if (get_options()->Tor2webRendezvousPoints
&&
1722 purpose
== CIRCUIT_PURPOSE_C_ESTABLISH_REND
) {
1723 need_specific_rp
= 1;
1726 if ((extend_info
|| purpose
!= CIRCUIT_PURPOSE_C_GENERAL
) &&
1727 purpose
!= CIRCUIT_PURPOSE_TESTING
&&
1728 !onehop_tunnel
&& !need_specific_rp
) {
1729 /* see if there are appropriate circs available to cannibalize. */
1730 /* XXX if we're planning to add a hop, perhaps we want to look for
1731 * internal circs rather than exit circs? -RD */
1732 circ
= circuit_find_to_cannibalize(purpose
, extend_info
, flags
);
1734 uint8_t old_purpose
= circ
->base_
.purpose
;
1735 struct timeval old_timestamp_began
= circ
->base_
.timestamp_began
;
1737 log_info(LD_CIRC
,"Cannibalizing circ '%s' for purpose %d (%s)",
1738 build_state_get_exit_nickname(circ
->build_state
), purpose
,
1739 circuit_purpose_to_string(purpose
));
1741 if ((purpose
== CIRCUIT_PURPOSE_S_CONNECT_REND
||
1742 purpose
== CIRCUIT_PURPOSE_C_INTRODUCING
) &&
1743 circ
->path_state
== PATH_STATE_BUILD_SUCCEEDED
) {
1744 /* Path bias: Cannibalized rends pre-emptively count as a
1745 * successfully built but unused closed circuit. We don't
1746 * wait until the extend (or the close) because the rend
1747 * point could be malicious.
1749 * Same deal goes for client side introductions. Clients
1750 * can be manipulated to connect repeatedly to them
1751 * (especially web clients).
1753 * If we decide to probe the initial portion of these circs,
1754 * (up to the adversary's final hop), we need to remove this,
1755 * or somehow mark the circuit with a special path state.
1758 /* This must be called before the purpose change */
1759 pathbias_check_close(circ
, END_CIRC_REASON_FINISHED
);
1762 circuit_change_purpose(TO_CIRCUIT(circ
), purpose
);
1763 /* Reset the start date of this circ, else expire_building
1764 * will see it and think it's been trying to build since it
1767 * Technically, the code should reset this when the
1768 * create cell is finally sent, but we're close enough
1770 tor_gettimeofday(&circ
->base_
.timestamp_began
);
1772 control_event_circuit_cannibalized(circ
, old_purpose
,
1773 &old_timestamp_began
);
1776 case CIRCUIT_PURPOSE_C_ESTABLISH_REND
:
1777 /* it's ready right now */
1779 case CIRCUIT_PURPOSE_C_INTRODUCING
:
1780 case CIRCUIT_PURPOSE_S_CONNECT_REND
:
1781 case CIRCUIT_PURPOSE_C_GENERAL
:
1782 case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO
:
1783 /* need to add a new hop */
1784 tor_assert(extend_info
);
1785 if (circuit_extend_to_new_exit(circ
, extend_info
) < 0)
1790 "unexpected purpose %d when cannibalizing a circ.",
1792 tor_fragile_assert();
1799 if (did_circs_fail_last_period
&&
1800 n_circuit_failures
> MAX_CIRCUIT_FAILURES
) {
1801 /* too many failed circs in a row. don't try. */
1802 // log_fn(LOG_INFO,"%d failures so far, not trying.",n_circuit_failures);
1806 /* try a circ. if it fails, circuit_mark_for_close will increment
1807 * n_circuit_failures */
1808 return circuit_establish_circuit(purpose
, extend_info
, flags
);
1811 /** Record another failure at opening a general circuit. When we have
1812 * too many, we'll stop trying for the remainder of this minute.
1815 circuit_increment_failure_count(void)
1817 ++n_circuit_failures
;
1818 log_debug(LD_CIRC
,"n_circuit_failures now %d.",n_circuit_failures
);
1821 /** Reset the failure count for opening general circuits. This means
1822 * we will try MAX_CIRCUIT_FAILURES times more (if necessary) before
1826 circuit_reset_failure_count(int timeout
)
1828 if (timeout
&& n_circuit_failures
> MAX_CIRCUIT_FAILURES
)
1829 did_circs_fail_last_period
= 1;
1831 did_circs_fail_last_period
= 0;
1832 n_circuit_failures
= 0;
1835 /** Find an open circ that we're happy to use for <b>conn</b> and return 1. If
1836 * there isn't one, and there isn't one on the way, launch one and return
1837 * 0. If it will never work, return -1.
1839 * Write the found or in-progress or launched circ into *circp.
1842 circuit_get_open_circ_or_launch(entry_connection_t
*conn
,
1843 uint8_t desired_circuit_purpose
,
1844 origin_circuit_t
**circp
)
1846 origin_circuit_t
*circ
;
1847 int check_exit_policy
;
1848 int need_uptime
, need_internal
;
1850 const or_options_t
*options
= get_options();
1854 if (ENTRY_TO_CONN(conn
)->state
!= AP_CONN_STATE_CIRCUIT_WAIT
) {
1855 connection_t
*c
= ENTRY_TO_CONN(conn
);
1856 log_err(LD_BUG
, "Connection state mismatch: wanted "
1857 "AP_CONN_STATE_CIRCUIT_WAIT, but got %d (%s)",
1858 c
->state
, conn_state_to_string(c
->type
, c
->state
));
1860 tor_assert(ENTRY_TO_CONN(conn
)->state
== AP_CONN_STATE_CIRCUIT_WAIT
);
1862 conn
->socks_request
->command
== SOCKS_COMMAND_CONNECT
&&
1863 !conn
->use_begindir
&&
1864 !connection_edge_is_rendezvous_stream(ENTRY_TO_EDGE_CONN(conn
));
1865 want_onehop
= conn
->want_onehop
;
1867 need_uptime
= !conn
->want_onehop
&& !conn
->use_begindir
&&
1868 smartlist_contains_int_as_string(options
->LongLivedPorts
,
1869 conn
->socks_request
->port
);
1871 if (desired_circuit_purpose
!= CIRCUIT_PURPOSE_C_GENERAL
)
1873 else if (conn
->use_begindir
|| conn
->want_onehop
)
1878 circ
= circuit_get_best(conn
, 1, desired_circuit_purpose
,
1879 need_uptime
, need_internal
);
1883 return 1; /* we're happy */
1886 int have_path
= have_enough_path_info(!need_internal
);
1888 if (!want_onehop
&& (!router_have_minimum_dir_info() || !have_path
)) {
1889 if (!connection_get_by_type(CONN_TYPE_DIR
)) {
1890 int severity
= LOG_NOTICE
;
1891 /* FFFF if this is a tunneled directory fetch, don't yell
1892 * as loudly. the user doesn't even know it's happening. */
1893 if (entry_list_is_constrained(options
) &&
1894 entries_known_but_down(options
)) {
1895 log_fn(severity
, LD_APP
|LD_DIR
,
1896 "Application request when we haven't %s. "
1897 "Optimistically trying known %s again.",
1898 !router_have_minimum_dir_info() ?
1899 "used client functionality lately" :
1900 "received a consensus with exits",
1901 options
->UseBridges
? "bridges" : "entrynodes");
1902 entries_retry_all(options
);
1903 } else if (!options
->UseBridges
|| any_bridge_descriptors_known()) {
1904 log_fn(severity
, LD_APP
|LD_DIR
,
1905 "Application request when we haven't %s. "
1906 "Optimistically trying directory fetches again.",
1907 !router_have_minimum_dir_info() ?
1908 "used client functionality lately" :
1909 "received a consensus with exits");
1910 routerlist_retry_directory_downloads(time(NULL
));
1913 /* the stream will be dealt with when router_have_minimum_dir_info becomes
1914 * 1, or when all directory attempts fail and directory_all_unreachable()
1920 /* Do we need to check exit policy? */
1921 if (check_exit_policy
) {
1922 if (!conn
->chosen_exit_name
) {
1924 tor_addr_t addr
, *addrp
=NULL
;
1925 if (tor_inet_aton(conn
->socks_request
->address
, &in
)) {
1926 tor_addr_from_in(&addr
, &in
);
1929 if (router_exit_policy_all_nodes_reject(addrp
,
1930 conn
->socks_request
->port
,
1933 "No Tor server allows exit to %s:%d. Rejecting.",
1934 safe_str_client(conn
->socks_request
->address
),
1935 conn
->socks_request
->port
);
1939 /* XXXX024 Duplicates checks in connection_ap_handshake_attach_circuit:
1940 * refactor into a single function? */
1941 const node_t
*node
= node_get_by_nickname(conn
->chosen_exit_name
, 1);
1942 int opt
= conn
->chosen_exit_optional
;
1943 if (node
&& !connection_ap_can_use_exit(conn
, node
)) {
1944 log_fn(opt
? LOG_INFO
: LOG_WARN
, LD_APP
,
1945 "Requested exit point '%s' is excluded or "
1946 "would refuse request. %s.",
1947 conn
->chosen_exit_name
, opt
? "Trying others" : "Closing");
1949 conn
->chosen_exit_optional
= 0;
1950 tor_free(conn
->chosen_exit_name
);
1952 return circuit_get_open_circ_or_launch(conn
,
1953 desired_circuit_purpose
,
1961 /* is one already on the way? */
1962 circ
= circuit_get_best(conn
, 0, desired_circuit_purpose
,
1963 need_uptime
, need_internal
);
1965 log_debug(LD_CIRC
, "one on the way!");
1967 extend_info_t
*extend_info
=NULL
;
1968 uint8_t new_circ_purpose
;
1969 const int n_pending
= count_pending_general_client_circuits();
1971 if (n_pending
>= options
->MaxClientCircuitsPending
) {
1972 static ratelim_t delay_limit
= RATELIM_INIT(10*60);
1974 if ((m
= rate_limit_log(&delay_limit
, approx_time()))) {
1975 log_notice(LD_APP
, "We'd like to launch a circuit to handle a "
1976 "connection, but we already have %d general-purpose client "
1977 "circuits pending. Waiting until some finish.%s",
1984 if (desired_circuit_purpose
== CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
) {
1985 /* need to pick an intro point */
1986 rend_data_t
*rend_data
= ENTRY_TO_EDGE_CONN(conn
)->rend_data
;
1987 tor_assert(rend_data
);
1988 extend_info
= rend_client_get_random_intro(rend_data
);
1991 "No intro points for '%s': re-fetching service descriptor.",
1992 safe_str_client(rend_data
->onion_address
));
1993 rend_client_refetch_v2_renddesc(rend_data
);
1994 connection_ap_mark_as_non_pending_circuit(conn
);
1995 ENTRY_TO_CONN(conn
)->state
= AP_CONN_STATE_RENDDESC_WAIT
;
1998 log_info(LD_REND
,"Chose %s as intro point for '%s'.",
1999 extend_info_describe(extend_info
),
2000 safe_str_client(rend_data
->onion_address
));
2003 /* If we have specified a particular exit node for our
2004 * connection, then be sure to open a circuit to that exit node.
2006 if (desired_circuit_purpose
== CIRCUIT_PURPOSE_C_GENERAL
) {
2007 if (conn
->chosen_exit_name
) {
2009 int opt
= conn
->chosen_exit_optional
;
2010 r
= node_get_by_nickname(conn
->chosen_exit_name
, 1);
2011 if (r
&& node_has_descriptor(r
)) {
2012 /* We might want to connect to an IPv6 bridge for loading
2013 descriptors so we use the preferred address rather than
2015 extend_info
= extend_info_from_node(r
, conn
->want_onehop
? 1 : 0);
2017 log_warn(LD_CIRC
,"Could not make a one-hop connection to %s. "
2018 "Discarding this circuit.", conn
->chosen_exit_name
);
2022 log_debug(LD_DIR
, "considering %d, %s",
2023 want_onehop
, conn
->chosen_exit_name
);
2024 if (want_onehop
&& conn
->chosen_exit_name
[0] == '$') {
2025 /* We're asking for a one-hop circuit to a router that
2026 * we don't have a routerinfo about. Make up an extend_info. */
2027 char digest
[DIGEST_LEN
];
2028 char *hexdigest
= conn
->chosen_exit_name
+1;
2030 if (strlen(hexdigest
) < HEX_DIGEST_LEN
||
2031 base16_decode(digest
,DIGEST_LEN
,hexdigest
,HEX_DIGEST_LEN
)<0) {
2032 log_info(LD_DIR
, "Broken exit digest on tunnel conn. Closing.");
2035 if (tor_addr_parse(&addr
, conn
->socks_request
->address
) < 0) {
2036 log_info(LD_DIR
, "Broken address %s on tunnel conn. Closing.",
2037 escaped_safe_str_client(conn
->socks_request
->address
));
2040 extend_info
= extend_info_new(conn
->chosen_exit_name
+1,
2041 digest
, NULL
, NULL
, &addr
,
2042 conn
->socks_request
->port
);
2044 /* We will need an onion key for the router, and we
2045 * don't have one. Refuse or relax requirements. */
2046 log_fn(opt
? LOG_INFO
: LOG_WARN
, LD_APP
,
2047 "Requested exit point '%s' is not known. %s.",
2048 conn
->chosen_exit_name
, opt
? "Trying others" : "Closing");
2050 conn
->chosen_exit_optional
= 0;
2051 tor_free(conn
->chosen_exit_name
);
2052 /* Try again with no requested exit */
2053 return circuit_get_open_circ_or_launch(conn
,
2054 desired_circuit_purpose
,
2063 if (desired_circuit_purpose
== CIRCUIT_PURPOSE_C_REND_JOINED
)
2064 new_circ_purpose
= CIRCUIT_PURPOSE_C_ESTABLISH_REND
;
2065 else if (desired_circuit_purpose
== CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
)
2066 new_circ_purpose
= CIRCUIT_PURPOSE_C_INTRODUCING
;
2068 new_circ_purpose
= desired_circuit_purpose
;
2070 #ifdef ENABLE_TOR2WEB_MODE
2071 if (options
->Tor2webMode
&&
2072 (new_circ_purpose
== CIRCUIT_PURPOSE_C_ESTABLISH_REND
||
2073 new_circ_purpose
== CIRCUIT_PURPOSE_C_INTRODUCING
)) {
2079 int flags
= CIRCLAUNCH_NEED_CAPACITY
;
2080 if (want_onehop
) flags
|= CIRCLAUNCH_ONEHOP_TUNNEL
;
2081 if (need_uptime
) flags
|= CIRCLAUNCH_NEED_UPTIME
;
2082 if (need_internal
) flags
|= CIRCLAUNCH_IS_INTERNAL
;
2083 circ
= circuit_launch_by_extend_info(new_circ_purpose
, extend_info
,
2087 extend_info_free(extend_info
);
2089 if (desired_circuit_purpose
== CIRCUIT_PURPOSE_C_GENERAL
) {
2090 /* We just caused a circuit to get built because of this stream.
2091 * If this stream has caused a _lot_ of circuits to be built, that's
2092 * a bad sign: we should tell the user. */
2093 if (conn
->num_circuits_launched
< NUM_CIRCUITS_LAUNCHED_THRESHOLD
&&
2094 ++conn
->num_circuits_launched
== NUM_CIRCUITS_LAUNCHED_THRESHOLD
)
2095 log_info(LD_CIRC
, "The application request to %s:%d has launched "
2096 "%d circuits without finding one it likes.",
2097 escaped_safe_str_client(conn
->socks_request
->address
),
2098 conn
->socks_request
->port
,
2099 conn
->num_circuits_launched
);
2101 /* help predict this next time */
2102 rep_hist_note_used_internal(time(NULL
), need_uptime
, 1);
2104 /* write the service_id into circ */
2105 circ
->rend_data
= rend_data_dup(ENTRY_TO_EDGE_CONN(conn
)->rend_data
);
2106 if (circ
->base_
.purpose
== CIRCUIT_PURPOSE_C_ESTABLISH_REND
&&
2107 circ
->base_
.state
== CIRCUIT_STATE_OPEN
)
2108 circuit_has_opened(circ
);
2111 } /* endif (!circ) */
2113 /* Mark the circuit with the isolation fields for this connection.
2114 * When the circuit arrives, we'll clear these flags: this is
2115 * just some internal bookkeeping to make sure that we have
2116 * launched enough circuits.
2118 connection_edge_update_circuit_isolation(conn
, circ
, 0);
2121 "No safe circuit (purpose %d) ready for edge "
2122 "connection; delaying.",
2123 desired_circuit_purpose
);
2129 /** Return true iff <b>crypt_path</b> is one of the crypt_paths for
2132 cpath_is_on_circuit(origin_circuit_t
*circ
, crypt_path_t
*crypt_path
)
2134 crypt_path_t
*cpath
, *cpath_next
= NULL
;
2135 for (cpath
= circ
->cpath
; cpath_next
!= circ
->cpath
; cpath
= cpath_next
) {
2136 cpath_next
= cpath
->next
;
2137 if (crypt_path
== cpath
)
2143 /** Return true iff client-side optimistic data is supported. */
2145 optimistic_data_enabled(void)
2147 const or_options_t
*options
= get_options();
2148 if (options
->OptimisticData
< 0) {
2149 /* XXX023 consider having auto default to 1 rather than 0 before
2150 * the 0.2.3 branch goes stable. See bug 3617. -RD */
2151 const int32_t enabled
=
2152 networkstatus_get_param(NULL
, "UseOptimisticData", 0, 0, 1);
2153 return (int)enabled
;
2155 return options
->OptimisticData
;
2158 /** Attach the AP stream <b>apconn</b> to circ's linked list of
2159 * p_streams. Also set apconn's cpath_layer to <b>cpath</b>, or to the last
2160 * hop in circ's cpath if <b>cpath</b> is NULL.
2163 link_apconn_to_circ(entry_connection_t
*apconn
, origin_circuit_t
*circ
,
2164 crypt_path_t
*cpath
)
2166 const node_t
*exitnode
= NULL
;
2168 /* add it into the linked list of streams on this circuit */
2169 log_debug(LD_APP
|LD_CIRC
, "attaching new conn to circ. n_circ_id %u.",
2170 (unsigned)circ
->base_
.n_circ_id
);
2171 /* reset it, so we can measure circ timeouts */
2172 ENTRY_TO_CONN(apconn
)->timestamp_lastread
= time(NULL
);
2173 ENTRY_TO_EDGE_CONN(apconn
)->next_stream
= circ
->p_streams
;
2174 ENTRY_TO_EDGE_CONN(apconn
)->on_circuit
= TO_CIRCUIT(circ
);
2175 /* assert_connection_ok(conn, time(NULL)); */
2176 circ
->p_streams
= ENTRY_TO_EDGE_CONN(apconn
);
2178 if (connection_edge_is_rendezvous_stream(ENTRY_TO_EDGE_CONN(apconn
))) {
2179 /* We are attaching a stream to a rendezvous circuit. That means
2180 * that an attempt to connect to a hidden service just
2181 * succeeded. Tell rendclient.c. */
2182 rend_client_note_connection_attempt_ended(
2183 ENTRY_TO_EDGE_CONN(apconn
)->rend_data
);
2186 if (cpath
) { /* we were given one; use it */
2187 tor_assert(cpath_is_on_circuit(circ
, cpath
));
2189 /* use the last hop in the circuit */
2190 tor_assert(circ
->cpath
);
2191 tor_assert(circ
->cpath
->prev
);
2192 tor_assert(circ
->cpath
->prev
->state
== CPATH_STATE_OPEN
);
2193 cpath
= circ
->cpath
->prev
;
2195 ENTRY_TO_EDGE_CONN(apconn
)->cpath_layer
= cpath
;
2197 circ
->isolation_any_streams_attached
= 1;
2198 connection_edge_update_circuit_isolation(apconn
, circ
, 0);
2200 /* Compute the exitnode if possible, for logging below */
2201 if (cpath
->extend_info
)
2202 exitnode
= node_get_by_id(cpath
->extend_info
->identity_digest
);
2204 /* See if we can use optimistic data on this circuit */
2205 if (optimistic_data_enabled() &&
2206 (circ
->base_
.purpose
== CIRCUIT_PURPOSE_C_GENERAL
||
2207 circ
->base_
.purpose
== CIRCUIT_PURPOSE_C_REND_JOINED
))
2208 apconn
->may_use_optimistic_data
= 1;
2210 apconn
->may_use_optimistic_data
= 0;
2211 log_info(LD_APP
, "Looks like completed circuit to %s %s allow "
2212 "optimistic data for connection to %s",
2213 circ
->base_
.purpose
== CIRCUIT_PURPOSE_C_GENERAL
?
2214 /* node_describe() does the right thing if exitnode is NULL */
2215 safe_str_client(node_describe(exitnode
)) :
2217 apconn
->may_use_optimistic_data
? "does" : "doesn't",
2218 safe_str_client(apconn
->socks_request
->address
));
2221 /** Return true iff <b>address</b> is matched by one of the entries in
2222 * TrackHostExits. */
2224 hostname_in_track_host_exits(const or_options_t
*options
, const char *address
)
2226 if (!options
->TrackHostExits
)
2228 SMARTLIST_FOREACH_BEGIN(options
->TrackHostExits
, const char *, cp
) {
2229 if (cp
[0] == '.') { /* match end */
2230 if (cp
[1] == '\0' ||
2231 !strcasecmpend(address
, cp
) ||
2232 !strcasecmp(address
, &cp
[1]))
2234 } else if (strcasecmp(cp
, address
) == 0) {
2237 } SMARTLIST_FOREACH_END(cp
);
2241 /** If an exit wasn't explicitly specified for <b>conn</b>, consider saving
2242 * the exit that we *did* choose for use by future connections to
2243 * <b>conn</b>'s destination.
2246 consider_recording_trackhost(const entry_connection_t
*conn
,
2247 const origin_circuit_t
*circ
)
2249 const or_options_t
*options
= get_options();
2250 char *new_address
= NULL
;
2251 char fp
[HEX_DIGEST_LEN
+1];
2253 /* Search the addressmap for this conn's destination. */
2254 /* If they're not in the address map.. */
2255 if (!options
->TrackHostExits
||
2256 addressmap_have_mapping(conn
->socks_request
->address
,
2257 options
->TrackHostExitsExpire
))
2258 return; /* nothing to track, or already mapped */
2260 if (!hostname_in_track_host_exits(options
, conn
->socks_request
->address
) ||
2261 !circ
->build_state
->chosen_exit
)
2264 /* write down the fingerprint of the chosen exit, not the nickname,
2265 * because the chosen exit might not be named. */
2266 base16_encode(fp
, sizeof(fp
),
2267 circ
->build_state
->chosen_exit
->identity_digest
, DIGEST_LEN
);
2269 /* Add this exit/hostname pair to the addressmap. */
2270 tor_asprintf(&new_address
, "%s.%s.exit",
2271 conn
->socks_request
->address
, fp
);
2273 addressmap_register(conn
->socks_request
->address
, new_address
,
2274 time(NULL
) + options
->TrackHostExitsExpire
,
2275 ADDRMAPSRC_TRACKEXIT
, 0, 0);
2278 /** Attempt to attach the connection <b>conn</b> to <b>circ</b>, and send a
2279 * begin or resolve cell as appropriate. Return values are as for
2280 * connection_ap_handshake_attach_circuit. The stream will exit from the hop
2281 * indicated by <b>cpath</b>, or from the last hop in circ's cpath if
2282 * <b>cpath</b> is NULL. */
2284 connection_ap_handshake_attach_chosen_circuit(entry_connection_t
*conn
,
2285 origin_circuit_t
*circ
,
2286 crypt_path_t
*cpath
)
2288 connection_t
*base_conn
= ENTRY_TO_CONN(conn
);
2290 tor_assert(base_conn
->state
== AP_CONN_STATE_CIRCUIT_WAIT
||
2291 base_conn
->state
== AP_CONN_STATE_CONTROLLER_WAIT
);
2292 tor_assert(conn
->socks_request
);
2294 tor_assert(circ
->base_
.state
== CIRCUIT_STATE_OPEN
);
2296 base_conn
->state
= AP_CONN_STATE_CIRCUIT_WAIT
;
2298 if (!circ
->base_
.timestamp_dirty
||
2299 ((conn
->entry_cfg
.isolation_flags
& ISO_SOCKSAUTH
) &&
2300 (conn
->entry_cfg
.socks_iso_keep_alive
) &&
2301 (conn
->socks_request
->usernamelen
||
2302 conn
->socks_request
->passwordlen
))) {
2303 /* When stream isolation is in use and controlled by an application
2304 * we are willing to keep using the stream. */
2305 circ
->base_
.timestamp_dirty
= approx_time();
2308 pathbias_count_use_attempt(circ
);
2310 link_apconn_to_circ(conn
, circ
, cpath
);
2311 tor_assert(conn
->socks_request
);
2312 if (conn
->socks_request
->command
== SOCKS_COMMAND_CONNECT
) {
2313 if (!conn
->use_begindir
)
2314 consider_recording_trackhost(conn
, circ
);
2315 if (connection_ap_handshake_send_begin(conn
) < 0)
2318 if (connection_ap_handshake_send_resolve(conn
) < 0)
2325 /** Try to find a safe live circuit for CONN_TYPE_AP connection conn. If
2326 * we don't find one: if conn cannot be handled by any known nodes,
2327 * warn and return -1 (conn needs to die, and is maybe already marked);
2328 * else launch new circuit (if necessary) and return 0.
2329 * Otherwise, associate conn with a safe live circuit, do the
2330 * right next step, and return 1.
2332 /* XXXX this function should mark for close whenever it returns -1;
2333 * its callers shouldn't have to worry about that. */
2335 connection_ap_handshake_attach_circuit(entry_connection_t
*conn
)
2337 connection_t
*base_conn
= ENTRY_TO_CONN(conn
);
2343 tor_assert(base_conn
->state
== AP_CONN_STATE_CIRCUIT_WAIT
);
2344 tor_assert(conn
->socks_request
);
2345 want_onehop
= conn
->want_onehop
;
2347 conn_age
= (int)(time(NULL
) - base_conn
->timestamp_created
);
2349 if (conn_age
>= get_options()->SocksTimeout
) {
2350 int severity
= (tor_addr_is_null(&base_conn
->addr
) && !base_conn
->port
) ?
2351 LOG_INFO
: LOG_NOTICE
;
2352 log_fn(severity
, LD_APP
,
2353 "Tried for %d seconds to get a connection to %s:%d. Giving up.",
2354 conn_age
, safe_str_client(conn
->socks_request
->address
),
2355 conn
->socks_request
->port
);
2359 if (!connection_edge_is_rendezvous_stream(ENTRY_TO_EDGE_CONN(conn
))) {
2360 /* we're a general conn */
2361 origin_circuit_t
*circ
=NULL
;
2363 /* Are we linked to a dir conn that aims to fetch a consensus?
2364 * We check here because this conn might no longer be needed. */
2365 if (base_conn
->linked_conn
&&
2366 base_conn
->linked_conn
->type
== CONN_TYPE_DIR
&&
2367 base_conn
->linked_conn
->purpose
== DIR_PURPOSE_FETCH_CONSENSUS
) {
2369 /* Yes we are. Is there a consensus fetch farther along than us? */
2370 if (networkstatus_consensus_is_already_downloading(
2371 TO_DIR_CONN(base_conn
->linked_conn
)->requested_resource
)) {
2372 /* We're doing the "multiple consensus fetch attempts" game from
2373 * proposal 210, and we're late to the party. Just close this conn.
2374 * The circuit and TLS conn that we made will time out after a while
2375 * if nothing else wants to use them. */
2376 log_info(LD_DIR
, "Closing extra consensus fetch (to %s) since one "
2377 "is already downloading.", base_conn
->linked_conn
->address
);
2382 if (conn
->chosen_exit_name
) {
2383 const node_t
*node
= node_get_by_nickname(conn
->chosen_exit_name
, 1);
2384 int opt
= conn
->chosen_exit_optional
;
2385 if (!node
&& !want_onehop
) {
2386 /* We ran into this warning when trying to extend a circuit to a
2387 * hidden service directory for which we didn't have a router
2388 * descriptor. See flyspray task 767 for more details. We should
2389 * keep this in mind when deciding to use BEGIN_DIR cells for other
2390 * directory requests as well. -KL*/
2391 log_fn(opt
? LOG_INFO
: LOG_WARN
, LD_APP
,
2392 "Requested exit point '%s' is not known. %s.",
2393 conn
->chosen_exit_name
, opt
? "Trying others" : "Closing");
2395 conn
->chosen_exit_optional
= 0;
2396 tor_free(conn
->chosen_exit_name
);
2401 if (node
&& !connection_ap_can_use_exit(conn
, node
)) {
2402 log_fn(opt
? LOG_INFO
: LOG_WARN
, LD_APP
,
2403 "Requested exit point '%s' is excluded or "
2404 "would refuse request. %s.",
2405 conn
->chosen_exit_name
, opt
? "Trying others" : "Closing");
2407 conn
->chosen_exit_optional
= 0;
2408 tor_free(conn
->chosen_exit_name
);
2415 /* find the circuit that we should use, if there is one. */
2416 retval
= circuit_get_open_circ_or_launch(
2417 conn
, CIRCUIT_PURPOSE_C_GENERAL
, &circ
);
2418 if (retval
< 1) // XXX023 if we totally fail, this still returns 0 -RD
2421 log_debug(LD_APP
|LD_CIRC
,
2422 "Attaching apconn to circ %u (stream %d sec old).",
2423 (unsigned)circ
->base_
.n_circ_id
, conn_age
);
2424 /* print the circ's path, so people can figure out which circs are
2426 circuit_log_path(LOG_INFO
,LD_APP
|LD_CIRC
,circ
);
2428 /* We have found a suitable circuit for our conn. Hurray. */
2429 return connection_ap_handshake_attach_chosen_circuit(conn
, circ
, NULL
);
2431 } else { /* we're a rendezvous conn */
2432 origin_circuit_t
*rendcirc
=NULL
, *introcirc
=NULL
;
2434 tor_assert(!ENTRY_TO_EDGE_CONN(conn
)->cpath_layer
);
2436 /* start by finding a rendezvous circuit for us */
2438 retval
= circuit_get_open_circ_or_launch(
2439 conn
, CIRCUIT_PURPOSE_C_REND_JOINED
, &rendcirc
);
2440 if (retval
< 0) return -1; /* failed */
2443 tor_assert(rendcirc
);
2444 /* one is already established, attach */
2446 "rend joined circ %u already here. attaching. "
2447 "(stream %d sec old)",
2448 (unsigned)rendcirc
->base_
.n_circ_id
, conn_age
);
2449 /* Mark rendezvous circuits as 'newly dirty' every time you use
2450 * them, since the process of rebuilding a rendezvous circ is so
2451 * expensive. There is a tradeoff between linkability and
2452 * feasibility, at this point.
2454 rendcirc
->base_
.timestamp_dirty
= time(NULL
);
2456 /* We've also attempted to use them. If they fail, we need to
2457 * probe them for path bias */
2458 pathbias_count_use_attempt(rendcirc
);
2460 link_apconn_to_circ(conn
, rendcirc
, NULL
);
2461 if (connection_ap_handshake_send_begin(conn
) < 0)
2462 return 0; /* already marked, let them fade away */
2466 /* At this point we need to re-check the state, since it's possible that
2467 * our call to circuit_get_open_circ_or_launch() changed the connection's
2468 * state from "CIRCUIT_WAIT" to "RENDDESC_WAIT" because we decided to
2469 * re-fetch the descriptor.
2471 if (ENTRY_TO_CONN(conn
)->state
!= AP_CONN_STATE_CIRCUIT_WAIT
) {
2472 log_info(LD_REND
, "This connection is no longer ready to attach; its "
2474 "(We probably have to re-fetch its descriptor.)");
2478 if (rendcirc
&& (rendcirc
->base_
.purpose
==
2479 CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED
)) {
2481 "pending-join circ %u already here, with intro ack. "
2482 "Stalling. (stream %d sec old)",
2483 (unsigned)rendcirc
->base_
.n_circ_id
, conn_age
);
2487 /* it's on its way. find an intro circ. */
2488 retval
= circuit_get_open_circ_or_launch(
2489 conn
, CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
, &introcirc
);
2490 if (retval
< 0) return -1; /* failed */
2493 /* one has already sent the intro. keep waiting. */
2494 tor_assert(introcirc
);
2495 log_info(LD_REND
, "Intro circ %u present and awaiting ack (rend %u). "
2496 "Stalling. (stream %d sec old)",
2497 (unsigned)introcirc
->base_
.n_circ_id
,
2498 rendcirc
? (unsigned)rendcirc
->base_
.n_circ_id
: 0,
2503 /* now rendcirc and introcirc are each either undefined or not finished */
2505 if (rendcirc
&& introcirc
&&
2506 rendcirc
->base_
.purpose
== CIRCUIT_PURPOSE_C_REND_READY
) {
2508 "ready rend circ %u already here (no intro-ack yet on "
2509 "intro %u). (stream %d sec old)",
2510 (unsigned)rendcirc
->base_
.n_circ_id
,
2511 (unsigned)introcirc
->base_
.n_circ_id
, conn_age
);
2513 tor_assert(introcirc
->base_
.purpose
== CIRCUIT_PURPOSE_C_INTRODUCING
);
2514 if (introcirc
->base_
.state
== CIRCUIT_STATE_OPEN
) {
2515 log_info(LD_REND
,"found open intro circ %u (rend %u); sending "
2516 "introduction. (stream %d sec old)",
2517 (unsigned)introcirc
->base_
.n_circ_id
,
2518 (unsigned)rendcirc
->base_
.n_circ_id
,
2520 switch (rend_client_send_introduction(introcirc
, rendcirc
)) {
2521 case 0: /* success */
2522 rendcirc
->base_
.timestamp_dirty
= time(NULL
);
2523 introcirc
->base_
.timestamp_dirty
= time(NULL
);
2525 pathbias_count_use_attempt(introcirc
);
2526 pathbias_count_use_attempt(rendcirc
);
2528 assert_circuit_ok(TO_CIRCUIT(rendcirc
));
2529 assert_circuit_ok(TO_CIRCUIT(introcirc
));
2531 case -1: /* transient error */
2533 case -2: /* permanent error */
2536 tor_fragile_assert();
2542 log_info(LD_REND
, "Intro (%u) and rend (%u) circs are not both ready. "
2543 "Stalling conn. (%d sec old)",
2544 introcirc
? (unsigned)introcirc
->base_
.n_circ_id
: 0,
2545 rendcirc
? (unsigned)rendcirc
->base_
.n_circ_id
: 0, conn_age
);
2550 /** Change <b>circ</b>'s purpose to <b>new_purpose</b>. */
2552 circuit_change_purpose(circuit_t
*circ
, uint8_t new_purpose
)
2554 uint8_t old_purpose
;
2555 /* Don't allow an OR circ to become an origin circ or vice versa. */
2556 tor_assert(!!(CIRCUIT_IS_ORIGIN(circ
)) ==
2557 !!(CIRCUIT_PURPOSE_IS_ORIGIN(new_purpose
)));
2559 if (circ
->purpose
== new_purpose
) return;
2561 if (CIRCUIT_IS_ORIGIN(circ
)) {
2562 char old_purpose_desc
[80] = "";
2564 strncpy(old_purpose_desc
, circuit_purpose_to_string(circ
->purpose
), 80-1);
2565 old_purpose_desc
[80-1] = '\0';
2568 "changing purpose of origin circ %d "
2569 "from \"%s\" (%d) to \"%s\" (%d)",
2570 TO_ORIGIN_CIRCUIT(circ
)->global_identifier
,
2573 circuit_purpose_to_string(new_purpose
),
2577 old_purpose
= circ
->purpose
;
2578 circ
->purpose
= new_purpose
;
2580 if (CIRCUIT_IS_ORIGIN(circ
)) {
2581 control_event_circuit_purpose_changed(TO_ORIGIN_CIRCUIT(circ
),
2586 /** Mark <b>circ</b> so that no more connections can be attached to it. */
2588 mark_circuit_unusable_for_new_conns(origin_circuit_t
*circ
)
2590 const or_options_t
*options
= get_options();
2593 /* XXXX025 This is a kludge; we're only keeping it around in case there's
2594 * something that doesn't check unusable_for_new_conns, and to avoid
2595 * deeper refactoring of our expiration logic. */
2596 if (! circ
->base_
.timestamp_dirty
)
2597 circ
->base_
.timestamp_dirty
= approx_time();
2598 if (options
->MaxCircuitDirtiness
>= circ
->base_
.timestamp_dirty
)
2599 circ
->base_
.timestamp_dirty
= 1; /* prevent underflow */
2601 circ
->base_
.timestamp_dirty
-= options
->MaxCircuitDirtiness
;
2603 circ
->unusable_for_new_conns
= 1;