circuituse.c 106 KB

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