circuituse.c 116 KB

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