circuituse.c 89 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393
  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-2013, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  6. /**
  7. * \file circuituse.c
  8. * \brief Launch the right sort of circuits and attach streams to them.
  9. **/
  10. #include "or.h"
  11. #include "addressmap.h"
  12. #include "channel.h"
  13. #include "circpathbias.h"
  14. #include "circuitbuild.h"
  15. #include "circuitlist.h"
  16. #include "circuitstats.h"
  17. #include "circuituse.h"
  18. #include "config.h"
  19. #include "connection.h"
  20. #include "connection_edge.h"
  21. #include "control.h"
  22. #include "entrynodes.h"
  23. #include "nodelist.h"
  24. #include "networkstatus.h"
  25. #include "policies.h"
  26. #include "rendclient.h"
  27. #include "rendcommon.h"
  28. #include "rendservice.h"
  29. #include "rephist.h"
  30. #include "router.h"
  31. #include "routerlist.h"
  32. static void circuit_expire_old_circuits_clientside(void);
  33. static void circuit_increment_failure_count(void);
  34. /** Return 1 if <b>circ</b> could be returned by circuit_get_best().
  35. * Else return 0.
  36. */
  37. static int
  38. circuit_is_acceptable(const origin_circuit_t *origin_circ,
  39. const entry_connection_t *conn,
  40. int must_be_open, uint8_t purpose,
  41. int need_uptime, int need_internal,
  42. time_t now)
  43. {
  44. const circuit_t *circ = TO_CIRCUIT(origin_circ);
  45. const node_t *exitnode;
  46. cpath_build_state_t *build_state;
  47. tor_assert(circ);
  48. tor_assert(conn);
  49. tor_assert(conn->socks_request);
  50. if (must_be_open && (circ->state != CIRCUIT_STATE_OPEN || !circ->n_chan))
  51. return 0; /* ignore non-open circs */
  52. if (circ->marked_for_close)
  53. return 0;
  54. /* if this circ isn't our purpose, skip. */
  55. if (purpose == CIRCUIT_PURPOSE_C_REND_JOINED && !must_be_open) {
  56. if (circ->purpose != CIRCUIT_PURPOSE_C_ESTABLISH_REND &&
  57. circ->purpose != CIRCUIT_PURPOSE_C_REND_READY &&
  58. circ->purpose != CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED &&
  59. circ->purpose != CIRCUIT_PURPOSE_C_REND_JOINED)
  60. return 0;
  61. } else if (purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT &&
  62. !must_be_open) {
  63. if (circ->purpose != CIRCUIT_PURPOSE_C_INTRODUCING &&
  64. circ->purpose != CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT)
  65. return 0;
  66. } else {
  67. if (purpose != circ->purpose)
  68. return 0;
  69. }
  70. /* If this is a timed-out hidden service circuit, skip it. */
  71. if (origin_circ->hs_circ_has_timed_out) {
  72. return 0;
  73. }
  74. if (purpose == CIRCUIT_PURPOSE_C_GENERAL ||
  75. purpose == CIRCUIT_PURPOSE_C_REND_JOINED) {
  76. if (circ->timestamp_dirty &&
  77. circ->timestamp_dirty+get_options()->MaxCircuitDirtiness <= now)
  78. return 0;
  79. }
  80. if (origin_circ->unusable_for_new_conns)
  81. return 0;
  82. /* decide if this circ is suitable for this conn */
  83. /* for rend circs, circ->cpath->prev is not the last router in the
  84. * circuit, it's the magical extra bob hop. so just check the nickname
  85. * of the one we meant to finish at.
  86. */
  87. build_state = origin_circ->build_state;
  88. exitnode = build_state_get_exit_node(build_state);
  89. if (need_uptime && !build_state->need_uptime)
  90. return 0;
  91. if (need_internal != build_state->is_internal)
  92. return 0;
  93. if (purpose == CIRCUIT_PURPOSE_C_GENERAL) {
  94. tor_addr_t addr;
  95. const int family = tor_addr_parse(&addr, conn->socks_request->address);
  96. if (!exitnode && !build_state->onehop_tunnel) {
  97. log_debug(LD_CIRC,"Not considering circuit with unknown router.");
  98. return 0; /* this circuit is screwed and doesn't know it yet,
  99. * or is a rendezvous circuit. */
  100. }
  101. if (build_state->onehop_tunnel) {
  102. if (!conn->want_onehop) {
  103. log_debug(LD_CIRC,"Skipping one-hop circuit.");
  104. return 0;
  105. }
  106. tor_assert(conn->chosen_exit_name);
  107. if (build_state->chosen_exit) {
  108. char digest[DIGEST_LEN];
  109. if (hexdigest_to_digest(conn->chosen_exit_name, digest) < 0)
  110. return 0; /* broken digest, we don't want it */
  111. if (tor_memneq(digest, build_state->chosen_exit->identity_digest,
  112. DIGEST_LEN))
  113. return 0; /* this is a circuit to somewhere else */
  114. if (tor_digest_is_zero(digest)) {
  115. /* we don't know the digest; have to compare addr:port */
  116. if (family < 0 ||
  117. !tor_addr_eq(&build_state->chosen_exit->addr, &addr) ||
  118. build_state->chosen_exit->port != conn->socks_request->port)
  119. return 0;
  120. }
  121. }
  122. } else {
  123. if (conn->want_onehop) {
  124. /* don't use three-hop circuits -- that could hurt our anonymity. */
  125. return 0;
  126. }
  127. }
  128. if (origin_circ->prepend_policy && family != -1) {
  129. int r = compare_tor_addr_to_addr_policy(&addr,
  130. conn->socks_request->port,
  131. origin_circ->prepend_policy);
  132. if (r == ADDR_POLICY_REJECTED)
  133. return 0;
  134. }
  135. if (exitnode && !connection_ap_can_use_exit(conn, exitnode)) {
  136. /* can't exit from this router */
  137. return 0;
  138. }
  139. } else { /* not general */
  140. const edge_connection_t *edge_conn = ENTRY_TO_EDGE_CONN(conn);
  141. if ((edge_conn->rend_data && !origin_circ->rend_data) ||
  142. (!edge_conn->rend_data && origin_circ->rend_data) ||
  143. (edge_conn->rend_data && origin_circ->rend_data &&
  144. rend_cmp_service_ids(edge_conn->rend_data->onion_address,
  145. origin_circ->rend_data->onion_address))) {
  146. /* this circ is not for this conn */
  147. return 0;
  148. }
  149. }
  150. if (!connection_edge_compatible_with_circuit(conn, origin_circ)) {
  151. /* conn needs to be isolated from other conns that have already used
  152. * origin_circ */
  153. return 0;
  154. }
  155. return 1;
  156. }
  157. /** Return 1 if circuit <b>a</b> is better than circuit <b>b</b> for
  158. * <b>conn</b>, and return 0 otherwise. Used by circuit_get_best.
  159. */
  160. static int
  161. circuit_is_better(const origin_circuit_t *oa, const origin_circuit_t *ob,
  162. const entry_connection_t *conn)
  163. {
  164. const circuit_t *a = TO_CIRCUIT(oa);
  165. const circuit_t *b = TO_CIRCUIT(ob);
  166. const uint8_t purpose = ENTRY_TO_CONN(conn)->purpose;
  167. int a_bits, b_bits;
  168. /* If one of the circuits was allowed to live due to relaxing its timeout,
  169. * it is definitely worse (it's probably a much slower path). */
  170. if (oa->relaxed_timeout && !ob->relaxed_timeout)
  171. return 0; /* ob is better. It's not relaxed. */
  172. if (!oa->relaxed_timeout && ob->relaxed_timeout)
  173. return 1; /* oa is better. It's not relaxed. */
  174. switch (purpose) {
  175. case CIRCUIT_PURPOSE_C_GENERAL:
  176. /* if it's used but less dirty it's best;
  177. * else if it's more recently created it's best
  178. */
  179. if (b->timestamp_dirty) {
  180. if (a->timestamp_dirty &&
  181. a->timestamp_dirty > b->timestamp_dirty)
  182. return 1;
  183. } else {
  184. if (a->timestamp_dirty ||
  185. timercmp(&a->timestamp_began, &b->timestamp_began, >))
  186. return 1;
  187. if (ob->build_state->is_internal)
  188. /* XXX023 what the heck is this internal thing doing here. I
  189. * think we can get rid of it. circuit_is_acceptable() already
  190. * makes sure that is_internal is exactly what we need it to
  191. * be. -RD */
  192. return 1;
  193. }
  194. break;
  195. case CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT:
  196. /* the closer it is to ack_wait the better it is */
  197. if (a->purpose > b->purpose)
  198. return 1;
  199. break;
  200. case CIRCUIT_PURPOSE_C_REND_JOINED:
  201. /* the closer it is to rend_joined the better it is */
  202. if (a->purpose > b->purpose)
  203. return 1;
  204. break;
  205. }
  206. /* XXXX023 Maybe this check should get a higher priority to avoid
  207. * using up circuits too rapidly. */
  208. a_bits = connection_edge_update_circuit_isolation(conn,
  209. (origin_circuit_t*)oa, 1);
  210. b_bits = connection_edge_update_circuit_isolation(conn,
  211. (origin_circuit_t*)ob, 1);
  212. /* if x_bits < 0, then we have not used x for anything; better not to dirty
  213. * a connection if we can help it. */
  214. if (a_bits < 0) {
  215. return 0;
  216. } else if (b_bits < 0) {
  217. return 1;
  218. }
  219. a_bits &= ~ oa->isolation_flags_mixed;
  220. a_bits &= ~ ob->isolation_flags_mixed;
  221. if (n_bits_set_u8(a_bits) < n_bits_set_u8(b_bits)) {
  222. /* The fewer new restrictions we need to make on a circuit for stream
  223. * isolation, the better. */
  224. return 1;
  225. }
  226. return 0;
  227. }
  228. /** Find the best circ that conn can use, preferably one which is
  229. * dirty. Circ must not be too old.
  230. *
  231. * Conn must be defined.
  232. *
  233. * If must_be_open, ignore circs not in CIRCUIT_STATE_OPEN.
  234. *
  235. * circ_purpose specifies what sort of circuit we must have.
  236. * It can be C_GENERAL, C_INTRODUCE_ACK_WAIT, or C_REND_JOINED.
  237. *
  238. * If it's REND_JOINED and must_be_open==0, then return the closest
  239. * rendezvous-purposed circuit that you can find.
  240. *
  241. * If it's INTRODUCE_ACK_WAIT and must_be_open==0, then return the
  242. * closest introduce-purposed circuit that you can find.
  243. */
  244. static origin_circuit_t *
  245. circuit_get_best(const entry_connection_t *conn,
  246. int must_be_open, uint8_t purpose,
  247. int need_uptime, int need_internal)
  248. {
  249. circuit_t *circ;
  250. origin_circuit_t *best=NULL;
  251. struct timeval now;
  252. int intro_going_on_but_too_old = 0;
  253. tor_assert(conn);
  254. tor_assert(purpose == CIRCUIT_PURPOSE_C_GENERAL ||
  255. purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT ||
  256. purpose == CIRCUIT_PURPOSE_C_REND_JOINED);
  257. tor_gettimeofday(&now);
  258. TOR_LIST_FOREACH(circ, circuit_get_global_list(), head) {
  259. origin_circuit_t *origin_circ;
  260. if (!CIRCUIT_IS_ORIGIN(circ))
  261. continue;
  262. origin_circ = TO_ORIGIN_CIRCUIT(circ);
  263. /* Log an info message if we're going to launch a new intro circ in
  264. * parallel */
  265. if (purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT &&
  266. !must_be_open && origin_circ->hs_circ_has_timed_out) {
  267. intro_going_on_but_too_old = 1;
  268. continue;
  269. }
  270. if (!circuit_is_acceptable(origin_circ,conn,must_be_open,purpose,
  271. need_uptime,need_internal, (time_t)now.tv_sec))
  272. continue;
  273. /* now this is an acceptable circ to hand back. but that doesn't
  274. * mean it's the *best* circ to hand back. try to decide.
  275. */
  276. if (!best || circuit_is_better(origin_circ,best,conn))
  277. best = origin_circ;
  278. }
  279. if (!best && intro_going_on_but_too_old)
  280. log_info(LD_REND|LD_CIRC, "There is an intro circuit being created "
  281. "right now, but it has already taken quite a while. Starting "
  282. "one in parallel.");
  283. return best;
  284. }
  285. /** Return the number of not-yet-open general-purpose origin circuits. */
  286. static int
  287. count_pending_general_client_circuits(void)
  288. {
  289. const circuit_t *circ;
  290. int count = 0;
  291. TOR_LIST_FOREACH(circ, circuit_get_global_list(), head) {
  292. if (circ->marked_for_close ||
  293. circ->state == CIRCUIT_STATE_OPEN ||
  294. circ->purpose != CIRCUIT_PURPOSE_C_GENERAL ||
  295. !CIRCUIT_IS_ORIGIN(circ))
  296. continue;
  297. ++count;
  298. }
  299. return count;
  300. }
  301. #if 0
  302. /** Check whether, according to the policies in <b>options</b>, the
  303. * circuit <b>circ</b> makes sense. */
  304. /* XXXX currently only checks Exclude{Exit}Nodes; it should check more.
  305. * Also, it doesn't have the right definition of an exit circuit. Also,
  306. * it's never called. */
  307. int
  308. circuit_conforms_to_options(const origin_circuit_t *circ,
  309. const or_options_t *options)
  310. {
  311. const crypt_path_t *cpath, *cpath_next = NULL;
  312. /* first check if it includes any excluded nodes */
  313. for (cpath = circ->cpath; cpath_next != circ->cpath; cpath = cpath_next) {
  314. cpath_next = cpath->next;
  315. if (routerset_contains_extendinfo(options->ExcludeNodes,
  316. cpath->extend_info))
  317. return 0;
  318. }
  319. /* then consider the final hop */
  320. if (routerset_contains_extendinfo(options->ExcludeExitNodes,
  321. circ->cpath->prev->extend_info))
  322. return 0;
  323. return 1;
  324. }
  325. #endif
  326. /** Close all circuits that start at us, aren't open, and were born
  327. * at least CircuitBuildTimeout seconds ago.
  328. */
  329. void
  330. circuit_expire_building(void)
  331. {
  332. circuit_t *victim, *next_circ;
  333. /* circ_times.timeout_ms and circ_times.close_ms are from
  334. * circuit_build_times_get_initial_timeout() if we haven't computed
  335. * custom timeouts yet */
  336. struct timeval general_cutoff, begindir_cutoff, fourhop_cutoff,
  337. close_cutoff, extremely_old_cutoff, hs_extremely_old_cutoff,
  338. cannibalized_cutoff, c_intro_cutoff, s_intro_cutoff, stream_cutoff;
  339. const or_options_t *options = get_options();
  340. struct timeval now;
  341. cpath_build_state_t *build_state;
  342. int any_opened_circs = 0;
  343. tor_gettimeofday(&now);
  344. /* Check to see if we have any opened circuits. If we don't,
  345. * we want to be more lenient with timeouts, in case the
  346. * user has relocated and/or changed network connections.
  347. * See bug #3443. */
  348. TOR_LIST_FOREACH(next_circ, circuit_get_global_list(), head) {
  349. if (!CIRCUIT_IS_ORIGIN(next_circ) || /* didn't originate here */
  350. next_circ->marked_for_close) { /* don't mess with marked circs */
  351. continue;
  352. }
  353. if (TO_ORIGIN_CIRCUIT(next_circ)->has_opened &&
  354. next_circ->state == CIRCUIT_STATE_OPEN &&
  355. TO_ORIGIN_CIRCUIT(next_circ)->build_state &&
  356. TO_ORIGIN_CIRCUIT(next_circ)->build_state->desired_path_len
  357. == DEFAULT_ROUTE_LEN) {
  358. any_opened_circs = 1;
  359. break;
  360. }
  361. }
  362. #define SET_CUTOFF(target, msec) do { \
  363. long ms = tor_lround(msec); \
  364. struct timeval diff; \
  365. diff.tv_sec = ms / 1000; \
  366. diff.tv_usec = (int)((ms % 1000) * 1000); \
  367. timersub(&now, &diff, &target); \
  368. } while (0)
  369. /**
  370. * Because circuit build timeout is calculated only based on 3 hop
  371. * general purpose circuit construction, we need to scale the timeout
  372. * to make it properly apply to longer circuits, and circuits of
  373. * certain usage types. The following diagram illustrates how we
  374. * derive the scaling below. In short, we calculate the number
  375. * of times our telescoping-based circuit construction causes cells
  376. * to traverse each link for the circuit purpose types in question,
  377. * and then assume each link is equivalent.
  378. *
  379. * OP --a--> A --b--> B --c--> C
  380. * OP --a--> A --b--> B --c--> C --d--> D
  381. *
  382. * Let h = a = b = c = d
  383. *
  384. * Three hops (general_cutoff)
  385. * RTTs = 3a + 2b + c
  386. * RTTs = 6h
  387. * Cannibalized:
  388. * RTTs = a+b+c+d
  389. * RTTs = 4h
  390. * Four hops:
  391. * RTTs = 4a + 3b + 2c + d
  392. * RTTs = 10h
  393. * Client INTRODUCE1+ACK: // XXX: correct?
  394. * RTTs = 5a + 4b + 3c + 2d
  395. * RTTs = 14h
  396. * Server intro:
  397. * RTTs = 4a + 3b + 2c
  398. * RTTs = 9h
  399. */
  400. SET_CUTOFF(general_cutoff, get_circuit_build_timeout_ms());
  401. SET_CUTOFF(begindir_cutoff, get_circuit_build_timeout_ms());
  402. /* > 3hop circs seem to have a 1.0 second delay on their cannibalized
  403. * 4th hop. */
  404. SET_CUTOFF(fourhop_cutoff, get_circuit_build_timeout_ms() * (10/6.0) + 1000);
  405. /* CIRCUIT_PURPOSE_C_ESTABLISH_REND behaves more like a RELAY cell.
  406. * Use the stream cutoff (more or less). */
  407. SET_CUTOFF(stream_cutoff, MAX(options->CircuitStreamTimeout,15)*1000 + 1000);
  408. /* Be lenient with cannibalized circs. They already survived the official
  409. * CBT, and they're usually not performance-critical. */
  410. SET_CUTOFF(cannibalized_cutoff,
  411. MAX(get_circuit_build_close_time_ms()*(4/6.0),
  412. options->CircuitStreamTimeout * 1000) + 1000);
  413. /* Intro circs have an extra round trip (and are also 4 hops long) */
  414. SET_CUTOFF(c_intro_cutoff, get_circuit_build_timeout_ms() * (14/6.0) + 1000);
  415. /* Server intro circs have an extra round trip */
  416. SET_CUTOFF(s_intro_cutoff, get_circuit_build_timeout_ms() * (9/6.0) + 1000);
  417. SET_CUTOFF(close_cutoff, get_circuit_build_close_time_ms());
  418. SET_CUTOFF(extremely_old_cutoff, get_circuit_build_close_time_ms()*2 + 1000);
  419. SET_CUTOFF(hs_extremely_old_cutoff,
  420. MAX(get_circuit_build_close_time_ms()*2 + 1000,
  421. options->SocksTimeout * 1000));
  422. TOR_LIST_FOREACH(next_circ, circuit_get_global_list(), head) {
  423. struct timeval cutoff;
  424. victim = next_circ;
  425. if (!CIRCUIT_IS_ORIGIN(victim) || /* didn't originate here */
  426. victim->marked_for_close) /* don't mess with marked circs */
  427. continue;
  428. /* If we haven't yet started the first hop, it means we don't have
  429. * any orconns available, and thus have not started counting time yet
  430. * for this circuit. See circuit_deliver_create_cell() and uses of
  431. * timestamp_began.
  432. *
  433. * Continue to wait in this case. The ORConn should timeout
  434. * independently and kill us then.
  435. */
  436. if (TO_ORIGIN_CIRCUIT(victim)->cpath->state == CPATH_STATE_CLOSED) {
  437. continue;
  438. }
  439. build_state = TO_ORIGIN_CIRCUIT(victim)->build_state;
  440. if (build_state && build_state->onehop_tunnel)
  441. cutoff = begindir_cutoff;
  442. else if (victim->purpose == CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT)
  443. cutoff = close_cutoff;
  444. else if (victim->purpose == CIRCUIT_PURPOSE_C_INTRODUCING ||
  445. victim->purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT)
  446. cutoff = c_intro_cutoff;
  447. else if (victim->purpose == CIRCUIT_PURPOSE_S_ESTABLISH_INTRO)
  448. cutoff = s_intro_cutoff;
  449. else if (victim->purpose == CIRCUIT_PURPOSE_C_ESTABLISH_REND)
  450. cutoff = stream_cutoff;
  451. else if (victim->purpose == CIRCUIT_PURPOSE_PATH_BIAS_TESTING)
  452. cutoff = close_cutoff;
  453. else if (TO_ORIGIN_CIRCUIT(victim)->has_opened &&
  454. victim->state != CIRCUIT_STATE_OPEN)
  455. cutoff = cannibalized_cutoff;
  456. else if (build_state && build_state->desired_path_len >= 4)
  457. cutoff = fourhop_cutoff;
  458. else
  459. cutoff = general_cutoff;
  460. if (TO_ORIGIN_CIRCUIT(victim)->hs_circ_has_timed_out)
  461. cutoff = hs_extremely_old_cutoff;
  462. if (timercmp(&victim->timestamp_began, &cutoff, >))
  463. continue; /* it's still young, leave it alone */
  464. /* We need to double-check the opened state here because
  465. * we don't want to consider opened 1-hop dircon circuits for
  466. * deciding when to relax the timeout, but we *do* want to relax
  467. * those circuits too if nothing else is opened *and* they still
  468. * aren't either. */
  469. if (!any_opened_circs && victim->state != CIRCUIT_STATE_OPEN) {
  470. /* It's still young enough that we wouldn't close it, right? */
  471. if (timercmp(&victim->timestamp_began, &close_cutoff, >)) {
  472. if (!TO_ORIGIN_CIRCUIT(victim)->relaxed_timeout) {
  473. int first_hop_succeeded = TO_ORIGIN_CIRCUIT(victim)->cpath->state
  474. == CPATH_STATE_OPEN;
  475. log_info(LD_CIRC,
  476. "No circuits are opened. Relaxing timeout for circuit %d "
  477. "(a %s %d-hop circuit in state %s with channel state %s). "
  478. "%d guards are live.",
  479. TO_ORIGIN_CIRCUIT(victim)->global_identifier,
  480. circuit_purpose_to_string(victim->purpose),
  481. TO_ORIGIN_CIRCUIT(victim)->build_state ?
  482. TO_ORIGIN_CIRCUIT(victim)->build_state->desired_path_len :
  483. -1,
  484. circuit_state_to_string(victim->state),
  485. channel_state_to_string(victim->n_chan->state),
  486. num_live_entry_guards(0));
  487. /* We count the timeout here for CBT, because technically this
  488. * was a timeout, and the timeout value needs to reset if we
  489. * see enough of them. Note this means we also need to avoid
  490. * double-counting below, too. */
  491. circuit_build_times_count_timeout(get_circuit_build_times_mutable(),
  492. first_hop_succeeded);
  493. TO_ORIGIN_CIRCUIT(victim)->relaxed_timeout = 1;
  494. }
  495. continue;
  496. } else {
  497. static ratelim_t relax_timeout_limit = RATELIM_INIT(3600);
  498. const double build_close_ms = get_circuit_build_close_time_ms();
  499. log_fn_ratelim(&relax_timeout_limit, LOG_NOTICE, LD_CIRC,
  500. "No circuits are opened. Relaxed timeout for circuit %d "
  501. "(a %s %d-hop circuit in state %s with channel state %s) to "
  502. "%ldms. However, it appears the circuit has timed out "
  503. "anyway. %d guards are live.",
  504. TO_ORIGIN_CIRCUIT(victim)->global_identifier,
  505. circuit_purpose_to_string(victim->purpose),
  506. TO_ORIGIN_CIRCUIT(victim)->build_state ?
  507. TO_ORIGIN_CIRCUIT(victim)->build_state->desired_path_len :
  508. -1,
  509. circuit_state_to_string(victim->state),
  510. channel_state_to_string(victim->n_chan->state),
  511. (long)build_close_ms,
  512. num_live_entry_guards(0));
  513. }
  514. }
  515. #if 0
  516. /* some debug logs, to help track bugs */
  517. if (victim->purpose >= CIRCUIT_PURPOSE_C_INTRODUCING &&
  518. victim->purpose <= CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED) {
  519. if (!victim->timestamp_dirty)
  520. log_fn(LOG_DEBUG,"Considering %sopen purpose %d to %s (circid %d)."
  521. "(clean).",
  522. victim->state == CIRCUIT_STATE_OPEN ? "" : "non",
  523. victim->purpose, victim->build_state->chosen_exit_name,
  524. victim->n_circ_id);
  525. else
  526. log_fn(LOG_DEBUG,"Considering %sopen purpose %d to %s (circid %d). "
  527. "%d secs since dirty.",
  528. victim->state == CIRCUIT_STATE_OPEN ? "" : "non",
  529. victim->purpose, victim->build_state->chosen_exit_name,
  530. victim->n_circ_id,
  531. (int)(now - victim->timestamp_dirty));
  532. }
  533. #endif
  534. /* if circ is !open, or if it's open but purpose is a non-finished
  535. * intro or rend, then mark it for close */
  536. if (victim->state == CIRCUIT_STATE_OPEN) {
  537. switch (victim->purpose) {
  538. default: /* most open circuits can be left alone. */
  539. continue; /* yes, continue inside a switch refers to the nearest
  540. * enclosing loop. C is smart. */
  541. case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO:
  542. break; /* too old, need to die */
  543. case CIRCUIT_PURPOSE_C_REND_READY:
  544. /* it's a rend_ready circ -- has it already picked a query? */
  545. /* c_rend_ready circs measure age since timestamp_dirty,
  546. * because that's set when they switch purposes
  547. */
  548. if (TO_ORIGIN_CIRCUIT(victim)->rend_data ||
  549. victim->timestamp_dirty > cutoff.tv_sec)
  550. continue;
  551. break;
  552. case CIRCUIT_PURPOSE_PATH_BIAS_TESTING:
  553. /* Open path bias testing circuits are given a long
  554. * time to complete the test, but not forever */
  555. TO_ORIGIN_CIRCUIT(victim)->path_state = PATH_STATE_USE_FAILED;
  556. break;
  557. case CIRCUIT_PURPOSE_C_INTRODUCING:
  558. /* We keep old introducing circuits around for
  559. * a while in parallel, and they can end up "opened".
  560. * We decide below if we're going to mark them timed
  561. * out and eventually close them.
  562. */
  563. break;
  564. case CIRCUIT_PURPOSE_C_ESTABLISH_REND:
  565. case CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED:
  566. case CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT:
  567. /* rend and intro circs become dirty each time they
  568. * make an introduction attempt. so timestamp_dirty
  569. * will reflect the time since the last attempt.
  570. */
  571. if (victim->timestamp_dirty > cutoff.tv_sec)
  572. continue;
  573. break;
  574. }
  575. } else { /* circuit not open, consider recording failure as timeout */
  576. int first_hop_succeeded = TO_ORIGIN_CIRCUIT(victim)->cpath &&
  577. TO_ORIGIN_CIRCUIT(victim)->cpath->state == CPATH_STATE_OPEN;
  578. if (TO_ORIGIN_CIRCUIT(victim)->p_streams != NULL) {
  579. log_warn(LD_BUG, "Circuit %d (purpose %d, %s) has timed out, "
  580. "yet has attached streams!",
  581. TO_ORIGIN_CIRCUIT(victim)->global_identifier,
  582. victim->purpose,
  583. circuit_purpose_to_string(victim->purpose));
  584. tor_fragile_assert();
  585. continue;
  586. }
  587. if (circuit_timeout_want_to_count_circ(TO_ORIGIN_CIRCUIT(victim)) &&
  588. circuit_build_times_enough_to_compute(get_circuit_build_times())) {
  589. /* Circuits are allowed to last longer for measurement.
  590. * Switch their purpose and wait. */
  591. if (victim->purpose != CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT) {
  592. control_event_circuit_status(TO_ORIGIN_CIRCUIT(victim),
  593. CIRC_EVENT_FAILED,
  594. END_CIRC_REASON_TIMEOUT);
  595. circuit_change_purpose(victim, CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT);
  596. /* Record this failure to check for too many timeouts
  597. * in a row. This function does not record a time value yet
  598. * (we do that later); it only counts the fact that we did
  599. * have a timeout. We also want to avoid double-counting
  600. * already "relaxed" circuits, which are counted above. */
  601. if (!TO_ORIGIN_CIRCUIT(victim)->relaxed_timeout) {
  602. circuit_build_times_count_timeout(
  603. get_circuit_build_times_mutable(),
  604. first_hop_succeeded);
  605. }
  606. continue;
  607. }
  608. /*
  609. * If the circuit build time is much greater than we would have cut
  610. * it off at, we probably had a suspend event along this codepath,
  611. * and we should discard the value.
  612. */
  613. if (timercmp(&victim->timestamp_began, &extremely_old_cutoff, <)) {
  614. log_notice(LD_CIRC,
  615. "Extremely large value for circuit build timeout: %lds. "
  616. "Assuming clock jump. Purpose %d (%s)",
  617. (long)(now.tv_sec - victim->timestamp_began.tv_sec),
  618. victim->purpose,
  619. circuit_purpose_to_string(victim->purpose));
  620. } else if (circuit_build_times_count_close(
  621. get_circuit_build_times_mutable(),
  622. first_hop_succeeded,
  623. (time_t)victim->timestamp_created.tv_sec)) {
  624. circuit_build_times_set_timeout(get_circuit_build_times_mutable());
  625. }
  626. }
  627. }
  628. /* If this is a hidden service client circuit which is far enough
  629. * along in connecting to its destination, and we haven't already
  630. * flagged it as 'timed out', and the user has not told us to
  631. * close such circs immediately on timeout, flag it as 'timed out'
  632. * so we'll launch another intro or rend circ, but don't mark it
  633. * for close yet.
  634. *
  635. * (Circs flagged as 'timed out' are given a much longer timeout
  636. * period above, so we won't close them in the next call to
  637. * circuit_expire_building.) */
  638. if (!(options->CloseHSClientCircuitsImmediatelyOnTimeout) &&
  639. !(TO_ORIGIN_CIRCUIT(victim)->hs_circ_has_timed_out)) {
  640. switch (victim->purpose) {
  641. case CIRCUIT_PURPOSE_C_REND_READY:
  642. /* We only want to spare a rend circ if it has been specified in
  643. * an INTRODUCE1 cell sent to a hidden service. A circ's
  644. * pending_final_cpath field is non-NULL iff it is a rend circ
  645. * and we have tried to send an INTRODUCE1 cell specifying it.
  646. * Thus, if the pending_final_cpath field *is* NULL, then we
  647. * want to not spare it. */
  648. if (TO_ORIGIN_CIRCUIT(victim)->build_state &&
  649. TO_ORIGIN_CIRCUIT(victim)->build_state->pending_final_cpath ==
  650. NULL)
  651. break;
  652. /* fallthrough! */
  653. case CIRCUIT_PURPOSE_C_INTRODUCING:
  654. /* connection_ap_handshake_attach_circuit() will relaunch for us */
  655. case CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT:
  656. case CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED:
  657. /* If we have reached this line, we want to spare the circ for now. */
  658. log_info(LD_CIRC,"Marking circ %u (state %d:%s, purpose %d) "
  659. "as timed-out HS circ",
  660. (unsigned)victim->n_circ_id,
  661. victim->state, circuit_state_to_string(victim->state),
  662. victim->purpose);
  663. TO_ORIGIN_CIRCUIT(victim)->hs_circ_has_timed_out = 1;
  664. continue;
  665. default:
  666. break;
  667. }
  668. }
  669. /* If this is a service-side rendezvous circuit which is far
  670. * enough along in connecting to its destination, consider sparing
  671. * it. */
  672. if (!(options->CloseHSServiceRendCircuitsImmediatelyOnTimeout) &&
  673. !(TO_ORIGIN_CIRCUIT(victim)->hs_circ_has_timed_out) &&
  674. victim->purpose == CIRCUIT_PURPOSE_S_CONNECT_REND) {
  675. log_info(LD_CIRC,"Marking circ %u (state %d:%s, purpose %d) "
  676. "as timed-out HS circ; relaunching rendezvous attempt.",
  677. (unsigned)victim->n_circ_id,
  678. victim->state, circuit_state_to_string(victim->state),
  679. victim->purpose);
  680. TO_ORIGIN_CIRCUIT(victim)->hs_circ_has_timed_out = 1;
  681. rend_service_relaunch_rendezvous(TO_ORIGIN_CIRCUIT(victim));
  682. continue;
  683. }
  684. if (victim->n_chan)
  685. log_info(LD_CIRC,
  686. "Abandoning circ %u %s:%u (state %d,%d:%s, purpose %d, "
  687. "len %d)", TO_ORIGIN_CIRCUIT(victim)->global_identifier,
  688. channel_get_canonical_remote_descr(victim->n_chan),
  689. (unsigned)victim->n_circ_id,
  690. TO_ORIGIN_CIRCUIT(victim)->has_opened,
  691. victim->state, circuit_state_to_string(victim->state),
  692. victim->purpose,
  693. TO_ORIGIN_CIRCUIT(victim)->build_state ?
  694. TO_ORIGIN_CIRCUIT(victim)->build_state->desired_path_len :
  695. -1);
  696. else
  697. log_info(LD_CIRC,
  698. "Abandoning circ %u %u (state %d,%d:%s, purpose %d, len %d)",
  699. TO_ORIGIN_CIRCUIT(victim)->global_identifier,
  700. (unsigned)victim->n_circ_id,
  701. TO_ORIGIN_CIRCUIT(victim)->has_opened,
  702. victim->state,
  703. circuit_state_to_string(victim->state), victim->purpose,
  704. TO_ORIGIN_CIRCUIT(victim)->build_state ?
  705. TO_ORIGIN_CIRCUIT(victim)->build_state->desired_path_len :
  706. -1);
  707. circuit_log_path(LOG_INFO,LD_CIRC,TO_ORIGIN_CIRCUIT(victim));
  708. if (victim->purpose == CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT)
  709. circuit_mark_for_close(victim, END_CIRC_REASON_MEASUREMENT_EXPIRED);
  710. else
  711. circuit_mark_for_close(victim, END_CIRC_REASON_TIMEOUT);
  712. pathbias_count_timeout(TO_ORIGIN_CIRCUIT(victim));
  713. }
  714. }
  715. /**
  716. * As a diagnostic for bug 8387, log information about how many one-hop
  717. * circuits we have around that have been there for at least <b>age</b>
  718. * seconds. Log a few of them.
  719. */
  720. void
  721. circuit_log_ancient_one_hop_circuits(int age)
  722. {
  723. #define MAX_ANCIENT_ONEHOP_CIRCUITS_TO_LOG 10
  724. time_t cutoff = time(NULL) - age;
  725. int n_found = 0;
  726. smartlist_t *log_these = smartlist_new();
  727. const circuit_t *circ;
  728. TOR_LIST_FOREACH(circ, circuit_get_global_list(), head) {
  729. const origin_circuit_t *ocirc;
  730. if (! CIRCUIT_IS_ORIGIN(circ))
  731. continue;
  732. if (circ->timestamp_created.tv_sec >= cutoff)
  733. continue;
  734. ocirc = CONST_TO_ORIGIN_CIRCUIT(circ);
  735. if (ocirc->build_state && ocirc->build_state->onehop_tunnel) {
  736. ++n_found;
  737. if (smartlist_len(log_these) < MAX_ANCIENT_ONEHOP_CIRCUITS_TO_LOG)
  738. smartlist_add(log_these, (origin_circuit_t*) ocirc);
  739. }
  740. }
  741. if (n_found == 0)
  742. goto done;
  743. log_notice(LD_HEARTBEAT,
  744. "Diagnostic for issue 8387: Found %d one-hop circuits more "
  745. "than %d seconds old! Logging %d...",
  746. n_found, age, smartlist_len(log_these));
  747. SMARTLIST_FOREACH_BEGIN(log_these, const origin_circuit_t *, ocirc) {
  748. char created[ISO_TIME_LEN+1];
  749. circ = TO_CIRCUIT(ocirc);
  750. format_local_iso_time(created,
  751. (time_t)circ->timestamp_created.tv_sec);
  752. log_notice(LD_HEARTBEAT, " #%d created at %s. %s, %s. %s for close. "
  753. "%s for new conns.",
  754. ocirc_sl_idx,
  755. created,
  756. circuit_state_to_string(circ->state),
  757. circuit_purpose_to_string(circ->purpose),
  758. circ->marked_for_close ? "Marked" : "Not marked",
  759. ocirc->unusable_for_new_conns ? "Not usable" : "usable");
  760. } SMARTLIST_FOREACH_END(ocirc);
  761. done:
  762. smartlist_free(log_these);
  763. }
  764. /** Remove any elements in <b>needed_ports</b> that are handled by an
  765. * open or in-progress circuit.
  766. */
  767. void
  768. circuit_remove_handled_ports(smartlist_t *needed_ports)
  769. {
  770. int i;
  771. uint16_t *port;
  772. for (i = 0; i < smartlist_len(needed_ports); ++i) {
  773. port = smartlist_get(needed_ports, i);
  774. tor_assert(*port);
  775. if (circuit_stream_is_being_handled(NULL, *port,
  776. MIN_CIRCUITS_HANDLING_STREAM)) {
  777. // log_debug(LD_CIRC,"Port %d is already being handled; removing.", port);
  778. smartlist_del(needed_ports, i--);
  779. tor_free(port);
  780. } else {
  781. log_debug(LD_CIRC,"Port %d is not handled.", *port);
  782. }
  783. }
  784. }
  785. /** Return 1 if at least <b>min</b> general-purpose non-internal circuits
  786. * will have an acceptable exit node for exit stream <b>conn</b> if it
  787. * is defined, else for "*:port".
  788. * Else return 0.
  789. */
  790. int
  791. circuit_stream_is_being_handled(entry_connection_t *conn,
  792. uint16_t port, int min)
  793. {
  794. circuit_t *circ;
  795. const node_t *exitnode;
  796. int num=0;
  797. time_t now = time(NULL);
  798. int need_uptime = smartlist_contains_int_as_string(
  799. get_options()->LongLivedPorts,
  800. conn ? conn->socks_request->port : port);
  801. TOR_LIST_FOREACH(circ, circuit_get_global_list(), head) {
  802. if (CIRCUIT_IS_ORIGIN(circ) &&
  803. !circ->marked_for_close &&
  804. circ->purpose == CIRCUIT_PURPOSE_C_GENERAL &&
  805. (!circ->timestamp_dirty ||
  806. circ->timestamp_dirty + get_options()->MaxCircuitDirtiness > now)) {
  807. origin_circuit_t *origin_circ = TO_ORIGIN_CIRCUIT(circ);
  808. cpath_build_state_t *build_state = origin_circ->build_state;
  809. if (build_state->is_internal || build_state->onehop_tunnel)
  810. continue;
  811. if (origin_circ->unusable_for_new_conns)
  812. continue;
  813. exitnode = build_state_get_exit_node(build_state);
  814. if (exitnode && (!need_uptime || build_state->need_uptime)) {
  815. int ok;
  816. if (conn) {
  817. ok = connection_ap_can_use_exit(conn, exitnode);
  818. } else {
  819. addr_policy_result_t r;
  820. r = compare_tor_addr_to_node_policy(NULL, port, exitnode);
  821. ok = r != ADDR_POLICY_REJECTED && r != ADDR_POLICY_PROBABLY_REJECTED;
  822. }
  823. if (ok) {
  824. if (++num >= min)
  825. return 1;
  826. }
  827. }
  828. }
  829. }
  830. return 0;
  831. }
  832. /** Don't keep more than this many unused open circuits around. */
  833. #define MAX_UNUSED_OPEN_CIRCUITS 14
  834. /** Figure out how many circuits we have open that are clean. Make
  835. * sure it's enough for all the upcoming behaviors we predict we'll have.
  836. * But put an upper bound on the total number of circuits.
  837. */
  838. static void
  839. circuit_predict_and_launch_new(void)
  840. {
  841. circuit_t *circ;
  842. int num=0, num_internal=0, num_uptime_internal=0;
  843. int hidserv_needs_uptime=0, hidserv_needs_capacity=1;
  844. int port_needs_uptime=0, port_needs_capacity=1;
  845. time_t now = time(NULL);
  846. int flags = 0;
  847. /* First, count how many of each type of circuit we have already. */
  848. TOR_LIST_FOREACH(circ, circuit_get_global_list(), head) {
  849. cpath_build_state_t *build_state;
  850. origin_circuit_t *origin_circ;
  851. if (!CIRCUIT_IS_ORIGIN(circ))
  852. continue;
  853. if (circ->marked_for_close)
  854. continue; /* don't mess with marked circs */
  855. if (circ->timestamp_dirty)
  856. continue; /* only count clean circs */
  857. if (circ->purpose != CIRCUIT_PURPOSE_C_GENERAL)
  858. continue; /* only pay attention to general-purpose circs */
  859. origin_circ = TO_ORIGIN_CIRCUIT(circ);
  860. if (origin_circ->unusable_for_new_conns)
  861. continue;
  862. build_state = origin_circ->build_state;
  863. if (build_state->onehop_tunnel)
  864. continue;
  865. num++;
  866. if (build_state->is_internal)
  867. num_internal++;
  868. if (build_state->need_uptime && build_state->is_internal)
  869. num_uptime_internal++;
  870. }
  871. /* If that's enough, then stop now. */
  872. if (num >= MAX_UNUSED_OPEN_CIRCUITS)
  873. return; /* we already have many, making more probably will hurt */
  874. /* Second, see if we need any more exit circuits. */
  875. /* check if we know of a port that's been requested recently
  876. * and no circuit is currently available that can handle it. */
  877. if (!circuit_all_predicted_ports_handled(now, &port_needs_uptime,
  878. &port_needs_capacity)) {
  879. if (port_needs_uptime)
  880. flags |= CIRCLAUNCH_NEED_UPTIME;
  881. if (port_needs_capacity)
  882. flags |= CIRCLAUNCH_NEED_CAPACITY;
  883. log_info(LD_CIRC,
  884. "Have %d clean circs (%d internal), need another exit circ.",
  885. num, num_internal);
  886. circuit_launch(CIRCUIT_PURPOSE_C_GENERAL, flags);
  887. return;
  888. }
  889. /* Third, see if we need any more hidden service (server) circuits. */
  890. if (num_rend_services() && num_uptime_internal < 3) {
  891. flags = (CIRCLAUNCH_NEED_CAPACITY | CIRCLAUNCH_NEED_UPTIME |
  892. CIRCLAUNCH_IS_INTERNAL);
  893. log_info(LD_CIRC,
  894. "Have %d clean circs (%d internal), need another internal "
  895. "circ for my hidden service.",
  896. num, num_internal);
  897. circuit_launch(CIRCUIT_PURPOSE_C_GENERAL, flags);
  898. return;
  899. }
  900. /* Fourth, see if we need any more hidden service (client) circuits. */
  901. if (rep_hist_get_predicted_internal(now, &hidserv_needs_uptime,
  902. &hidserv_needs_capacity) &&
  903. ((num_uptime_internal<2 && hidserv_needs_uptime) ||
  904. num_internal<2)) {
  905. if (hidserv_needs_uptime)
  906. flags |= CIRCLAUNCH_NEED_UPTIME;
  907. if (hidserv_needs_capacity)
  908. flags |= CIRCLAUNCH_NEED_CAPACITY;
  909. flags |= CIRCLAUNCH_IS_INTERNAL;
  910. log_info(LD_CIRC,
  911. "Have %d clean circs (%d uptime-internal, %d internal), need"
  912. " another hidden service circ.",
  913. num, num_uptime_internal, num_internal);
  914. circuit_launch(CIRCUIT_PURPOSE_C_GENERAL, flags);
  915. return;
  916. }
  917. /* Finally, check to see if we still need more circuits to learn
  918. * a good build timeout. But if we're close to our max number we
  919. * want, don't do another -- we want to leave a few slots open so
  920. * we can still build circuits preemptively as needed. */
  921. if (num < MAX_UNUSED_OPEN_CIRCUITS-2 &&
  922. ! circuit_build_times_disabled() &&
  923. circuit_build_times_needs_circuits_now(get_circuit_build_times())) {
  924. flags = CIRCLAUNCH_NEED_CAPACITY;
  925. log_info(LD_CIRC,
  926. "Have %d clean circs need another buildtime test circ.", num);
  927. circuit_launch(CIRCUIT_PURPOSE_C_GENERAL, flags);
  928. return;
  929. }
  930. }
  931. /** Build a new test circuit every 5 minutes */
  932. #define TESTING_CIRCUIT_INTERVAL 300
  933. /** This function is called once a second, if router_have_min_dir_info() is
  934. * true. Its job is to make sure all services we offer have enough circuits
  935. * available. Some services just want enough circuits for current tasks,
  936. * whereas others want a minimum set of idle circuits hanging around.
  937. */
  938. void
  939. circuit_build_needed_circs(time_t now)
  940. {
  941. static time_t time_to_new_circuit = 0;
  942. const or_options_t *options = get_options();
  943. /* launch a new circ for any pending streams that need one */
  944. connection_ap_attach_pending();
  945. /* make sure any hidden services have enough intro points */
  946. rend_services_introduce();
  947. if (time_to_new_circuit < now) {
  948. circuit_reset_failure_count(1);
  949. time_to_new_circuit = now + options->NewCircuitPeriod;
  950. if (proxy_mode(get_options()))
  951. addressmap_clean(now);
  952. circuit_expire_old_circuits_clientside();
  953. #if 0 /* disable for now, until predict-and-launch-new can cull leftovers */
  954. circ = circuit_get_youngest_clean_open(CIRCUIT_PURPOSE_C_GENERAL);
  955. if (get_options()->RunTesting &&
  956. circ &&
  957. circ->timestamp_began.tv_sec + TESTING_CIRCUIT_INTERVAL < now) {
  958. log_fn(LOG_INFO,"Creating a new testing circuit.");
  959. circuit_launch(CIRCUIT_PURPOSE_C_GENERAL, 0);
  960. }
  961. #endif
  962. }
  963. if (!options->DisablePredictedCircuits)
  964. circuit_predict_and_launch_new();
  965. }
  966. /** If the stream <b>conn</b> is a member of any of the linked
  967. * lists of <b>circ</b>, then remove it from the list.
  968. */
  969. void
  970. circuit_detach_stream(circuit_t *circ, edge_connection_t *conn)
  971. {
  972. edge_connection_t *prevconn;
  973. tor_assert(circ);
  974. tor_assert(conn);
  975. if (conn->base_.type == CONN_TYPE_AP) {
  976. entry_connection_t *entry_conn = EDGE_TO_ENTRY_CONN(conn);
  977. entry_conn->may_use_optimistic_data = 0;
  978. }
  979. conn->cpath_layer = NULL; /* don't keep a stale pointer */
  980. conn->on_circuit = NULL;
  981. if (CIRCUIT_IS_ORIGIN(circ)) {
  982. origin_circuit_t *origin_circ = TO_ORIGIN_CIRCUIT(circ);
  983. if (conn == origin_circ->p_streams) {
  984. origin_circ->p_streams = conn->next_stream;
  985. return;
  986. }
  987. for (prevconn = origin_circ->p_streams;
  988. prevconn && prevconn->next_stream && prevconn->next_stream != conn;
  989. prevconn = prevconn->next_stream)
  990. ;
  991. if (prevconn && prevconn->next_stream) {
  992. prevconn->next_stream = conn->next_stream;
  993. return;
  994. }
  995. } else {
  996. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  997. if (conn == or_circ->n_streams) {
  998. or_circ->n_streams = conn->next_stream;
  999. return;
  1000. }
  1001. if (conn == or_circ->resolving_streams) {
  1002. or_circ->resolving_streams = conn->next_stream;
  1003. return;
  1004. }
  1005. for (prevconn = or_circ->n_streams;
  1006. prevconn && prevconn->next_stream && prevconn->next_stream != conn;
  1007. prevconn = prevconn->next_stream)
  1008. ;
  1009. if (prevconn && prevconn->next_stream) {
  1010. prevconn->next_stream = conn->next_stream;
  1011. return;
  1012. }
  1013. for (prevconn = or_circ->resolving_streams;
  1014. prevconn && prevconn->next_stream && prevconn->next_stream != conn;
  1015. prevconn = prevconn->next_stream)
  1016. ;
  1017. if (prevconn && prevconn->next_stream) {
  1018. prevconn->next_stream = conn->next_stream;
  1019. return;
  1020. }
  1021. }
  1022. log_warn(LD_BUG,"Edge connection not in circuit's list.");
  1023. /* Don't give an error here; it's harmless. */
  1024. tor_fragile_assert();
  1025. }
  1026. /** If we haven't yet decided on a good timeout value for circuit
  1027. * building, we close idles circuits aggressively so we can get more
  1028. * data points. */
  1029. #define IDLE_TIMEOUT_WHILE_LEARNING (10*60)
  1030. /** Find each circuit that has been unused for too long, or dirty
  1031. * for too long and has no streams on it: mark it for close.
  1032. */
  1033. static void
  1034. circuit_expire_old_circuits_clientside(void)
  1035. {
  1036. circuit_t *circ;
  1037. struct timeval cutoff, now;
  1038. tor_gettimeofday(&now);
  1039. cutoff = now;
  1040. if (! circuit_build_times_disabled() &&
  1041. circuit_build_times_needs_circuits(get_circuit_build_times())) {
  1042. /* Circuits should be shorter lived if we need more of them
  1043. * for learning a good build timeout */
  1044. cutoff.tv_sec -= IDLE_TIMEOUT_WHILE_LEARNING;
  1045. } else {
  1046. cutoff.tv_sec -= get_options()->CircuitIdleTimeout;
  1047. }
  1048. TOR_LIST_FOREACH(circ, circuit_get_global_list(), head) {
  1049. if (circ->marked_for_close || !CIRCUIT_IS_ORIGIN(circ))
  1050. continue;
  1051. /* If the circuit has been dirty for too long, and there are no streams
  1052. * on it, mark it for close.
  1053. */
  1054. if (circ->timestamp_dirty &&
  1055. circ->timestamp_dirty + get_options()->MaxCircuitDirtiness <
  1056. now.tv_sec &&
  1057. !TO_ORIGIN_CIRCUIT(circ)->p_streams /* nothing attached */ ) {
  1058. log_debug(LD_CIRC, "Closing n_circ_id %u (dirty %ld sec ago, "
  1059. "purpose %d)",
  1060. (unsigned)circ->n_circ_id,
  1061. (long)(now.tv_sec - circ->timestamp_dirty),
  1062. circ->purpose);
  1063. /* Don't do this magic for testing circuits. Their death is governed
  1064. * by circuit_expire_building */
  1065. if (circ->purpose != CIRCUIT_PURPOSE_PATH_BIAS_TESTING)
  1066. circuit_mark_for_close(circ, END_CIRC_REASON_FINISHED);
  1067. } else if (!circ->timestamp_dirty && circ->state == CIRCUIT_STATE_OPEN) {
  1068. if (timercmp(&circ->timestamp_began, &cutoff, <)) {
  1069. if (circ->purpose == CIRCUIT_PURPOSE_C_GENERAL ||
  1070. circ->purpose == CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT ||
  1071. circ->purpose == CIRCUIT_PURPOSE_S_ESTABLISH_INTRO ||
  1072. circ->purpose == CIRCUIT_PURPOSE_TESTING ||
  1073. (circ->purpose >= CIRCUIT_PURPOSE_C_INTRODUCING &&
  1074. circ->purpose <= CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED) ||
  1075. circ->purpose == CIRCUIT_PURPOSE_S_CONNECT_REND) {
  1076. log_debug(LD_CIRC,
  1077. "Closing circuit that has been unused for %ld msec.",
  1078. tv_mdiff(&circ->timestamp_began, &now));
  1079. circuit_mark_for_close(circ, END_CIRC_REASON_FINISHED);
  1080. } else if (!TO_ORIGIN_CIRCUIT(circ)->is_ancient) {
  1081. /* Server-side rend joined circuits can end up really old, because
  1082. * they are reused by clients for longer than normal. The client
  1083. * controls their lifespan. (They never become dirty, because
  1084. * connection_exit_begin_conn() never marks anything as dirty.)
  1085. * Similarly, server-side intro circuits last a long time. */
  1086. if (circ->purpose != CIRCUIT_PURPOSE_S_REND_JOINED &&
  1087. circ->purpose != CIRCUIT_PURPOSE_S_INTRO) {
  1088. log_notice(LD_CIRC,
  1089. "Ancient non-dirty circuit %d is still around after "
  1090. "%ld milliseconds. Purpose: %d (%s)",
  1091. TO_ORIGIN_CIRCUIT(circ)->global_identifier,
  1092. tv_mdiff(&circ->timestamp_began, &now),
  1093. circ->purpose,
  1094. circuit_purpose_to_string(circ->purpose));
  1095. TO_ORIGIN_CIRCUIT(circ)->is_ancient = 1;
  1096. }
  1097. }
  1098. }
  1099. }
  1100. }
  1101. }
  1102. /** How long do we wait before killing circuits with the properties
  1103. * described below?
  1104. *
  1105. * Probably we could choose a number here as low as 5 to 10 seconds,
  1106. * since these circs are used for begindir, and a) generally you either
  1107. * ask another begindir question right after or you don't for a long time,
  1108. * b) clients at least through 0.2.1.x choose from the whole set of
  1109. * directory mirrors at each choice, and c) re-establishing a one-hop
  1110. * circuit via create-fast is a light operation assuming the TLS conn is
  1111. * still there.
  1112. *
  1113. * I expect "b" to go away one day when we move to using directory
  1114. * guards, but I think "a" and "c" are good enough reasons that a low
  1115. * number is safe even then.
  1116. */
  1117. #define IDLE_ONE_HOP_CIRC_TIMEOUT 60
  1118. /** Find each non-origin circuit that has been unused for too long,
  1119. * has no streams on it, used a create_fast, and ends here: mark it
  1120. * for close.
  1121. */
  1122. void
  1123. circuit_expire_old_circuits_serverside(time_t now)
  1124. {
  1125. circuit_t *circ;
  1126. or_circuit_t *or_circ;
  1127. time_t cutoff = now - IDLE_ONE_HOP_CIRC_TIMEOUT;
  1128. TOR_LIST_FOREACH(circ, circuit_get_global_list(), head) {
  1129. if (circ->marked_for_close || CIRCUIT_IS_ORIGIN(circ))
  1130. continue;
  1131. or_circ = TO_OR_CIRCUIT(circ);
  1132. /* If the circuit has been idle for too long, and there are no streams
  1133. * on it, and it ends here, and it used a create_fast, mark it for close.
  1134. */
  1135. if (or_circ->is_first_hop && !circ->n_chan &&
  1136. !or_circ->n_streams && !or_circ->resolving_streams &&
  1137. or_circ->p_chan &&
  1138. channel_when_last_xmit(or_circ->p_chan) <= cutoff) {
  1139. log_info(LD_CIRC, "Closing circ_id %u (empty %d secs ago)",
  1140. (unsigned)or_circ->p_circ_id,
  1141. (int)(now - channel_when_last_xmit(or_circ->p_chan)));
  1142. circuit_mark_for_close(circ, END_CIRC_REASON_FINISHED);
  1143. }
  1144. }
  1145. }
  1146. /** Number of testing circuits we want open before testing our bandwidth. */
  1147. #define NUM_PARALLEL_TESTING_CIRCS 4
  1148. /** True iff we've ever had enough testing circuits open to test our
  1149. * bandwidth. */
  1150. static int have_performed_bandwidth_test = 0;
  1151. /** Reset have_performed_bandwidth_test, so we'll start building
  1152. * testing circuits again so we can exercise our bandwidth. */
  1153. void
  1154. reset_bandwidth_test(void)
  1155. {
  1156. have_performed_bandwidth_test = 0;
  1157. }
  1158. /** Return 1 if we've already exercised our bandwidth, or if we
  1159. * have fewer than NUM_PARALLEL_TESTING_CIRCS testing circuits
  1160. * established or on the way. Else return 0.
  1161. */
  1162. int
  1163. circuit_enough_testing_circs(void)
  1164. {
  1165. circuit_t *circ;
  1166. int num = 0;
  1167. if (have_performed_bandwidth_test)
  1168. return 1;
  1169. TOR_LIST_FOREACH(circ, circuit_get_global_list(), head) {
  1170. if (!circ->marked_for_close && CIRCUIT_IS_ORIGIN(circ) &&
  1171. circ->purpose == CIRCUIT_PURPOSE_TESTING &&
  1172. circ->state == CIRCUIT_STATE_OPEN)
  1173. num++;
  1174. }
  1175. return num >= NUM_PARALLEL_TESTING_CIRCS;
  1176. }
  1177. /** A testing circuit has completed. Take whatever stats we want.
  1178. * Noticing reachability is taken care of in onionskin_answer(),
  1179. * so there's no need to record anything here. But if we still want
  1180. * to do the bandwidth test, and we now have enough testing circuits
  1181. * open, do it.
  1182. */
  1183. static void
  1184. circuit_testing_opened(origin_circuit_t *circ)
  1185. {
  1186. if (have_performed_bandwidth_test ||
  1187. !check_whether_orport_reachable()) {
  1188. /* either we've already done everything we want with testing circuits,
  1189. * or this testing circuit became open due to a fluke, e.g. we picked
  1190. * a last hop where we already had the connection open due to an
  1191. * outgoing local circuit. */
  1192. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_AT_ORIGIN);
  1193. } else if (circuit_enough_testing_circs()) {
  1194. router_perform_bandwidth_test(NUM_PARALLEL_TESTING_CIRCS, time(NULL));
  1195. have_performed_bandwidth_test = 1;
  1196. } else
  1197. consider_testing_reachability(1, 0);
  1198. }
  1199. /** A testing circuit has failed to build. Take whatever stats we want. */
  1200. static void
  1201. circuit_testing_failed(origin_circuit_t *circ, int at_last_hop)
  1202. {
  1203. if (server_mode(get_options()) && check_whether_orport_reachable())
  1204. return;
  1205. log_info(LD_GENERAL,
  1206. "Our testing circuit (to see if your ORPort is reachable) "
  1207. "has failed. I'll try again later.");
  1208. /* These aren't used yet. */
  1209. (void)circ;
  1210. (void)at_last_hop;
  1211. }
  1212. /** The circuit <b>circ</b> has just become open. Take the next
  1213. * step: for rendezvous circuits, we pass circ to the appropriate
  1214. * function in rendclient or rendservice. For general circuits, we
  1215. * call connection_ap_attach_pending, which looks for pending streams
  1216. * that could use circ.
  1217. */
  1218. void
  1219. circuit_has_opened(origin_circuit_t *circ)
  1220. {
  1221. control_event_circuit_status(circ, CIRC_EVENT_BUILT, 0);
  1222. /* Remember that this circuit has finished building. Now if we start
  1223. * it building again later (e.g. by extending it), we will know not
  1224. * to consider its build time. */
  1225. circ->has_opened = 1;
  1226. switch (TO_CIRCUIT(circ)->purpose) {
  1227. case CIRCUIT_PURPOSE_C_ESTABLISH_REND:
  1228. rend_client_rendcirc_has_opened(circ);
  1229. /* Start building an intro circ if we don't have one yet. */
  1230. connection_ap_attach_pending();
  1231. /* This isn't a call to circuit_try_attaching_streams because a
  1232. * circuit in _C_ESTABLISH_REND state isn't connected to its
  1233. * hidden service yet, thus we can't attach streams to it yet,
  1234. * thus circuit_try_attaching_streams would always clear the
  1235. * circuit's isolation state. circuit_try_attaching_streams is
  1236. * called later, when the rend circ enters _C_REND_JOINED
  1237. * state. */
  1238. break;
  1239. case CIRCUIT_PURPOSE_C_INTRODUCING:
  1240. rend_client_introcirc_has_opened(circ);
  1241. break;
  1242. case CIRCUIT_PURPOSE_C_GENERAL:
  1243. /* Tell any AP connections that have been waiting for a new
  1244. * circuit that one is ready. */
  1245. circuit_try_attaching_streams(circ);
  1246. break;
  1247. case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO:
  1248. /* at Bob, waiting for introductions */
  1249. rend_service_intro_has_opened(circ);
  1250. break;
  1251. case CIRCUIT_PURPOSE_S_CONNECT_REND:
  1252. /* at Bob, connecting to rend point */
  1253. rend_service_rendezvous_has_opened(circ);
  1254. break;
  1255. case CIRCUIT_PURPOSE_TESTING:
  1256. circuit_testing_opened(circ);
  1257. break;
  1258. /* default:
  1259. * This won't happen in normal operation, but might happen if the
  1260. * controller did it. Just let it slide. */
  1261. }
  1262. }
  1263. /** If the stream-isolation state of <b>circ</b> can be cleared, clear
  1264. * it. Return non-zero iff <b>circ</b>'s isolation state was cleared. */
  1265. static int
  1266. circuit_try_clearing_isolation_state(origin_circuit_t *circ)
  1267. {
  1268. if (/* The circuit may have become non-open if it was cannibalized.*/
  1269. circ->base_.state == CIRCUIT_STATE_OPEN &&
  1270. /* If !isolation_values_set, there is nothing to clear. */
  1271. circ->isolation_values_set &&
  1272. /* It's not legal to clear a circuit's isolation info if it's ever had
  1273. * streams attached */
  1274. !circ->isolation_any_streams_attached) {
  1275. /* If we have any isolation information set on this circuit, and
  1276. * we didn't manage to attach any streams to it, then we can
  1277. * and should clear it and try again. */
  1278. circuit_clear_isolation(circ);
  1279. return 1;
  1280. } else {
  1281. return 0;
  1282. }
  1283. }
  1284. /** Called when a circuit becomes ready for streams to be attached to
  1285. * it. */
  1286. void
  1287. circuit_try_attaching_streams(origin_circuit_t *circ)
  1288. {
  1289. /* Attach streams to this circuit if we can. */
  1290. connection_ap_attach_pending();
  1291. /* The call to circuit_try_clearing_isolation_state here will do
  1292. * nothing and return 0 if we didn't attach any streams to circ
  1293. * above. */
  1294. if (circuit_try_clearing_isolation_state(circ)) {
  1295. /* Maybe *now* we can attach some streams to this circuit. */
  1296. connection_ap_attach_pending();
  1297. }
  1298. }
  1299. /** Called whenever a circuit could not be successfully built.
  1300. */
  1301. void
  1302. circuit_build_failed(origin_circuit_t *circ)
  1303. {
  1304. channel_t *n_chan = NULL;
  1305. /* we should examine circ and see if it failed because of
  1306. * the last hop or an earlier hop. then use this info below.
  1307. */
  1308. int failed_at_last_hop = 0;
  1309. /* If the last hop isn't open, and the second-to-last is, we failed
  1310. * at the last hop. */
  1311. if (circ->cpath &&
  1312. circ->cpath->prev->state != CPATH_STATE_OPEN &&
  1313. circ->cpath->prev->prev->state == CPATH_STATE_OPEN) {
  1314. failed_at_last_hop = 1;
  1315. }
  1316. if (circ->cpath &&
  1317. circ->cpath->state != CPATH_STATE_OPEN &&
  1318. ! circ->base_.received_destroy) {
  1319. /* We failed at the first hop for some reason other than a DESTROY cell.
  1320. * If there's an OR connection to blame, blame it. Also, avoid this relay
  1321. * for a while, and fail any one-hop directory fetches destined for it. */
  1322. const char *n_chan_id = circ->cpath->extend_info->identity_digest;
  1323. int already_marked = 0;
  1324. if (circ->base_.n_chan) {
  1325. n_chan = circ->base_.n_chan;
  1326. if (n_chan->is_bad_for_new_circs) {
  1327. /* We only want to blame this router when a fresh healthy
  1328. * connection fails. So don't mark this router as newly failed,
  1329. * since maybe this was just an old circuit attempt that's
  1330. * finally timing out now. Also, there's no need to blow away
  1331. * circuits/streams/etc, since the failure of an unhealthy conn
  1332. * doesn't tell us much about whether a healthy conn would
  1333. * succeed. */
  1334. already_marked = 1;
  1335. }
  1336. log_info(LD_OR,
  1337. "Our circuit failed to get a response from the first hop "
  1338. "(%s). I'm going to try to rotate to a better connection.",
  1339. channel_get_canonical_remote_descr(n_chan));
  1340. n_chan->is_bad_for_new_circs = 1;
  1341. } else {
  1342. log_info(LD_OR,
  1343. "Our circuit died before the first hop with no connection");
  1344. }
  1345. if (n_chan_id && !already_marked) {
  1346. entry_guard_register_connect_status(n_chan_id, 0, 1, time(NULL));
  1347. /* if there are any one-hop streams waiting on this circuit, fail
  1348. * them now so they can retry elsewhere. */
  1349. connection_ap_fail_onehop(n_chan_id, circ->build_state);
  1350. }
  1351. }
  1352. switch (circ->base_.purpose) {
  1353. case CIRCUIT_PURPOSE_C_GENERAL:
  1354. /* If we never built the circuit, note it as a failure. */
  1355. circuit_increment_failure_count();
  1356. if (failed_at_last_hop) {
  1357. /* Make sure any streams that demand our last hop as their exit
  1358. * know that it's unlikely to happen. */
  1359. circuit_discard_optional_exit_enclaves(circ->cpath->prev->extend_info);
  1360. }
  1361. break;
  1362. case CIRCUIT_PURPOSE_TESTING:
  1363. circuit_testing_failed(circ, failed_at_last_hop);
  1364. break;
  1365. case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO:
  1366. /* at Bob, waiting for introductions */
  1367. if (circ->base_.state != CIRCUIT_STATE_OPEN) {
  1368. circuit_increment_failure_count();
  1369. }
  1370. /* no need to care here, because bob will rebuild intro
  1371. * points periodically. */
  1372. break;
  1373. case CIRCUIT_PURPOSE_C_INTRODUCING:
  1374. /* at Alice, connecting to intro point */
  1375. /* Don't increment failure count, since Bob may have picked
  1376. * the introduction point maliciously */
  1377. /* Alice will pick a new intro point when this one dies, if
  1378. * the stream in question still cares. No need to act here. */
  1379. break;
  1380. case CIRCUIT_PURPOSE_C_ESTABLISH_REND:
  1381. /* at Alice, waiting for Bob */
  1382. circuit_increment_failure_count();
  1383. /* Alice will pick a new rend point when this one dies, if
  1384. * the stream in question still cares. No need to act here. */
  1385. break;
  1386. case CIRCUIT_PURPOSE_S_CONNECT_REND:
  1387. /* at Bob, connecting to rend point */
  1388. /* Don't increment failure count, since Alice may have picked
  1389. * the rendezvous point maliciously */
  1390. log_info(LD_REND,
  1391. "Couldn't connect to Alice's chosen rend point %s "
  1392. "(%s hop failed).",
  1393. escaped(build_state_get_exit_nickname(circ->build_state)),
  1394. failed_at_last_hop?"last":"non-last");
  1395. rend_service_relaunch_rendezvous(circ);
  1396. break;
  1397. /* default:
  1398. * This won't happen in normal operation, but might happen if the
  1399. * controller did it. Just let it slide. */
  1400. }
  1401. }
  1402. /** Number of consecutive failures so far; should only be touched by
  1403. * circuit_launch_new and circuit_*_failure_count.
  1404. */
  1405. static int n_circuit_failures = 0;
  1406. /** Before the last time we called circuit_reset_failure_count(), were
  1407. * there a lot of failures? */
  1408. static int did_circs_fail_last_period = 0;
  1409. /** Don't retry launching a new circuit if we try this many times with no
  1410. * success. */
  1411. #define MAX_CIRCUIT_FAILURES 5
  1412. /** Launch a new circuit; see circuit_launch_by_extend_info() for
  1413. * details on arguments. */
  1414. origin_circuit_t *
  1415. circuit_launch(uint8_t purpose, int flags)
  1416. {
  1417. return circuit_launch_by_extend_info(purpose, NULL, flags);
  1418. }
  1419. /** Launch a new circuit with purpose <b>purpose</b> and exit node
  1420. * <b>extend_info</b> (or NULL to select a random exit node). If flags
  1421. * contains CIRCLAUNCH_NEED_UPTIME, choose among routers with high uptime. If
  1422. * CIRCLAUNCH_NEED_CAPACITY is set, choose among routers with high bandwidth.
  1423. * If CIRCLAUNCH_IS_INTERNAL is true, the last hop need not be an exit node.
  1424. * If CIRCLAUNCH_ONEHOP_TUNNEL is set, the circuit will have only one hop.
  1425. * Return the newly allocated circuit on success, or NULL on failure. */
  1426. origin_circuit_t *
  1427. circuit_launch_by_extend_info(uint8_t purpose,
  1428. extend_info_t *extend_info,
  1429. int flags)
  1430. {
  1431. origin_circuit_t *circ;
  1432. int onehop_tunnel = (flags & CIRCLAUNCH_ONEHOP_TUNNEL) != 0;
  1433. if (!onehop_tunnel && !router_have_minimum_dir_info()) {
  1434. log_debug(LD_CIRC,"Haven't fetched enough directory info yet; canceling "
  1435. "circuit launch.");
  1436. return NULL;
  1437. }
  1438. if ((extend_info || purpose != CIRCUIT_PURPOSE_C_GENERAL) &&
  1439. purpose != CIRCUIT_PURPOSE_TESTING && !onehop_tunnel) {
  1440. /* see if there are appropriate circs available to cannibalize. */
  1441. /* XXX if we're planning to add a hop, perhaps we want to look for
  1442. * internal circs rather than exit circs? -RD */
  1443. circ = circuit_find_to_cannibalize(purpose, extend_info, flags);
  1444. if (circ) {
  1445. uint8_t old_purpose = circ->base_.purpose;
  1446. struct timeval old_timestamp_began = circ->base_.timestamp_began;
  1447. log_info(LD_CIRC,"Cannibalizing circ '%s' for purpose %d (%s)",
  1448. build_state_get_exit_nickname(circ->build_state), purpose,
  1449. circuit_purpose_to_string(purpose));
  1450. if ((purpose == CIRCUIT_PURPOSE_S_CONNECT_REND ||
  1451. purpose == CIRCUIT_PURPOSE_C_INTRODUCING) &&
  1452. circ->path_state == PATH_STATE_BUILD_SUCCEEDED) {
  1453. /* Path bias: Cannibalized rends pre-emptively count as a
  1454. * successfully built but unused closed circuit. We don't
  1455. * wait until the extend (or the close) because the rend
  1456. * point could be malicious.
  1457. *
  1458. * Same deal goes for client side introductions. Clients
  1459. * can be manipulated to connect repeatedly to them
  1460. * (especially web clients).
  1461. *
  1462. * If we decide to probe the initial portion of these circs,
  1463. * (up to the adversary's final hop), we need to remove this,
  1464. * or somehow mark the circuit with a special path state.
  1465. */
  1466. /* This must be called before the purpose change */
  1467. pathbias_check_close(circ, END_CIRC_REASON_FINISHED);
  1468. }
  1469. circuit_change_purpose(TO_CIRCUIT(circ), purpose);
  1470. /* Reset the start date of this circ, else expire_building
  1471. * will see it and think it's been trying to build since it
  1472. * began.
  1473. *
  1474. * Technically, the code should reset this when the
  1475. * create cell is finally sent, but we're close enough
  1476. * here. */
  1477. tor_gettimeofday(&circ->base_.timestamp_began);
  1478. control_event_circuit_cannibalized(circ, old_purpose,
  1479. &old_timestamp_began);
  1480. switch (purpose) {
  1481. case CIRCUIT_PURPOSE_C_ESTABLISH_REND:
  1482. case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO:
  1483. /* it's ready right now */
  1484. break;
  1485. case CIRCUIT_PURPOSE_C_INTRODUCING:
  1486. case CIRCUIT_PURPOSE_S_CONNECT_REND:
  1487. case CIRCUIT_PURPOSE_C_GENERAL:
  1488. /* need to add a new hop */
  1489. tor_assert(extend_info);
  1490. if (circuit_extend_to_new_exit(circ, extend_info) < 0)
  1491. return NULL;
  1492. break;
  1493. default:
  1494. log_warn(LD_BUG,
  1495. "unexpected purpose %d when cannibalizing a circ.",
  1496. purpose);
  1497. tor_fragile_assert();
  1498. return NULL;
  1499. }
  1500. return circ;
  1501. }
  1502. }
  1503. if (did_circs_fail_last_period &&
  1504. n_circuit_failures > MAX_CIRCUIT_FAILURES) {
  1505. /* too many failed circs in a row. don't try. */
  1506. // log_fn(LOG_INFO,"%d failures so far, not trying.",n_circuit_failures);
  1507. return NULL;
  1508. }
  1509. /* try a circ. if it fails, circuit_mark_for_close will increment
  1510. * n_circuit_failures */
  1511. return circuit_establish_circuit(purpose, extend_info, flags);
  1512. }
  1513. /** Record another failure at opening a general circuit. When we have
  1514. * too many, we'll stop trying for the remainder of this minute.
  1515. */
  1516. static void
  1517. circuit_increment_failure_count(void)
  1518. {
  1519. ++n_circuit_failures;
  1520. log_debug(LD_CIRC,"n_circuit_failures now %d.",n_circuit_failures);
  1521. }
  1522. /** Reset the failure count for opening general circuits. This means
  1523. * we will try MAX_CIRCUIT_FAILURES times more (if necessary) before
  1524. * stopping again.
  1525. */
  1526. void
  1527. circuit_reset_failure_count(int timeout)
  1528. {
  1529. if (timeout && n_circuit_failures > MAX_CIRCUIT_FAILURES)
  1530. did_circs_fail_last_period = 1;
  1531. else
  1532. did_circs_fail_last_period = 0;
  1533. n_circuit_failures = 0;
  1534. }
  1535. /** Find an open circ that we're happy to use for <b>conn</b> and return 1. If
  1536. * there isn't one, and there isn't one on the way, launch one and return
  1537. * 0. If it will never work, return -1.
  1538. *
  1539. * Write the found or in-progress or launched circ into *circp.
  1540. */
  1541. static int
  1542. circuit_get_open_circ_or_launch(entry_connection_t *conn,
  1543. uint8_t desired_circuit_purpose,
  1544. origin_circuit_t **circp)
  1545. {
  1546. origin_circuit_t *circ;
  1547. int check_exit_policy;
  1548. int need_uptime, need_internal;
  1549. int want_onehop;
  1550. const or_options_t *options = get_options();
  1551. tor_assert(conn);
  1552. tor_assert(circp);
  1553. tor_assert(ENTRY_TO_CONN(conn)->state == AP_CONN_STATE_CIRCUIT_WAIT);
  1554. check_exit_policy =
  1555. conn->socks_request->command == SOCKS_COMMAND_CONNECT &&
  1556. !conn->use_begindir &&
  1557. !connection_edge_is_rendezvous_stream(ENTRY_TO_EDGE_CONN(conn));
  1558. want_onehop = conn->want_onehop;
  1559. need_uptime = !conn->want_onehop && !conn->use_begindir &&
  1560. smartlist_contains_int_as_string(options->LongLivedPorts,
  1561. conn->socks_request->port);
  1562. if (desired_circuit_purpose != CIRCUIT_PURPOSE_C_GENERAL)
  1563. need_internal = 1;
  1564. else if (conn->use_begindir || conn->want_onehop)
  1565. need_internal = 1;
  1566. else
  1567. need_internal = 0;
  1568. circ = circuit_get_best(conn, 1, desired_circuit_purpose,
  1569. need_uptime, need_internal);
  1570. if (circ) {
  1571. *circp = circ;
  1572. return 1; /* we're happy */
  1573. }
  1574. if (!want_onehop && !router_have_minimum_dir_info()) {
  1575. if (!connection_get_by_type(CONN_TYPE_DIR)) {
  1576. int severity = LOG_NOTICE;
  1577. /* FFFF if this is a tunneled directory fetch, don't yell
  1578. * as loudly. the user doesn't even know it's happening. */
  1579. if (entry_list_is_constrained(options) &&
  1580. entries_known_but_down(options)) {
  1581. log_fn(severity, LD_APP|LD_DIR,
  1582. "Application request when we haven't used client functionality "
  1583. "lately. Optimistically trying known %s again.",
  1584. options->UseBridges ? "bridges" : "entrynodes");
  1585. entries_retry_all(options);
  1586. } else if (!options->UseBridges || any_bridge_descriptors_known()) {
  1587. log_fn(severity, LD_APP|LD_DIR,
  1588. "Application request when we haven't used client functionality "
  1589. "lately. Optimistically trying directory fetches again.");
  1590. routerlist_retry_directory_downloads(time(NULL));
  1591. }
  1592. }
  1593. /* the stream will be dealt with when router_have_minimum_dir_info becomes
  1594. * 1, or when all directory attempts fail and directory_all_unreachable()
  1595. * kills it.
  1596. */
  1597. return 0;
  1598. }
  1599. /* Do we need to check exit policy? */
  1600. if (check_exit_policy) {
  1601. if (!conn->chosen_exit_name) {
  1602. struct in_addr in;
  1603. tor_addr_t addr, *addrp=NULL;
  1604. if (tor_inet_aton(conn->socks_request->address, &in)) {
  1605. tor_addr_from_in(&addr, &in);
  1606. addrp = &addr;
  1607. }
  1608. if (router_exit_policy_all_nodes_reject(addrp,
  1609. conn->socks_request->port,
  1610. need_uptime)) {
  1611. log_notice(LD_APP,
  1612. "No Tor server allows exit to %s:%d. Rejecting.",
  1613. safe_str_client(conn->socks_request->address),
  1614. conn->socks_request->port);
  1615. return -1;
  1616. }
  1617. } else {
  1618. /* XXXX024 Duplicates checks in connection_ap_handshake_attach_circuit:
  1619. * refactor into a single function? */
  1620. const node_t *node = node_get_by_nickname(conn->chosen_exit_name, 1);
  1621. int opt = conn->chosen_exit_optional;
  1622. if (node && !connection_ap_can_use_exit(conn, node)) {
  1623. log_fn(opt ? LOG_INFO : LOG_WARN, LD_APP,
  1624. "Requested exit point '%s' is excluded or "
  1625. "would refuse request. %s.",
  1626. conn->chosen_exit_name, opt ? "Trying others" : "Closing");
  1627. if (opt) {
  1628. conn->chosen_exit_optional = 0;
  1629. tor_free(conn->chosen_exit_name);
  1630. /* Try again. */
  1631. return circuit_get_open_circ_or_launch(conn,
  1632. desired_circuit_purpose,
  1633. circp);
  1634. }
  1635. return -1;
  1636. }
  1637. }
  1638. }
  1639. /* is one already on the way? */
  1640. circ = circuit_get_best(conn, 0, desired_circuit_purpose,
  1641. need_uptime, need_internal);
  1642. if (circ)
  1643. log_debug(LD_CIRC, "one on the way!");
  1644. if (!circ) {
  1645. extend_info_t *extend_info=NULL;
  1646. uint8_t new_circ_purpose;
  1647. const int n_pending = count_pending_general_client_circuits();
  1648. if (n_pending >= options->MaxClientCircuitsPending) {
  1649. static ratelim_t delay_limit = RATELIM_INIT(10*60);
  1650. char *m;
  1651. if ((m = rate_limit_log(&delay_limit, approx_time()))) {
  1652. log_notice(LD_APP, "We'd like to launch a circuit to handle a "
  1653. "connection, but we already have %d general-purpose client "
  1654. "circuits pending. Waiting until some finish.%s",
  1655. n_pending, m);
  1656. tor_free(m);
  1657. }
  1658. return 0;
  1659. }
  1660. if (desired_circuit_purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT) {
  1661. /* need to pick an intro point */
  1662. rend_data_t *rend_data = ENTRY_TO_EDGE_CONN(conn)->rend_data;
  1663. tor_assert(rend_data);
  1664. extend_info = rend_client_get_random_intro(rend_data);
  1665. if (!extend_info) {
  1666. log_info(LD_REND,
  1667. "No intro points for '%s': re-fetching service descriptor.",
  1668. safe_str_client(rend_data->onion_address));
  1669. rend_client_refetch_v2_renddesc(rend_data);
  1670. ENTRY_TO_CONN(conn)->state = AP_CONN_STATE_RENDDESC_WAIT;
  1671. return 0;
  1672. }
  1673. log_info(LD_REND,"Chose %s as intro point for '%s'.",
  1674. extend_info_describe(extend_info),
  1675. safe_str_client(rend_data->onion_address));
  1676. }
  1677. /* If we have specified a particular exit node for our
  1678. * connection, then be sure to open a circuit to that exit node.
  1679. */
  1680. if (desired_circuit_purpose == CIRCUIT_PURPOSE_C_GENERAL) {
  1681. if (conn->chosen_exit_name) {
  1682. const node_t *r;
  1683. int opt = conn->chosen_exit_optional;
  1684. r = node_get_by_nickname(conn->chosen_exit_name, 1);
  1685. if (r && node_has_descriptor(r)) {
  1686. /* We might want to connect to an IPv6 bridge for loading
  1687. descriptors so we use the preferred address rather than
  1688. the primary. */
  1689. extend_info = extend_info_from_node(r, conn->want_onehop ? 1 : 0);
  1690. } else {
  1691. log_debug(LD_DIR, "considering %d, %s",
  1692. want_onehop, conn->chosen_exit_name);
  1693. if (want_onehop && conn->chosen_exit_name[0] == '$') {
  1694. /* We're asking for a one-hop circuit to a router that
  1695. * we don't have a routerinfo about. Make up an extend_info. */
  1696. char digest[DIGEST_LEN];
  1697. char *hexdigest = conn->chosen_exit_name+1;
  1698. tor_addr_t addr;
  1699. if (strlen(hexdigest) < HEX_DIGEST_LEN ||
  1700. base16_decode(digest,DIGEST_LEN,hexdigest,HEX_DIGEST_LEN)<0) {
  1701. log_info(LD_DIR, "Broken exit digest on tunnel conn. Closing.");
  1702. return -1;
  1703. }
  1704. if (tor_addr_parse(&addr, conn->socks_request->address) < 0) {
  1705. log_info(LD_DIR, "Broken address %s on tunnel conn. Closing.",
  1706. escaped_safe_str_client(conn->socks_request->address));
  1707. return -1;
  1708. }
  1709. extend_info = extend_info_new(conn->chosen_exit_name+1,
  1710. digest, NULL, NULL, &addr,
  1711. conn->socks_request->port);
  1712. } else {
  1713. /* We will need an onion key for the router, and we
  1714. * don't have one. Refuse or relax requirements. */
  1715. log_fn(opt ? LOG_INFO : LOG_WARN, LD_APP,
  1716. "Requested exit point '%s' is not known. %s.",
  1717. conn->chosen_exit_name, opt ? "Trying others" : "Closing");
  1718. if (opt) {
  1719. conn->chosen_exit_optional = 0;
  1720. tor_free(conn->chosen_exit_name);
  1721. /* Try again with no requested exit */
  1722. return circuit_get_open_circ_or_launch(conn,
  1723. desired_circuit_purpose,
  1724. circp);
  1725. }
  1726. return -1;
  1727. }
  1728. }
  1729. }
  1730. }
  1731. if (desired_circuit_purpose == CIRCUIT_PURPOSE_C_REND_JOINED)
  1732. new_circ_purpose = CIRCUIT_PURPOSE_C_ESTABLISH_REND;
  1733. else if (desired_circuit_purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT)
  1734. new_circ_purpose = CIRCUIT_PURPOSE_C_INTRODUCING;
  1735. else
  1736. new_circ_purpose = desired_circuit_purpose;
  1737. if (options->Tor2webMode &&
  1738. (new_circ_purpose == CIRCUIT_PURPOSE_C_ESTABLISH_REND ||
  1739. new_circ_purpose == CIRCUIT_PURPOSE_C_INTRODUCING)) {
  1740. want_onehop = 1;
  1741. }
  1742. {
  1743. int flags = CIRCLAUNCH_NEED_CAPACITY;
  1744. if (want_onehop) flags |= CIRCLAUNCH_ONEHOP_TUNNEL;
  1745. if (need_uptime) flags |= CIRCLAUNCH_NEED_UPTIME;
  1746. if (need_internal) flags |= CIRCLAUNCH_IS_INTERNAL;
  1747. circ = circuit_launch_by_extend_info(new_circ_purpose, extend_info,
  1748. flags);
  1749. }
  1750. extend_info_free(extend_info);
  1751. if (desired_circuit_purpose == CIRCUIT_PURPOSE_C_GENERAL) {
  1752. /* We just caused a circuit to get built because of this stream.
  1753. * If this stream has caused a _lot_ of circuits to be built, that's
  1754. * a bad sign: we should tell the user. */
  1755. if (conn->num_circuits_launched < NUM_CIRCUITS_LAUNCHED_THRESHOLD &&
  1756. ++conn->num_circuits_launched == NUM_CIRCUITS_LAUNCHED_THRESHOLD)
  1757. log_info(LD_CIRC, "The application request to %s:%d has launched "
  1758. "%d circuits without finding one it likes.",
  1759. escaped_safe_str_client(conn->socks_request->address),
  1760. conn->socks_request->port,
  1761. conn->num_circuits_launched);
  1762. } else {
  1763. /* help predict this next time */
  1764. rep_hist_note_used_internal(time(NULL), need_uptime, 1);
  1765. if (circ) {
  1766. /* write the service_id into circ */
  1767. circ->rend_data = rend_data_dup(ENTRY_TO_EDGE_CONN(conn)->rend_data);
  1768. if (circ->base_.purpose == CIRCUIT_PURPOSE_C_ESTABLISH_REND &&
  1769. circ->base_.state == CIRCUIT_STATE_OPEN)
  1770. rend_client_rendcirc_has_opened(circ);
  1771. }
  1772. }
  1773. } /* endif (!circ) */
  1774. if (circ) {
  1775. /* Mark the circuit with the isolation fields for this connection.
  1776. * When the circuit arrives, we'll clear these flags: this is
  1777. * just some internal bookkeeping to make sure that we have
  1778. * launched enough circuits.
  1779. */
  1780. connection_edge_update_circuit_isolation(conn, circ, 0);
  1781. } else {
  1782. log_info(LD_APP,
  1783. "No safe circuit (purpose %d) ready for edge "
  1784. "connection; delaying.",
  1785. desired_circuit_purpose);
  1786. }
  1787. *circp = circ;
  1788. return 0;
  1789. }
  1790. /** Return true iff <b>crypt_path</b> is one of the crypt_paths for
  1791. * <b>circ</b>. */
  1792. static int
  1793. cpath_is_on_circuit(origin_circuit_t *circ, crypt_path_t *crypt_path)
  1794. {
  1795. crypt_path_t *cpath, *cpath_next = NULL;
  1796. for (cpath = circ->cpath; cpath_next != circ->cpath; cpath = cpath_next) {
  1797. cpath_next = cpath->next;
  1798. if (crypt_path == cpath)
  1799. return 1;
  1800. }
  1801. return 0;
  1802. }
  1803. /** Return true iff client-side optimistic data is supported. */
  1804. static int
  1805. optimistic_data_enabled(void)
  1806. {
  1807. const or_options_t *options = get_options();
  1808. if (options->OptimisticData < 0) {
  1809. /* XXX023 consider having auto default to 1 rather than 0 before
  1810. * the 0.2.3 branch goes stable. See bug 3617. -RD */
  1811. const int32_t enabled =
  1812. networkstatus_get_param(NULL, "UseOptimisticData", 0, 0, 1);
  1813. return (int)enabled;
  1814. }
  1815. return options->OptimisticData;
  1816. }
  1817. /** Attach the AP stream <b>apconn</b> to circ's linked list of
  1818. * p_streams. Also set apconn's cpath_layer to <b>cpath</b>, or to the last
  1819. * hop in circ's cpath if <b>cpath</b> is NULL.
  1820. */
  1821. static void
  1822. link_apconn_to_circ(entry_connection_t *apconn, origin_circuit_t *circ,
  1823. crypt_path_t *cpath)
  1824. {
  1825. const node_t *exitnode;
  1826. /* add it into the linked list of streams on this circuit */
  1827. log_debug(LD_APP|LD_CIRC, "attaching new conn to circ. n_circ_id %u.",
  1828. (unsigned)circ->base_.n_circ_id);
  1829. /* reset it, so we can measure circ timeouts */
  1830. ENTRY_TO_CONN(apconn)->timestamp_lastread = time(NULL);
  1831. ENTRY_TO_EDGE_CONN(apconn)->next_stream = circ->p_streams;
  1832. ENTRY_TO_EDGE_CONN(apconn)->on_circuit = TO_CIRCUIT(circ);
  1833. /* assert_connection_ok(conn, time(NULL)); */
  1834. circ->p_streams = ENTRY_TO_EDGE_CONN(apconn);
  1835. if (connection_edge_is_rendezvous_stream(ENTRY_TO_EDGE_CONN(apconn))) {
  1836. /* We are attaching a stream to a rendezvous circuit. That means
  1837. * that an attempt to connect to a hidden service just
  1838. * succeeded. Tell rendclient.c. */
  1839. rend_client_note_connection_attempt_ended(
  1840. ENTRY_TO_EDGE_CONN(apconn)->rend_data->onion_address);
  1841. }
  1842. if (cpath) { /* we were given one; use it */
  1843. tor_assert(cpath_is_on_circuit(circ, cpath));
  1844. } else {
  1845. /* use the last hop in the circuit */
  1846. tor_assert(circ->cpath);
  1847. tor_assert(circ->cpath->prev);
  1848. tor_assert(circ->cpath->prev->state == CPATH_STATE_OPEN);
  1849. cpath = circ->cpath->prev;
  1850. }
  1851. ENTRY_TO_EDGE_CONN(apconn)->cpath_layer = cpath;
  1852. circ->isolation_any_streams_attached = 1;
  1853. connection_edge_update_circuit_isolation(apconn, circ, 0);
  1854. /* See if we can use optimistic data on this circuit */
  1855. if (cpath->extend_info &&
  1856. (exitnode = node_get_by_id(cpath->extend_info->identity_digest)) &&
  1857. exitnode->rs) {
  1858. /* Okay; we know what exit node this is. */
  1859. if (optimistic_data_enabled() &&
  1860. circ->base_.purpose == CIRCUIT_PURPOSE_C_GENERAL &&
  1861. exitnode->rs->version_supports_optimistic_data)
  1862. apconn->may_use_optimistic_data = 1;
  1863. else
  1864. apconn->may_use_optimistic_data = 0;
  1865. log_info(LD_APP, "Looks like completed circuit to %s %s allow "
  1866. "optimistic data for connection to %s",
  1867. safe_str_client(node_describe(exitnode)),
  1868. apconn->may_use_optimistic_data ? "does" : "doesn't",
  1869. safe_str_client(apconn->socks_request->address));
  1870. }
  1871. }
  1872. /** Return true iff <b>address</b> is matched by one of the entries in
  1873. * TrackHostExits. */
  1874. int
  1875. hostname_in_track_host_exits(const or_options_t *options, const char *address)
  1876. {
  1877. if (!options->TrackHostExits)
  1878. return 0;
  1879. SMARTLIST_FOREACH_BEGIN(options->TrackHostExits, const char *, cp) {
  1880. if (cp[0] == '.') { /* match end */
  1881. if (cp[1] == '\0' ||
  1882. !strcasecmpend(address, cp) ||
  1883. !strcasecmp(address, &cp[1]))
  1884. return 1;
  1885. } else if (strcasecmp(cp, address) == 0) {
  1886. return 1;
  1887. }
  1888. } SMARTLIST_FOREACH_END(cp);
  1889. return 0;
  1890. }
  1891. /** If an exit wasn't explicitly specified for <b>conn</b>, consider saving
  1892. * the exit that we *did* choose for use by future connections to
  1893. * <b>conn</b>'s destination.
  1894. */
  1895. static void
  1896. consider_recording_trackhost(const entry_connection_t *conn,
  1897. const origin_circuit_t *circ)
  1898. {
  1899. const or_options_t *options = get_options();
  1900. char *new_address = NULL;
  1901. char fp[HEX_DIGEST_LEN+1];
  1902. /* Search the addressmap for this conn's destination. */
  1903. /* If he's not in the address map.. */
  1904. if (!options->TrackHostExits ||
  1905. addressmap_have_mapping(conn->socks_request->address,
  1906. options->TrackHostExitsExpire))
  1907. return; /* nothing to track, or already mapped */
  1908. if (!hostname_in_track_host_exits(options, conn->socks_request->address) ||
  1909. !circ->build_state->chosen_exit)
  1910. return;
  1911. /* write down the fingerprint of the chosen exit, not the nickname,
  1912. * because the chosen exit might not be named. */
  1913. base16_encode(fp, sizeof(fp),
  1914. circ->build_state->chosen_exit->identity_digest, DIGEST_LEN);
  1915. /* Add this exit/hostname pair to the addressmap. */
  1916. tor_asprintf(&new_address, "%s.%s.exit",
  1917. conn->socks_request->address, fp);
  1918. addressmap_register(conn->socks_request->address, new_address,
  1919. time(NULL) + options->TrackHostExitsExpire,
  1920. ADDRMAPSRC_TRACKEXIT, 0, 0);
  1921. }
  1922. /** Attempt to attach the connection <b>conn</b> to <b>circ</b>, and send a
  1923. * begin or resolve cell as appropriate. Return values are as for
  1924. * connection_ap_handshake_attach_circuit. The stream will exit from the hop
  1925. * indicated by <b>cpath</b>, or from the last hop in circ's cpath if
  1926. * <b>cpath</b> is NULL. */
  1927. int
  1928. connection_ap_handshake_attach_chosen_circuit(entry_connection_t *conn,
  1929. origin_circuit_t *circ,
  1930. crypt_path_t *cpath)
  1931. {
  1932. connection_t *base_conn = ENTRY_TO_CONN(conn);
  1933. tor_assert(conn);
  1934. tor_assert(base_conn->state == AP_CONN_STATE_CIRCUIT_WAIT ||
  1935. base_conn->state == AP_CONN_STATE_CONTROLLER_WAIT);
  1936. tor_assert(conn->socks_request);
  1937. tor_assert(circ);
  1938. tor_assert(circ->base_.state == CIRCUIT_STATE_OPEN);
  1939. base_conn->state = AP_CONN_STATE_CIRCUIT_WAIT;
  1940. if (!circ->base_.timestamp_dirty)
  1941. circ->base_.timestamp_dirty = time(NULL);
  1942. pathbias_count_use_attempt(circ);
  1943. link_apconn_to_circ(conn, circ, cpath);
  1944. tor_assert(conn->socks_request);
  1945. if (conn->socks_request->command == SOCKS_COMMAND_CONNECT) {
  1946. if (!conn->use_begindir)
  1947. consider_recording_trackhost(conn, circ);
  1948. if (connection_ap_handshake_send_begin(conn) < 0)
  1949. return -1;
  1950. } else {
  1951. if (connection_ap_handshake_send_resolve(conn) < 0)
  1952. return -1;
  1953. }
  1954. return 1;
  1955. }
  1956. /** Try to find a safe live circuit for CONN_TYPE_AP connection conn. If
  1957. * we don't find one: if conn cannot be handled by any known nodes,
  1958. * warn and return -1 (conn needs to die, and is maybe already marked);
  1959. * else launch new circuit (if necessary) and return 0.
  1960. * Otherwise, associate conn with a safe live circuit, do the
  1961. * right next step, and return 1.
  1962. */
  1963. /* XXXX this function should mark for close whenever it returns -1;
  1964. * its callers shouldn't have to worry about that. */
  1965. int
  1966. connection_ap_handshake_attach_circuit(entry_connection_t *conn)
  1967. {
  1968. connection_t *base_conn = ENTRY_TO_CONN(conn);
  1969. int retval;
  1970. int conn_age;
  1971. int want_onehop;
  1972. tor_assert(conn);
  1973. tor_assert(base_conn->state == AP_CONN_STATE_CIRCUIT_WAIT);
  1974. tor_assert(conn->socks_request);
  1975. want_onehop = conn->want_onehop;
  1976. conn_age = (int)(time(NULL) - base_conn->timestamp_created);
  1977. if (conn_age >= get_options()->SocksTimeout) {
  1978. int severity = (tor_addr_is_null(&base_conn->addr) && !base_conn->port) ?
  1979. LOG_INFO : LOG_NOTICE;
  1980. log_fn(severity, LD_APP,
  1981. "Tried for %d seconds to get a connection to %s:%d. Giving up.",
  1982. conn_age, safe_str_client(conn->socks_request->address),
  1983. conn->socks_request->port);
  1984. return -1;
  1985. }
  1986. if (!connection_edge_is_rendezvous_stream(ENTRY_TO_EDGE_CONN(conn))) {
  1987. /* we're a general conn */
  1988. origin_circuit_t *circ=NULL;
  1989. if (conn->chosen_exit_name) {
  1990. const node_t *node = node_get_by_nickname(conn->chosen_exit_name, 1);
  1991. int opt = conn->chosen_exit_optional;
  1992. if (!node && !want_onehop) {
  1993. /* We ran into this warning when trying to extend a circuit to a
  1994. * hidden service directory for which we didn't have a router
  1995. * descriptor. See flyspray task 767 for more details. We should
  1996. * keep this in mind when deciding to use BEGIN_DIR cells for other
  1997. * directory requests as well. -KL*/
  1998. log_fn(opt ? LOG_INFO : LOG_WARN, LD_APP,
  1999. "Requested exit point '%s' is not known. %s.",
  2000. conn->chosen_exit_name, opt ? "Trying others" : "Closing");
  2001. if (opt) {
  2002. conn->chosen_exit_optional = 0;
  2003. tor_free(conn->chosen_exit_name);
  2004. return 0;
  2005. }
  2006. return -1;
  2007. }
  2008. if (node && !connection_ap_can_use_exit(conn, node)) {
  2009. log_fn(opt ? LOG_INFO : LOG_WARN, LD_APP,
  2010. "Requested exit point '%s' is excluded or "
  2011. "would refuse request. %s.",
  2012. conn->chosen_exit_name, opt ? "Trying others" : "Closing");
  2013. if (opt) {
  2014. conn->chosen_exit_optional = 0;
  2015. tor_free(conn->chosen_exit_name);
  2016. return 0;
  2017. }
  2018. return -1;
  2019. }
  2020. }
  2021. /* find the circuit that we should use, if there is one. */
  2022. retval = circuit_get_open_circ_or_launch(
  2023. conn, CIRCUIT_PURPOSE_C_GENERAL, &circ);
  2024. if (retval < 1) // XXX023 if we totally fail, this still returns 0 -RD
  2025. return retval;
  2026. log_debug(LD_APP|LD_CIRC,
  2027. "Attaching apconn to circ %u (stream %d sec old).",
  2028. (unsigned)circ->base_.n_circ_id, conn_age);
  2029. /* print the circ's path, so people can figure out which circs are
  2030. * sucking. */
  2031. circuit_log_path(LOG_INFO,LD_APP|LD_CIRC,circ);
  2032. /* We have found a suitable circuit for our conn. Hurray. */
  2033. return connection_ap_handshake_attach_chosen_circuit(conn, circ, NULL);
  2034. } else { /* we're a rendezvous conn */
  2035. origin_circuit_t *rendcirc=NULL, *introcirc=NULL;
  2036. tor_assert(!ENTRY_TO_EDGE_CONN(conn)->cpath_layer);
  2037. /* start by finding a rendezvous circuit for us */
  2038. retval = circuit_get_open_circ_or_launch(
  2039. conn, CIRCUIT_PURPOSE_C_REND_JOINED, &rendcirc);
  2040. if (retval < 0) return -1; /* failed */
  2041. if (retval > 0) {
  2042. tor_assert(rendcirc);
  2043. /* one is already established, attach */
  2044. log_info(LD_REND,
  2045. "rend joined circ %d already here. attaching. "
  2046. "(stream %d sec old)",
  2047. (unsigned)rendcirc->base_.n_circ_id, conn_age);
  2048. /* Mark rendezvous circuits as 'newly dirty' every time you use
  2049. * them, since the process of rebuilding a rendezvous circ is so
  2050. * expensive. There is a tradeoff between linkability and
  2051. * feasibility, at this point.
  2052. */
  2053. rendcirc->base_.timestamp_dirty = time(NULL);
  2054. /* We've also attempted to use them. If they fail, we need to
  2055. * probe them for path bias */
  2056. pathbias_count_use_attempt(rendcirc);
  2057. link_apconn_to_circ(conn, rendcirc, NULL);
  2058. if (connection_ap_handshake_send_begin(conn) < 0)
  2059. return 0; /* already marked, let them fade away */
  2060. return 1;
  2061. }
  2062. if (rendcirc && (rendcirc->base_.purpose ==
  2063. CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED)) {
  2064. log_info(LD_REND,
  2065. "pending-join circ %u already here, with intro ack. "
  2066. "Stalling. (stream %d sec old)",
  2067. (unsigned)rendcirc->base_.n_circ_id, conn_age);
  2068. return 0;
  2069. }
  2070. /* it's on its way. find an intro circ. */
  2071. retval = circuit_get_open_circ_or_launch(
  2072. conn, CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT, &introcirc);
  2073. if (retval < 0) return -1; /* failed */
  2074. if (retval > 0) {
  2075. /* one has already sent the intro. keep waiting. */
  2076. tor_assert(introcirc);
  2077. log_info(LD_REND, "Intro circ %u present and awaiting ack (rend %u). "
  2078. "Stalling. (stream %d sec old)",
  2079. (unsigned)introcirc->base_.n_circ_id,
  2080. rendcirc ? (unsigned)rendcirc->base_.n_circ_id : 0,
  2081. conn_age);
  2082. return 0;
  2083. }
  2084. /* now rendcirc and introcirc are each either undefined or not finished */
  2085. if (rendcirc && introcirc &&
  2086. rendcirc->base_.purpose == CIRCUIT_PURPOSE_C_REND_READY) {
  2087. log_info(LD_REND,
  2088. "ready rend circ %u already here (no intro-ack yet on "
  2089. "intro %u). (stream %d sec old)",
  2090. (unsigned)rendcirc->base_.n_circ_id,
  2091. (unsigned)introcirc->base_.n_circ_id, conn_age);
  2092. tor_assert(introcirc->base_.purpose == CIRCUIT_PURPOSE_C_INTRODUCING);
  2093. if (introcirc->base_.state == CIRCUIT_STATE_OPEN) {
  2094. log_info(LD_REND,"found open intro circ %u (rend %u); sending "
  2095. "introduction. (stream %d sec old)",
  2096. (unsigned)introcirc->base_.n_circ_id,
  2097. (unsigned)rendcirc->base_.n_circ_id,
  2098. conn_age);
  2099. switch (rend_client_send_introduction(introcirc, rendcirc)) {
  2100. case 0: /* success */
  2101. rendcirc->base_.timestamp_dirty = time(NULL);
  2102. introcirc->base_.timestamp_dirty = time(NULL);
  2103. pathbias_count_use_attempt(introcirc);
  2104. pathbias_count_use_attempt(rendcirc);
  2105. assert_circuit_ok(TO_CIRCUIT(rendcirc));
  2106. assert_circuit_ok(TO_CIRCUIT(introcirc));
  2107. return 0;
  2108. case -1: /* transient error */
  2109. return 0;
  2110. case -2: /* permanent error */
  2111. return -1;
  2112. default: /* oops */
  2113. tor_fragile_assert();
  2114. return -1;
  2115. }
  2116. }
  2117. }
  2118. log_info(LD_REND, "Intro (%u) and rend (%u) circs are not both ready. "
  2119. "Stalling conn. (%d sec old)",
  2120. introcirc ? (unsigned)introcirc->base_.n_circ_id : 0,
  2121. rendcirc ? (unsigned)rendcirc->base_.n_circ_id : 0, conn_age);
  2122. return 0;
  2123. }
  2124. }
  2125. /** Change <b>circ</b>'s purpose to <b>new_purpose</b>. */
  2126. void
  2127. circuit_change_purpose(circuit_t *circ, uint8_t new_purpose)
  2128. {
  2129. uint8_t old_purpose;
  2130. /* Don't allow an OR circ to become an origin circ or vice versa. */
  2131. tor_assert(!!(CIRCUIT_IS_ORIGIN(circ)) ==
  2132. !!(CIRCUIT_PURPOSE_IS_ORIGIN(new_purpose)));
  2133. if (circ->purpose == new_purpose) return;
  2134. if (CIRCUIT_IS_ORIGIN(circ)) {
  2135. char old_purpose_desc[80] = "";
  2136. strncpy(old_purpose_desc, circuit_purpose_to_string(circ->purpose), 80-1);
  2137. old_purpose_desc[80-1] = '\0';
  2138. log_debug(LD_CIRC,
  2139. "changing purpose of origin circ %d "
  2140. "from \"%s\" (%d) to \"%s\" (%d)",
  2141. TO_ORIGIN_CIRCUIT(circ)->global_identifier,
  2142. old_purpose_desc,
  2143. circ->purpose,
  2144. circuit_purpose_to_string(new_purpose),
  2145. new_purpose);
  2146. }
  2147. old_purpose = circ->purpose;
  2148. circ->purpose = new_purpose;
  2149. if (CIRCUIT_IS_ORIGIN(circ)) {
  2150. control_event_circuit_purpose_changed(TO_ORIGIN_CIRCUIT(circ),
  2151. old_purpose);
  2152. }
  2153. }
  2154. /** Mark <b>circ</b> so that no more connections can be attached to it. */
  2155. void
  2156. mark_circuit_unusable_for_new_conns(origin_circuit_t *circ)
  2157. {
  2158. const or_options_t *options = get_options();
  2159. tor_assert(circ);
  2160. /* XXXX025 This is a kludge; we're only keeping it around in case there's
  2161. * something that doesn't check unusable_for_new_conns, and to avoid
  2162. * deeper refactoring of our expiration logic. */
  2163. if (! circ->base_.timestamp_dirty)
  2164. circ->base_.timestamp_dirty = approx_time();
  2165. if (options->MaxCircuitDirtiness >= circ->base_.timestamp_dirty)
  2166. circ->base_.timestamp_dirty = 1; /* prevent underflow */
  2167. else
  2168. circ->base_.timestamp_dirty -= options->MaxCircuitDirtiness;
  2169. circ->unusable_for_new_conns = 1;
  2170. }