circuitlist.c 87 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701
  1. /* Copyright 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 circuitlist.c
  8. *
  9. * \brief Manage global structures that list and index circuits, and
  10. * look up circuits within them.
  11. *
  12. * One of the most frequent operations in Tor occurs every time that
  13. * a relay cell arrives on a channel. When that happens, we need to
  14. * find which circuit it is associated with, based on the channel and the
  15. * circuit ID in the relay cell.
  16. *
  17. * To handle that, we maintain a global list of circuits, and a hashtable
  18. * mapping [channel,circID] pairs to circuits. Circuits are added to and
  19. * removed from this mapping using circuit_set_p_circid_chan() and
  20. * circuit_set_n_circid_chan(). To look up a circuit from this map, most
  21. * callers should use circuit_get_by_circid_channel(), though
  22. * circuit_get_by_circid_channel_even_if_marked() is appropriate under some
  23. * circumstances.
  24. *
  25. * We also need to allow for the possibility that we have blocked use of a
  26. * circuit ID (because we are waiting to send a DESTROY cell), but the
  27. * circuit is not there any more. For that case, we allow placeholder
  28. * entries in the table, using channel_mark_circid_unusable().
  29. *
  30. * To efficiently handle a channel that has just opened, we also maintain a
  31. * list of the circuits waiting for channels, so we can attach them as
  32. * needed without iterating through the whole list of circuits, using
  33. * circuit_get_all_pending_on_channel().
  34. *
  35. * In this module, we also handle the list of circuits that have been
  36. * marked for close elsewhere, and close them as needed. (We use this
  37. * "mark now, close later" pattern here and elsewhere to avoid
  38. * unpredictable recursion if we closed every circuit immediately upon
  39. * realizing it needed to close.) See circuit_mark_for_close() for the
  40. * mark function, and circuit_close_all_marked() for the close function.
  41. *
  42. * For hidden services, we need to be able to look up introduction point
  43. * circuits and rendezvous circuits by cookie, key, etc. These are
  44. * currently handled with linear searches in
  45. * circuit_get_ready_rend_circuit_by_rend_data(),
  46. * circuit_get_next_by_pk_and_purpose(), and with hash lookups in
  47. * circuit_get_rendezvous() and circuit_get_intro_point().
  48. *
  49. * This module is also the entry point for our out-of-memory handler
  50. * logic, which was originally circuit-focused.
  51. **/
  52. #define CIRCUITLIST_PRIVATE
  53. #include "torint.h" /* TOR_PRIuSZ */
  54. #include "or.h"
  55. #include "channel.h"
  56. #include "circpathbias.h"
  57. #include "circuitbuild.h"
  58. #include "circuitlist.h"
  59. #include "circuituse.h"
  60. #include "circuitstats.h"
  61. #include "connection.h"
  62. #include "config.h"
  63. #include "connection_edge.h"
  64. #include "connection_or.h"
  65. #include "control.h"
  66. #include "entrynodes.h"
  67. #include "main.h"
  68. #include "hs_circuit.h"
  69. #include "hs_circuitmap.h"
  70. #include "hs_ident.h"
  71. #include "networkstatus.h"
  72. #include "nodelist.h"
  73. #include "onion.h"
  74. #include "onion_fast.h"
  75. #include "policies.h"
  76. #include "relay.h"
  77. #include "rendclient.h"
  78. #include "rendcommon.h"
  79. #include "rephist.h"
  80. #include "routerlist.h"
  81. #include "routerset.h"
  82. #include "channelpadding.h"
  83. #include "ht.h"
  84. /********* START VARIABLES **********/
  85. /** A global list of all circuits at this hop. */
  86. static smartlist_t *global_circuitlist = NULL;
  87. /** A global list of all origin circuits. Every element of this is also
  88. * an element of global_circuitlist. */
  89. static smartlist_t *global_origin_circuit_list = NULL;
  90. /** A list of all the circuits in CIRCUIT_STATE_CHAN_WAIT. */
  91. static smartlist_t *circuits_pending_chans = NULL;
  92. /** List of all the (origin) circuits whose state is
  93. * CIRCUIT_STATE_GUARD_WAIT. */
  94. static smartlist_t *circuits_pending_other_guards = NULL;
  95. /** A list of all the circuits that have been marked with
  96. * circuit_mark_for_close and which are waiting for circuit_about_to_free. */
  97. static smartlist_t *circuits_pending_close = NULL;
  98. static void circuit_free_cpath_node(crypt_path_t *victim);
  99. static void cpath_ref_decref(crypt_path_reference_t *cpath_ref);
  100. static void circuit_about_to_free_atexit(circuit_t *circ);
  101. static void circuit_about_to_free(circuit_t *circ);
  102. /**
  103. * A cached value of the current state of the origin circuit list. Has the
  104. * value 1 if we saw any opened circuits recently (since the last call to
  105. * circuit_any_opened_circuits(), which gets called around once a second by
  106. * circuit_expire_building). 0 otherwise.
  107. */
  108. static int any_opened_circs_cached_val = 0;
  109. /********* END VARIABLES ************/
  110. /** A map from channel and circuit ID to circuit. (Lookup performance is
  111. * very important here, since we need to do it every time a cell arrives.) */
  112. typedef struct chan_circid_circuit_map_t {
  113. HT_ENTRY(chan_circid_circuit_map_t) node;
  114. channel_t *chan;
  115. circid_t circ_id;
  116. circuit_t *circuit;
  117. /* For debugging 12184: when was this placeholder item added? */
  118. time_t made_placeholder_at;
  119. } chan_circid_circuit_map_t;
  120. /** Helper for hash tables: compare the channel and circuit ID for a and
  121. * b, and return less than, equal to, or greater than zero appropriately.
  122. */
  123. static inline int
  124. chan_circid_entries_eq_(chan_circid_circuit_map_t *a,
  125. chan_circid_circuit_map_t *b)
  126. {
  127. return a->chan == b->chan && a->circ_id == b->circ_id;
  128. }
  129. /** Helper: return a hash based on circuit ID and the pointer value of
  130. * chan in <b>a</b>. */
  131. static inline unsigned int
  132. chan_circid_entry_hash_(chan_circid_circuit_map_t *a)
  133. {
  134. /* Try to squeze the siphash input into 8 bytes to save any extra siphash
  135. * rounds. This hash function is in the critical path. */
  136. uintptr_t chan = (uintptr_t) (void*) a->chan;
  137. uint32_t array[2];
  138. array[0] = a->circ_id;
  139. /* The low bits of the channel pointer are uninteresting, since the channel
  140. * is a pretty big structure. */
  141. array[1] = (uint32_t) (chan >> 6);
  142. return (unsigned) siphash24g(array, sizeof(array));
  143. }
  144. /** Map from [chan,circid] to circuit. */
  145. static HT_HEAD(chan_circid_map, chan_circid_circuit_map_t)
  146. chan_circid_map = HT_INITIALIZER();
  147. HT_PROTOTYPE(chan_circid_map, chan_circid_circuit_map_t, node,
  148. chan_circid_entry_hash_, chan_circid_entries_eq_)
  149. HT_GENERATE2(chan_circid_map, chan_circid_circuit_map_t, node,
  150. chan_circid_entry_hash_, chan_circid_entries_eq_, 0.6,
  151. tor_reallocarray_, tor_free_)
  152. /** The most recently returned entry from circuit_get_by_circid_chan;
  153. * used to improve performance when many cells arrive in a row from the
  154. * same circuit.
  155. */
  156. static chan_circid_circuit_map_t *_last_circid_chan_ent = NULL;
  157. /** Implementation helper for circuit_set_{p,n}_circid_channel: A circuit ID
  158. * and/or channel for circ has just changed from <b>old_chan, old_id</b>
  159. * to <b>chan, id</b>. Adjust the chan,circid map as appropriate, removing
  160. * the old entry (if any) and adding a new one. */
  161. static void
  162. circuit_set_circid_chan_helper(circuit_t *circ, int direction,
  163. circid_t id,
  164. channel_t *chan)
  165. {
  166. chan_circid_circuit_map_t search;
  167. chan_circid_circuit_map_t *found;
  168. channel_t *old_chan, **chan_ptr;
  169. circid_t old_id, *circid_ptr;
  170. int make_active, attached = 0;
  171. if (direction == CELL_DIRECTION_OUT) {
  172. chan_ptr = &circ->n_chan;
  173. circid_ptr = &circ->n_circ_id;
  174. make_active = circ->n_chan_cells.n > 0;
  175. } else {
  176. or_circuit_t *c = TO_OR_CIRCUIT(circ);
  177. chan_ptr = &c->p_chan;
  178. circid_ptr = &c->p_circ_id;
  179. make_active = c->p_chan_cells.n > 0;
  180. }
  181. old_chan = *chan_ptr;
  182. old_id = *circid_ptr;
  183. if (id == old_id && chan == old_chan)
  184. return;
  185. if (_last_circid_chan_ent &&
  186. ((old_id == _last_circid_chan_ent->circ_id &&
  187. old_chan == _last_circid_chan_ent->chan) ||
  188. (id == _last_circid_chan_ent->circ_id &&
  189. chan == _last_circid_chan_ent->chan))) {
  190. _last_circid_chan_ent = NULL;
  191. }
  192. if (old_chan) {
  193. /*
  194. * If we're changing channels or ID and had an old channel and a non
  195. * zero old ID and weren't marked for close (i.e., we should have been
  196. * attached), detach the circuit. ID changes require this because
  197. * circuitmux hashes on (channel_id, circuit_id).
  198. */
  199. if (old_id != 0 && (old_chan != chan || old_id != id) &&
  200. !(circ->marked_for_close)) {
  201. tor_assert(old_chan->cmux);
  202. circuitmux_detach_circuit(old_chan->cmux, circ);
  203. }
  204. /* we may need to remove it from the conn-circid map */
  205. search.circ_id = old_id;
  206. search.chan = old_chan;
  207. found = HT_REMOVE(chan_circid_map, &chan_circid_map, &search);
  208. if (found) {
  209. tor_free(found);
  210. if (direction == CELL_DIRECTION_OUT) {
  211. /* One fewer circuits use old_chan as n_chan */
  212. --(old_chan->num_n_circuits);
  213. } else {
  214. /* One fewer circuits use old_chan as p_chan */
  215. --(old_chan->num_p_circuits);
  216. }
  217. }
  218. }
  219. /* Change the values only after we have possibly made the circuit inactive
  220. * on the previous chan. */
  221. *chan_ptr = chan;
  222. *circid_ptr = id;
  223. if (chan == NULL)
  224. return;
  225. /* now add the new one to the conn-circid map */
  226. search.circ_id = id;
  227. search.chan = chan;
  228. found = HT_FIND(chan_circid_map, &chan_circid_map, &search);
  229. if (found) {
  230. found->circuit = circ;
  231. found->made_placeholder_at = 0;
  232. } else {
  233. found = tor_malloc_zero(sizeof(chan_circid_circuit_map_t));
  234. found->circ_id = id;
  235. found->chan = chan;
  236. found->circuit = circ;
  237. HT_INSERT(chan_circid_map, &chan_circid_map, found);
  238. }
  239. /*
  240. * Attach to the circuitmux if we're changing channels or IDs and
  241. * have a new channel and ID to use and the circuit is not marked for
  242. * close.
  243. */
  244. if (chan && id != 0 && (old_chan != chan || old_id != id) &&
  245. !(circ->marked_for_close)) {
  246. tor_assert(chan->cmux);
  247. circuitmux_attach_circuit(chan->cmux, circ, direction);
  248. attached = 1;
  249. }
  250. /*
  251. * This is a no-op if we have no cells, but if we do it marks us active to
  252. * the circuitmux
  253. */
  254. if (make_active && attached)
  255. update_circuit_on_cmux(circ, direction);
  256. /* Adjust circuit counts on new channel */
  257. if (direction == CELL_DIRECTION_OUT) {
  258. ++chan->num_n_circuits;
  259. } else {
  260. ++chan->num_p_circuits;
  261. }
  262. }
  263. /** Mark that circuit id <b>id</b> shouldn't be used on channel <b>chan</b>,
  264. * even if there is no circuit on the channel. We use this to keep the
  265. * circuit id from getting re-used while we have queued but not yet sent
  266. * a destroy cell. */
  267. void
  268. channel_mark_circid_unusable(channel_t *chan, circid_t id)
  269. {
  270. chan_circid_circuit_map_t search;
  271. chan_circid_circuit_map_t *ent;
  272. /* See if there's an entry there. That wouldn't be good. */
  273. memset(&search, 0, sizeof(search));
  274. search.chan = chan;
  275. search.circ_id = id;
  276. ent = HT_FIND(chan_circid_map, &chan_circid_map, &search);
  277. if (ent && ent->circuit) {
  278. /* we have a problem. */
  279. log_warn(LD_BUG, "Tried to mark %u unusable on %p, but there was already "
  280. "a circuit there.", (unsigned)id, chan);
  281. } else if (ent) {
  282. /* It's already marked. */
  283. if (!ent->made_placeholder_at)
  284. ent->made_placeholder_at = approx_time();
  285. } else {
  286. ent = tor_malloc_zero(sizeof(chan_circid_circuit_map_t));
  287. ent->chan = chan;
  288. ent->circ_id = id;
  289. /* leave circuit at NULL. */
  290. ent->made_placeholder_at = approx_time();
  291. HT_INSERT(chan_circid_map, &chan_circid_map, ent);
  292. }
  293. }
  294. /** Mark that a circuit id <b>id</b> can be used again on <b>chan</b>.
  295. * We use this to re-enable the circuit ID after we've sent a destroy cell.
  296. */
  297. void
  298. channel_mark_circid_usable(channel_t *chan, circid_t id)
  299. {
  300. chan_circid_circuit_map_t search;
  301. chan_circid_circuit_map_t *ent;
  302. /* See if there's an entry there. That wouldn't be good. */
  303. memset(&search, 0, sizeof(search));
  304. search.chan = chan;
  305. search.circ_id = id;
  306. ent = HT_REMOVE(chan_circid_map, &chan_circid_map, &search);
  307. if (ent && ent->circuit) {
  308. log_warn(LD_BUG, "Tried to mark %u usable on %p, but there was already "
  309. "a circuit there.", (unsigned)id, chan);
  310. return;
  311. }
  312. if (_last_circid_chan_ent == ent)
  313. _last_circid_chan_ent = NULL;
  314. tor_free(ent);
  315. }
  316. /** Called to indicate that a DESTROY is pending on <b>chan</b> with
  317. * circuit ID <b>id</b>, but hasn't been sent yet. */
  318. void
  319. channel_note_destroy_pending(channel_t *chan, circid_t id)
  320. {
  321. circuit_t *circ = circuit_get_by_circid_channel_even_if_marked(id,chan);
  322. if (circ) {
  323. if (circ->n_chan == chan && circ->n_circ_id == id) {
  324. circ->n_delete_pending = 1;
  325. } else {
  326. or_circuit_t *orcirc = TO_OR_CIRCUIT(circ);
  327. if (orcirc->p_chan == chan && orcirc->p_circ_id == id) {
  328. circ->p_delete_pending = 1;
  329. }
  330. }
  331. return;
  332. }
  333. channel_mark_circid_unusable(chan, id);
  334. }
  335. /** Called to indicate that a DESTROY is no longer pending on <b>chan</b> with
  336. * circuit ID <b>id</b> -- typically, because it has been sent. */
  337. MOCK_IMPL(void,
  338. channel_note_destroy_not_pending,(channel_t *chan, circid_t id))
  339. {
  340. circuit_t *circ = circuit_get_by_circid_channel_even_if_marked(id,chan);
  341. if (circ) {
  342. if (circ->n_chan == chan && circ->n_circ_id == id) {
  343. circ->n_delete_pending = 0;
  344. } else {
  345. or_circuit_t *orcirc = TO_OR_CIRCUIT(circ);
  346. if (orcirc->p_chan == chan && orcirc->p_circ_id == id) {
  347. circ->p_delete_pending = 0;
  348. }
  349. }
  350. /* XXXX this shouldn't happen; log a bug here. */
  351. return;
  352. }
  353. channel_mark_circid_usable(chan, id);
  354. }
  355. /** Set the p_conn field of a circuit <b>circ</b>, along
  356. * with the corresponding circuit ID, and add the circuit as appropriate
  357. * to the (chan,id)-\>circuit map. */
  358. void
  359. circuit_set_p_circid_chan(or_circuit_t *or_circ, circid_t id,
  360. channel_t *chan)
  361. {
  362. circuit_t *circ = TO_CIRCUIT(or_circ);
  363. channel_t *old_chan = or_circ->p_chan;
  364. circid_t old_id = or_circ->p_circ_id;
  365. circuit_set_circid_chan_helper(circ, CELL_DIRECTION_IN, id, chan);
  366. if (chan) {
  367. tor_assert(bool_eq(or_circ->p_chan_cells.n,
  368. or_circ->next_active_on_p_chan));
  369. chan->timestamp_last_had_circuits = approx_time();
  370. }
  371. if (circ->p_delete_pending && old_chan) {
  372. channel_mark_circid_unusable(old_chan, old_id);
  373. circ->p_delete_pending = 0;
  374. }
  375. }
  376. /** Set the n_conn field of a circuit <b>circ</b>, along
  377. * with the corresponding circuit ID, and add the circuit as appropriate
  378. * to the (chan,id)-\>circuit map. */
  379. void
  380. circuit_set_n_circid_chan(circuit_t *circ, circid_t id,
  381. channel_t *chan)
  382. {
  383. channel_t *old_chan = circ->n_chan;
  384. circid_t old_id = circ->n_circ_id;
  385. circuit_set_circid_chan_helper(circ, CELL_DIRECTION_OUT, id, chan);
  386. if (chan) {
  387. tor_assert(bool_eq(circ->n_chan_cells.n, circ->next_active_on_n_chan));
  388. chan->timestamp_last_had_circuits = approx_time();
  389. }
  390. if (circ->n_delete_pending && old_chan) {
  391. channel_mark_circid_unusable(old_chan, old_id);
  392. circ->n_delete_pending = 0;
  393. }
  394. }
  395. /** Change the state of <b>circ</b> to <b>state</b>, adding it to or removing
  396. * it from lists as appropriate. */
  397. void
  398. circuit_set_state(circuit_t *circ, uint8_t state)
  399. {
  400. tor_assert(circ);
  401. if (state == circ->state)
  402. return;
  403. if (PREDICT_UNLIKELY(!circuits_pending_chans))
  404. circuits_pending_chans = smartlist_new();
  405. if (PREDICT_UNLIKELY(!circuits_pending_other_guards))
  406. circuits_pending_other_guards = smartlist_new();
  407. if (circ->state == CIRCUIT_STATE_CHAN_WAIT) {
  408. /* remove from waiting-circuit list. */
  409. smartlist_remove(circuits_pending_chans, circ);
  410. }
  411. if (state == CIRCUIT_STATE_CHAN_WAIT) {
  412. /* add to waiting-circuit list. */
  413. smartlist_add(circuits_pending_chans, circ);
  414. }
  415. if (circ->state == CIRCUIT_STATE_GUARD_WAIT) {
  416. smartlist_remove(circuits_pending_other_guards, circ);
  417. }
  418. if (state == CIRCUIT_STATE_GUARD_WAIT) {
  419. smartlist_add(circuits_pending_other_guards, circ);
  420. }
  421. if (state == CIRCUIT_STATE_GUARD_WAIT || state == CIRCUIT_STATE_OPEN)
  422. tor_assert(!circ->n_chan_create_cell);
  423. circ->state = state;
  424. }
  425. /** Append to <b>out</b> all circuits in state CHAN_WAIT waiting for
  426. * the given connection. */
  427. void
  428. circuit_get_all_pending_on_channel(smartlist_t *out, channel_t *chan)
  429. {
  430. tor_assert(out);
  431. tor_assert(chan);
  432. if (!circuits_pending_chans)
  433. return;
  434. SMARTLIST_FOREACH_BEGIN(circuits_pending_chans, circuit_t *, circ) {
  435. if (circ->marked_for_close)
  436. continue;
  437. if (!circ->n_hop)
  438. continue;
  439. tor_assert(circ->state == CIRCUIT_STATE_CHAN_WAIT);
  440. if (tor_digest_is_zero(circ->n_hop->identity_digest)) {
  441. /* Look at addr/port. This is an unkeyed connection. */
  442. if (!channel_matches_extend_info(chan, circ->n_hop))
  443. continue;
  444. } else {
  445. /* We expected a key. See if it's the right one. */
  446. if (tor_memneq(chan->identity_digest,
  447. circ->n_hop->identity_digest, DIGEST_LEN))
  448. continue;
  449. }
  450. smartlist_add(out, circ);
  451. } SMARTLIST_FOREACH_END(circ);
  452. }
  453. /** Return the number of circuits in state CHAN_WAIT, waiting for the given
  454. * channel. */
  455. int
  456. circuit_count_pending_on_channel(channel_t *chan)
  457. {
  458. int cnt;
  459. smartlist_t *sl = smartlist_new();
  460. tor_assert(chan);
  461. circuit_get_all_pending_on_channel(sl, chan);
  462. cnt = smartlist_len(sl);
  463. smartlist_free(sl);
  464. log_debug(LD_CIRC,"or_conn to %s, %d pending circs",
  465. channel_get_canonical_remote_descr(chan),
  466. cnt);
  467. return cnt;
  468. }
  469. /** Remove <b>origin_circ</b> from the global list of origin circuits.
  470. * Called when we are freeing a circuit.
  471. */
  472. static void
  473. circuit_remove_from_origin_circuit_list(origin_circuit_t *origin_circ)
  474. {
  475. int origin_idx = origin_circ->global_origin_circuit_list_idx;
  476. if (origin_idx < 0)
  477. return;
  478. origin_circuit_t *c2;
  479. tor_assert(origin_idx <= smartlist_len(global_origin_circuit_list));
  480. c2 = smartlist_get(global_origin_circuit_list, origin_idx);
  481. tor_assert(origin_circ == c2);
  482. smartlist_del(global_origin_circuit_list, origin_idx);
  483. if (origin_idx < smartlist_len(global_origin_circuit_list)) {
  484. origin_circuit_t *replacement =
  485. smartlist_get(global_origin_circuit_list, origin_idx);
  486. replacement->global_origin_circuit_list_idx = origin_idx;
  487. }
  488. origin_circ->global_origin_circuit_list_idx = -1;
  489. }
  490. /** Add <b>origin_circ</b> to the global list of origin circuits. Called
  491. * when creating the circuit. */
  492. static void
  493. circuit_add_to_origin_circuit_list(origin_circuit_t *origin_circ)
  494. {
  495. tor_assert(origin_circ->global_origin_circuit_list_idx == -1);
  496. smartlist_t *lst = circuit_get_global_origin_circuit_list();
  497. smartlist_add(lst, origin_circ);
  498. origin_circ->global_origin_circuit_list_idx = smartlist_len(lst) - 1;
  499. }
  500. /** Detach from the global circuit list, and deallocate, all
  501. * circuits that have been marked for close.
  502. */
  503. void
  504. circuit_close_all_marked(void)
  505. {
  506. if (circuits_pending_close == NULL)
  507. return;
  508. smartlist_t *lst = circuit_get_global_list();
  509. SMARTLIST_FOREACH_BEGIN(circuits_pending_close, circuit_t *, circ) {
  510. tor_assert(circ->marked_for_close);
  511. /* Remove it from the circuit list. */
  512. int idx = circ->global_circuitlist_idx;
  513. smartlist_del(lst, idx);
  514. if (idx < smartlist_len(lst)) {
  515. circuit_t *replacement = smartlist_get(lst, idx);
  516. replacement->global_circuitlist_idx = idx;
  517. }
  518. circ->global_circuitlist_idx = -1;
  519. /* Remove it from the origin circuit list, if appropriate. */
  520. if (CIRCUIT_IS_ORIGIN(circ)) {
  521. circuit_remove_from_origin_circuit_list(TO_ORIGIN_CIRCUIT(circ));
  522. }
  523. circuit_about_to_free(circ);
  524. circuit_free(circ);
  525. } SMARTLIST_FOREACH_END(circ);
  526. smartlist_clear(circuits_pending_close);
  527. }
  528. /** Return a pointer to the global list of circuits. */
  529. MOCK_IMPL(smartlist_t *,
  530. circuit_get_global_list,(void))
  531. {
  532. if (NULL == global_circuitlist)
  533. global_circuitlist = smartlist_new();
  534. return global_circuitlist;
  535. }
  536. /** Return a pointer to the global list of origin circuits. */
  537. smartlist_t *
  538. circuit_get_global_origin_circuit_list(void)
  539. {
  540. if (NULL == global_origin_circuit_list)
  541. global_origin_circuit_list = smartlist_new();
  542. return global_origin_circuit_list;
  543. }
  544. /**
  545. * Return true if we have any opened general-purpose 3 hop
  546. * origin circuits.
  547. *
  548. * The result from this function is cached for use by
  549. * circuit_any_opened_circuits_cached().
  550. */
  551. int
  552. circuit_any_opened_circuits(void)
  553. {
  554. SMARTLIST_FOREACH_BEGIN(circuit_get_global_origin_circuit_list(),
  555. const origin_circuit_t *, next_circ) {
  556. if (!TO_CIRCUIT(next_circ)->marked_for_close &&
  557. next_circ->has_opened &&
  558. TO_CIRCUIT(next_circ)->state == CIRCUIT_STATE_OPEN &&
  559. TO_CIRCUIT(next_circ)->purpose != CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT &&
  560. next_circ->build_state &&
  561. next_circ->build_state->desired_path_len == DEFAULT_ROUTE_LEN) {
  562. circuit_cache_opened_circuit_state(1);
  563. return 1;
  564. }
  565. } SMARTLIST_FOREACH_END(next_circ);
  566. circuit_cache_opened_circuit_state(0);
  567. return 0;
  568. }
  569. /**
  570. * Cache the "any circuits opened" state, as specified in param
  571. * circuits_are_opened. This is a helper function to update
  572. * the circuit opened status whenever we happen to look at the
  573. * circuit list.
  574. */
  575. void
  576. circuit_cache_opened_circuit_state(int circuits_are_opened)
  577. {
  578. any_opened_circs_cached_val = circuits_are_opened;
  579. }
  580. /**
  581. * Return true if there were any opened circuits since the last call to
  582. * circuit_any_opened_circuits(), or since circuit_expire_building() last
  583. * ran (it runs roughly once per second).
  584. */
  585. int
  586. circuit_any_opened_circuits_cached(void)
  587. {
  588. return any_opened_circs_cached_val;
  589. }
  590. /** Function to make circ-\>state human-readable */
  591. const char *
  592. circuit_state_to_string(int state)
  593. {
  594. static char buf[64];
  595. switch (state) {
  596. case CIRCUIT_STATE_BUILDING: return "doing handshakes";
  597. case CIRCUIT_STATE_ONIONSKIN_PENDING: return "processing the onion";
  598. case CIRCUIT_STATE_CHAN_WAIT: return "connecting to server";
  599. case CIRCUIT_STATE_GUARD_WAIT: return "waiting to see how other "
  600. "guards perform";
  601. case CIRCUIT_STATE_OPEN: return "open";
  602. default:
  603. log_warn(LD_BUG, "Unknown circuit state %d", state);
  604. tor_snprintf(buf, sizeof(buf), "unknown state [%d]", state);
  605. return buf;
  606. }
  607. }
  608. /** Map a circuit purpose to a string suitable to be displayed to a
  609. * controller. */
  610. const char *
  611. circuit_purpose_to_controller_string(uint8_t purpose)
  612. {
  613. static char buf[32];
  614. switch (purpose) {
  615. case CIRCUIT_PURPOSE_OR:
  616. case CIRCUIT_PURPOSE_INTRO_POINT:
  617. case CIRCUIT_PURPOSE_REND_POINT_WAITING:
  618. case CIRCUIT_PURPOSE_REND_ESTABLISHED:
  619. return "SERVER"; /* A controller should never see these, actually. */
  620. case CIRCUIT_PURPOSE_C_GENERAL:
  621. return "GENERAL";
  622. case CIRCUIT_PURPOSE_C_HSDIR_GET:
  623. return "HS_CLIENT_HSDIR";
  624. case CIRCUIT_PURPOSE_C_INTRODUCING:
  625. case CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT:
  626. case CIRCUIT_PURPOSE_C_INTRODUCE_ACKED:
  627. return "HS_CLIENT_INTRO";
  628. case CIRCUIT_PURPOSE_C_ESTABLISH_REND:
  629. case CIRCUIT_PURPOSE_C_REND_READY:
  630. case CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED:
  631. case CIRCUIT_PURPOSE_C_REND_JOINED:
  632. return "HS_CLIENT_REND";
  633. case CIRCUIT_PURPOSE_S_HSDIR_POST:
  634. return "HS_SERVICE_HSDIR";
  635. case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO:
  636. case CIRCUIT_PURPOSE_S_INTRO:
  637. return "HS_SERVICE_INTRO";
  638. case CIRCUIT_PURPOSE_S_CONNECT_REND:
  639. case CIRCUIT_PURPOSE_S_REND_JOINED:
  640. return "HS_SERVICE_REND";
  641. case CIRCUIT_PURPOSE_TESTING:
  642. return "TESTING";
  643. case CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT:
  644. return "MEASURE_TIMEOUT";
  645. case CIRCUIT_PURPOSE_CONTROLLER:
  646. return "CONTROLLER";
  647. case CIRCUIT_PURPOSE_PATH_BIAS_TESTING:
  648. return "PATH_BIAS_TESTING";
  649. case CIRCUIT_PURPOSE_HS_VANGUARDS:
  650. return "HS_VANGUARDS";
  651. default:
  652. tor_snprintf(buf, sizeof(buf), "UNKNOWN_%d", (int)purpose);
  653. return buf;
  654. }
  655. }
  656. /** Return a string specifying the state of the hidden-service circuit
  657. * purpose <b>purpose</b>, or NULL if <b>purpose</b> is not a
  658. * hidden-service-related circuit purpose. */
  659. const char *
  660. circuit_purpose_to_controller_hs_state_string(uint8_t purpose)
  661. {
  662. switch (purpose)
  663. {
  664. default:
  665. log_fn(LOG_WARN, LD_BUG,
  666. "Unrecognized circuit purpose: %d",
  667. (int)purpose);
  668. tor_fragile_assert();
  669. /* fall through */
  670. case CIRCUIT_PURPOSE_OR:
  671. case CIRCUIT_PURPOSE_C_GENERAL:
  672. case CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT:
  673. case CIRCUIT_PURPOSE_TESTING:
  674. case CIRCUIT_PURPOSE_CONTROLLER:
  675. case CIRCUIT_PURPOSE_PATH_BIAS_TESTING:
  676. case CIRCUIT_PURPOSE_HS_VANGUARDS:
  677. return NULL;
  678. case CIRCUIT_PURPOSE_INTRO_POINT:
  679. return "OR_HSSI_ESTABLISHED";
  680. case CIRCUIT_PURPOSE_REND_POINT_WAITING:
  681. return "OR_HSCR_ESTABLISHED";
  682. case CIRCUIT_PURPOSE_REND_ESTABLISHED:
  683. return "OR_HS_R_JOINED";
  684. case CIRCUIT_PURPOSE_C_HSDIR_GET:
  685. case CIRCUIT_PURPOSE_C_INTRODUCING:
  686. return "HSCI_CONNECTING";
  687. case CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT:
  688. return "HSCI_INTRO_SENT";
  689. case CIRCUIT_PURPOSE_C_INTRODUCE_ACKED:
  690. return "HSCI_DONE";
  691. case CIRCUIT_PURPOSE_C_ESTABLISH_REND:
  692. return "HSCR_CONNECTING";
  693. case CIRCUIT_PURPOSE_C_REND_READY:
  694. return "HSCR_ESTABLISHED_IDLE";
  695. case CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED:
  696. return "HSCR_ESTABLISHED_WAITING";
  697. case CIRCUIT_PURPOSE_C_REND_JOINED:
  698. return "HSCR_JOINED";
  699. case CIRCUIT_PURPOSE_S_HSDIR_POST:
  700. case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO:
  701. return "HSSI_CONNECTING";
  702. case CIRCUIT_PURPOSE_S_INTRO:
  703. return "HSSI_ESTABLISHED";
  704. case CIRCUIT_PURPOSE_S_CONNECT_REND:
  705. return "HSSR_CONNECTING";
  706. case CIRCUIT_PURPOSE_S_REND_JOINED:
  707. return "HSSR_JOINED";
  708. }
  709. }
  710. /** Return a human-readable string for the circuit purpose <b>purpose</b>. */
  711. const char *
  712. circuit_purpose_to_string(uint8_t purpose)
  713. {
  714. static char buf[32];
  715. switch (purpose)
  716. {
  717. case CIRCUIT_PURPOSE_OR:
  718. return "Circuit at relay";
  719. case CIRCUIT_PURPOSE_INTRO_POINT:
  720. return "Acting as intro point";
  721. case CIRCUIT_PURPOSE_REND_POINT_WAITING:
  722. return "Acting as rendezvous (pending)";
  723. case CIRCUIT_PURPOSE_REND_ESTABLISHED:
  724. return "Acting as rendezvous (established)";
  725. case CIRCUIT_PURPOSE_C_GENERAL:
  726. return "General-purpose client";
  727. case CIRCUIT_PURPOSE_C_INTRODUCING:
  728. return "Hidden service client: Connecting to intro point";
  729. case CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT:
  730. return "Hidden service client: Waiting for ack from intro point";
  731. case CIRCUIT_PURPOSE_C_INTRODUCE_ACKED:
  732. return "Hidden service client: Received ack from intro point";
  733. case CIRCUIT_PURPOSE_C_ESTABLISH_REND:
  734. return "Hidden service client: Establishing rendezvous point";
  735. case CIRCUIT_PURPOSE_C_REND_READY:
  736. return "Hidden service client: Pending rendezvous point";
  737. case CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED:
  738. return "Hidden service client: Pending rendezvous point (ack received)";
  739. case CIRCUIT_PURPOSE_C_REND_JOINED:
  740. return "Hidden service client: Active rendezvous point";
  741. case CIRCUIT_PURPOSE_C_HSDIR_GET:
  742. return "Hidden service client: Fetching HS descriptor";
  743. case CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT:
  744. return "Measuring circuit timeout";
  745. case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO:
  746. return "Hidden service: Establishing introduction point";
  747. case CIRCUIT_PURPOSE_S_INTRO:
  748. return "Hidden service: Introduction point";
  749. case CIRCUIT_PURPOSE_S_CONNECT_REND:
  750. return "Hidden service: Connecting to rendezvous point";
  751. case CIRCUIT_PURPOSE_S_REND_JOINED:
  752. return "Hidden service: Active rendezvous point";
  753. case CIRCUIT_PURPOSE_S_HSDIR_POST:
  754. return "Hidden service: Uploading HS descriptor";
  755. case CIRCUIT_PURPOSE_TESTING:
  756. return "Testing circuit";
  757. case CIRCUIT_PURPOSE_CONTROLLER:
  758. return "Circuit made by controller";
  759. case CIRCUIT_PURPOSE_PATH_BIAS_TESTING:
  760. return "Path-bias testing circuit";
  761. case CIRCUIT_PURPOSE_HS_VANGUARDS:
  762. return "Hidden service: Pre-built vanguard circuit";
  763. default:
  764. tor_snprintf(buf, sizeof(buf), "UNKNOWN_%d", (int)purpose);
  765. return buf;
  766. }
  767. }
  768. /** Pick a reasonable package_window to start out for our circuits.
  769. * Originally this was hard-coded at 1000, but now the consensus votes
  770. * on the answer. See proposal 168. */
  771. int32_t
  772. circuit_initial_package_window(void)
  773. {
  774. int32_t num = networkstatus_get_param(NULL, "circwindow", CIRCWINDOW_START,
  775. CIRCWINDOW_START_MIN,
  776. CIRCWINDOW_START_MAX);
  777. /* If the consensus tells us a negative number, we'd assert. */
  778. if (num < 0)
  779. num = CIRCWINDOW_START;
  780. return num;
  781. }
  782. /** Initialize the common elements in a circuit_t, and add it to the global
  783. * list. */
  784. static void
  785. init_circuit_base(circuit_t *circ)
  786. {
  787. tor_gettimeofday(&circ->timestamp_created);
  788. // Gets reset when we send CREATE_FAST.
  789. // circuit_expire_building() expects these to be equal
  790. // until the orconn is built.
  791. circ->timestamp_began = circ->timestamp_created;
  792. circ->package_window = circuit_initial_package_window();
  793. circ->deliver_window = CIRCWINDOW_START;
  794. cell_queue_init(&circ->n_chan_cells);
  795. smartlist_add(circuit_get_global_list(), circ);
  796. circ->global_circuitlist_idx = smartlist_len(circuit_get_global_list()) - 1;
  797. }
  798. /** If we haven't yet decided on a good timeout value for circuit
  799. * building, we close idle circuits aggressively so we can get more
  800. * data points. */
  801. #define IDLE_TIMEOUT_WHILE_LEARNING (1*60)
  802. /** Allocate space for a new circuit, initializing with <b>p_circ_id</b>
  803. * and <b>p_conn</b>. Add it to the global circuit list.
  804. */
  805. origin_circuit_t *
  806. origin_circuit_new(void)
  807. {
  808. origin_circuit_t *circ;
  809. /* never zero, since a global ID of 0 is treated specially by the
  810. * controller */
  811. static uint32_t n_circuits_allocated = 1;
  812. circ = tor_malloc_zero(sizeof(origin_circuit_t));
  813. circ->base_.magic = ORIGIN_CIRCUIT_MAGIC;
  814. circ->next_stream_id = crypto_rand_int(1<<16);
  815. circ->global_identifier = n_circuits_allocated++;
  816. circ->remaining_relay_early_cells = MAX_RELAY_EARLY_CELLS_PER_CIRCUIT;
  817. circ->remaining_relay_early_cells -= crypto_rand_int(2);
  818. init_circuit_base(TO_CIRCUIT(circ));
  819. /* Add to origin-list. */
  820. circ->global_origin_circuit_list_idx = -1;
  821. circuit_add_to_origin_circuit_list(circ);
  822. circuit_build_times_update_last_circ(get_circuit_build_times_mutable());
  823. if (! circuit_build_times_disabled(get_options()) &&
  824. circuit_build_times_needs_circuits(get_circuit_build_times())) {
  825. /* Circuits should be shorter lived if we need more of them
  826. * for learning a good build timeout */
  827. circ->circuit_idle_timeout = IDLE_TIMEOUT_WHILE_LEARNING;
  828. } else {
  829. // This should always be larger than the current port prediction time
  830. // remaining, or else we'll end up with the case where a circuit times out
  831. // and another one is built, effectively doubling the timeout window.
  832. //
  833. // We also randomize it by up to 5% more (ie 5% of 0 to 3600 seconds,
  834. // depending on how much circuit prediction time is remaining) so that
  835. // we don't close a bunch of unused circuits all at the same time.
  836. int prediction_time_remaining =
  837. predicted_ports_prediction_time_remaining(time(NULL));
  838. circ->circuit_idle_timeout = prediction_time_remaining+1+
  839. crypto_rand_int(1+prediction_time_remaining/20);
  840. if (circ->circuit_idle_timeout <= 0) {
  841. log_warn(LD_BUG,
  842. "Circuit chose a negative idle timeout of %d based on "
  843. "%d seconds of predictive building remaining.",
  844. circ->circuit_idle_timeout,
  845. prediction_time_remaining);
  846. circ->circuit_idle_timeout = IDLE_TIMEOUT_WHILE_LEARNING;
  847. }
  848. log_info(LD_CIRC,
  849. "Circuit " U64_FORMAT " chose an idle timeout of %d based on "
  850. "%d seconds of predictive building remaining.",
  851. U64_PRINTF_ARG(circ->global_identifier),
  852. circ->circuit_idle_timeout,
  853. prediction_time_remaining);
  854. }
  855. return circ;
  856. }
  857. /** Allocate a new or_circuit_t, connected to <b>p_chan</b> as
  858. * <b>p_circ_id</b>. If <b>p_chan</b> is NULL, the circuit is unattached. */
  859. or_circuit_t *
  860. or_circuit_new(circid_t p_circ_id, channel_t *p_chan)
  861. {
  862. /* CircIDs */
  863. or_circuit_t *circ;
  864. circ = tor_malloc_zero(sizeof(or_circuit_t));
  865. circ->base_.magic = OR_CIRCUIT_MAGIC;
  866. if (p_chan)
  867. circuit_set_p_circid_chan(circ, p_circ_id, p_chan);
  868. circ->remaining_relay_early_cells = MAX_RELAY_EARLY_CELLS_PER_CIRCUIT;
  869. cell_queue_init(&circ->p_chan_cells);
  870. init_circuit_base(TO_CIRCUIT(circ));
  871. return circ;
  872. }
  873. /** Free all storage held in circ->testing_cell_stats */
  874. void
  875. circuit_clear_testing_cell_stats(circuit_t *circ)
  876. {
  877. if (!circ || !circ->testing_cell_stats)
  878. return;
  879. SMARTLIST_FOREACH(circ->testing_cell_stats, testing_cell_stats_entry_t *,
  880. ent, tor_free(ent));
  881. smartlist_free(circ->testing_cell_stats);
  882. circ->testing_cell_stats = NULL;
  883. }
  884. /** Deallocate space associated with circ.
  885. */
  886. STATIC void
  887. circuit_free_(circuit_t *circ)
  888. {
  889. circid_t n_circ_id = 0;
  890. void *mem;
  891. size_t memlen;
  892. int should_free = 1;
  893. if (!circ)
  894. return;
  895. /* We keep a copy of this so we can log its value before it gets unset. */
  896. n_circ_id = circ->n_circ_id;
  897. circuit_clear_testing_cell_stats(circ);
  898. /* Cleanup circuit from anything HS v3 related. We also do this when the
  899. * circuit is closed. This is to avoid any code path that free registered
  900. * circuits without closing them before. This needs to be done before the
  901. * hs identifier is freed. */
  902. hs_circ_cleanup(circ);
  903. if (CIRCUIT_IS_ORIGIN(circ)) {
  904. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  905. mem = ocirc;
  906. memlen = sizeof(origin_circuit_t);
  907. tor_assert(circ->magic == ORIGIN_CIRCUIT_MAGIC);
  908. circuit_remove_from_origin_circuit_list(ocirc);
  909. if (ocirc->build_state) {
  910. extend_info_free(ocirc->build_state->chosen_exit);
  911. circuit_free_cpath_node(ocirc->build_state->pending_final_cpath);
  912. cpath_ref_decref(ocirc->build_state->service_pending_final_cpath_ref);
  913. }
  914. tor_free(ocirc->build_state);
  915. /* Cancel before freeing, if we haven't already succeeded or failed. */
  916. if (ocirc->guard_state) {
  917. entry_guard_cancel(&ocirc->guard_state);
  918. }
  919. circuit_guard_state_free(ocirc->guard_state);
  920. circuit_clear_cpath(ocirc);
  921. crypto_pk_free(ocirc->intro_key);
  922. rend_data_free(ocirc->rend_data);
  923. /* Finally, free the identifier of the circuit and nullify it so multiple
  924. * cleanup will work. */
  925. hs_ident_circuit_free(ocirc->hs_ident);
  926. ocirc->hs_ident = NULL;
  927. tor_free(ocirc->dest_address);
  928. if (ocirc->socks_username) {
  929. memwipe(ocirc->socks_username, 0x12, ocirc->socks_username_len);
  930. tor_free(ocirc->socks_username);
  931. }
  932. if (ocirc->socks_password) {
  933. memwipe(ocirc->socks_password, 0x06, ocirc->socks_password_len);
  934. tor_free(ocirc->socks_password);
  935. }
  936. addr_policy_list_free(ocirc->prepend_policy);
  937. } else {
  938. or_circuit_t *ocirc = TO_OR_CIRCUIT(circ);
  939. /* Remember cell statistics for this circuit before deallocating. */
  940. if (get_options()->CellStatistics)
  941. rep_hist_buffer_stats_add_circ(circ, time(NULL));
  942. mem = ocirc;
  943. memlen = sizeof(or_circuit_t);
  944. tor_assert(circ->magic == OR_CIRCUIT_MAGIC);
  945. should_free = (ocirc->workqueue_entry == NULL);
  946. crypto_cipher_free(ocirc->p_crypto);
  947. crypto_digest_free(ocirc->p_digest);
  948. crypto_cipher_free(ocirc->n_crypto);
  949. crypto_digest_free(ocirc->n_digest);
  950. if (ocirc->rend_splice) {
  951. or_circuit_t *other = ocirc->rend_splice;
  952. tor_assert(other->base_.magic == OR_CIRCUIT_MAGIC);
  953. other->rend_splice = NULL;
  954. }
  955. /* remove from map. */
  956. circuit_set_p_circid_chan(ocirc, 0, NULL);
  957. /* Clear cell queue _after_ removing it from the map. Otherwise our
  958. * "active" checks will be violated. */
  959. cell_queue_clear(&ocirc->p_chan_cells);
  960. }
  961. extend_info_free(circ->n_hop);
  962. tor_free(circ->n_chan_create_cell);
  963. if (circ->global_circuitlist_idx != -1) {
  964. int idx = circ->global_circuitlist_idx;
  965. circuit_t *c2 = smartlist_get(global_circuitlist, idx);
  966. tor_assert(c2 == circ);
  967. smartlist_del(global_circuitlist, idx);
  968. if (idx < smartlist_len(global_circuitlist)) {
  969. c2 = smartlist_get(global_circuitlist, idx);
  970. c2->global_circuitlist_idx = idx;
  971. }
  972. }
  973. /* Remove from map. */
  974. circuit_set_n_circid_chan(circ, 0, NULL);
  975. /* Clear cell queue _after_ removing it from the map. Otherwise our
  976. * "active" checks will be violated. */
  977. cell_queue_clear(&circ->n_chan_cells);
  978. log_info(LD_CIRC, "Circuit %u (id: %" PRIu32 ") has been freed.",
  979. n_circ_id,
  980. CIRCUIT_IS_ORIGIN(circ) ?
  981. TO_ORIGIN_CIRCUIT(circ)->global_identifier : 0);
  982. if (should_free) {
  983. memwipe(mem, 0xAA, memlen); /* poison memory */
  984. tor_free(mem);
  985. } else {
  986. /* If we made it here, this is an or_circuit_t that still has a pending
  987. * cpuworker request which we weren't able to cancel. Instead, set up
  988. * the magic value so that when the reply comes back, we'll know to discard
  989. * the reply and free this structure.
  990. */
  991. memwipe(mem, 0xAA, memlen);
  992. circ->magic = DEAD_CIRCUIT_MAGIC;
  993. }
  994. }
  995. /** Deallocate the linked list circ-><b>cpath</b>, and remove the cpath from
  996. * <b>circ</b>. */
  997. void
  998. circuit_clear_cpath(origin_circuit_t *circ)
  999. {
  1000. crypt_path_t *victim, *head, *cpath;
  1001. head = cpath = circ->cpath;
  1002. if (!cpath)
  1003. return;
  1004. /* it's a circular list, so we have to notice when we've
  1005. * gone through it once. */
  1006. while (cpath->next && cpath->next != head) {
  1007. victim = cpath;
  1008. cpath = victim->next;
  1009. circuit_free_cpath_node(victim);
  1010. }
  1011. circuit_free_cpath_node(cpath);
  1012. circ->cpath = NULL;
  1013. }
  1014. /** Release all storage held by circuits. */
  1015. void
  1016. circuit_free_all(void)
  1017. {
  1018. smartlist_t *lst = circuit_get_global_list();
  1019. SMARTLIST_FOREACH_BEGIN(lst, circuit_t *, tmp) {
  1020. if (! CIRCUIT_IS_ORIGIN(tmp)) {
  1021. or_circuit_t *or_circ = TO_OR_CIRCUIT(tmp);
  1022. while (or_circ->resolving_streams) {
  1023. edge_connection_t *next_conn;
  1024. next_conn = or_circ->resolving_streams->next_stream;
  1025. connection_free_(TO_CONN(or_circ->resolving_streams));
  1026. or_circ->resolving_streams = next_conn;
  1027. }
  1028. }
  1029. tmp->global_circuitlist_idx = -1;
  1030. circuit_about_to_free_atexit(tmp);
  1031. circuit_free(tmp);
  1032. SMARTLIST_DEL_CURRENT(lst, tmp);
  1033. } SMARTLIST_FOREACH_END(tmp);
  1034. smartlist_free(lst);
  1035. global_circuitlist = NULL;
  1036. smartlist_free(global_origin_circuit_list);
  1037. global_origin_circuit_list = NULL;
  1038. smartlist_free(circuits_pending_chans);
  1039. circuits_pending_chans = NULL;
  1040. smartlist_free(circuits_pending_close);
  1041. circuits_pending_close = NULL;
  1042. smartlist_free(circuits_pending_other_guards);
  1043. circuits_pending_other_guards = NULL;
  1044. {
  1045. chan_circid_circuit_map_t **elt, **next, *c;
  1046. for (elt = HT_START(chan_circid_map, &chan_circid_map);
  1047. elt;
  1048. elt = next) {
  1049. c = *elt;
  1050. next = HT_NEXT_RMV(chan_circid_map, &chan_circid_map, elt);
  1051. tor_assert(c->circuit == NULL);
  1052. tor_free(c);
  1053. }
  1054. }
  1055. HT_CLEAR(chan_circid_map, &chan_circid_map);
  1056. }
  1057. /** Deallocate space associated with the cpath node <b>victim</b>. */
  1058. static void
  1059. circuit_free_cpath_node(crypt_path_t *victim)
  1060. {
  1061. if (!victim)
  1062. return;
  1063. crypto_cipher_free(victim->f_crypto);
  1064. crypto_cipher_free(victim->b_crypto);
  1065. crypto_digest_free(victim->f_digest);
  1066. crypto_digest_free(victim->b_digest);
  1067. onion_handshake_state_release(&victim->handshake_state);
  1068. crypto_dh_free(victim->rend_dh_handshake_state);
  1069. extend_info_free(victim->extend_info);
  1070. memwipe(victim, 0xBB, sizeof(crypt_path_t)); /* poison memory */
  1071. tor_free(victim);
  1072. }
  1073. /** Release a crypt_path_reference_t*, which may be NULL. */
  1074. static void
  1075. cpath_ref_decref(crypt_path_reference_t *cpath_ref)
  1076. {
  1077. if (cpath_ref != NULL) {
  1078. if (--(cpath_ref->refcount) == 0) {
  1079. circuit_free_cpath_node(cpath_ref->cpath);
  1080. tor_free(cpath_ref);
  1081. }
  1082. }
  1083. }
  1084. /** A helper function for circuit_dump_by_conn() below. Log a bunch
  1085. * of information about circuit <b>circ</b>.
  1086. */
  1087. static void
  1088. circuit_dump_conn_details(int severity,
  1089. circuit_t *circ,
  1090. int conn_array_index,
  1091. const char *type,
  1092. circid_t this_circid,
  1093. circid_t other_circid)
  1094. {
  1095. tor_log(severity, LD_CIRC, "Conn %d has %s circuit: circID %u "
  1096. "(other side %u), state %d (%s), born %ld:",
  1097. conn_array_index, type, (unsigned)this_circid, (unsigned)other_circid,
  1098. circ->state, circuit_state_to_string(circ->state),
  1099. (long)circ->timestamp_began.tv_sec);
  1100. if (CIRCUIT_IS_ORIGIN(circ)) { /* circ starts at this node */
  1101. circuit_log_path(severity, LD_CIRC, TO_ORIGIN_CIRCUIT(circ));
  1102. }
  1103. }
  1104. /** Log, at severity <b>severity</b>, information about each circuit
  1105. * that is connected to <b>conn</b>.
  1106. */
  1107. void
  1108. circuit_dump_by_conn(connection_t *conn, int severity)
  1109. {
  1110. edge_connection_t *tmpconn;
  1111. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, circ) {
  1112. circid_t n_circ_id = circ->n_circ_id, p_circ_id = 0;
  1113. if (circ->marked_for_close) {
  1114. continue;
  1115. }
  1116. if (!CIRCUIT_IS_ORIGIN(circ)) {
  1117. p_circ_id = TO_OR_CIRCUIT(circ)->p_circ_id;
  1118. }
  1119. if (CIRCUIT_IS_ORIGIN(circ)) {
  1120. for (tmpconn=TO_ORIGIN_CIRCUIT(circ)->p_streams; tmpconn;
  1121. tmpconn=tmpconn->next_stream) {
  1122. if (TO_CONN(tmpconn) == conn) {
  1123. circuit_dump_conn_details(severity, circ, conn->conn_array_index,
  1124. "App-ward", p_circ_id, n_circ_id);
  1125. }
  1126. }
  1127. }
  1128. if (! CIRCUIT_IS_ORIGIN(circ)) {
  1129. for (tmpconn=TO_OR_CIRCUIT(circ)->n_streams; tmpconn;
  1130. tmpconn=tmpconn->next_stream) {
  1131. if (TO_CONN(tmpconn) == conn) {
  1132. circuit_dump_conn_details(severity, circ, conn->conn_array_index,
  1133. "Exit-ward", n_circ_id, p_circ_id);
  1134. }
  1135. }
  1136. }
  1137. }
  1138. SMARTLIST_FOREACH_END(circ);
  1139. }
  1140. /** Return the circuit whose global ID is <b>id</b>, or NULL if no
  1141. * such circuit exists. */
  1142. origin_circuit_t *
  1143. circuit_get_by_global_id(uint32_t id)
  1144. {
  1145. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, circ) {
  1146. if (CIRCUIT_IS_ORIGIN(circ) &&
  1147. TO_ORIGIN_CIRCUIT(circ)->global_identifier == id) {
  1148. if (circ->marked_for_close)
  1149. return NULL;
  1150. else
  1151. return TO_ORIGIN_CIRCUIT(circ);
  1152. }
  1153. }
  1154. SMARTLIST_FOREACH_END(circ);
  1155. return NULL;
  1156. }
  1157. /** Return a circ such that:
  1158. * - circ-\>n_circ_id or circ-\>p_circ_id is equal to <b>circ_id</b>, and
  1159. * - circ is attached to <b>chan</b>, either as p_chan or n_chan.
  1160. * Return NULL if no such circuit exists.
  1161. *
  1162. * If <b>found_entry_out</b> is provided, set it to true if we have a
  1163. * placeholder entry for circid/chan, and leave it unset otherwise.
  1164. */
  1165. static inline circuit_t *
  1166. circuit_get_by_circid_channel_impl(circid_t circ_id, channel_t *chan,
  1167. int *found_entry_out)
  1168. {
  1169. chan_circid_circuit_map_t search;
  1170. chan_circid_circuit_map_t *found;
  1171. if (_last_circid_chan_ent &&
  1172. circ_id == _last_circid_chan_ent->circ_id &&
  1173. chan == _last_circid_chan_ent->chan) {
  1174. found = _last_circid_chan_ent;
  1175. } else {
  1176. search.circ_id = circ_id;
  1177. search.chan = chan;
  1178. found = HT_FIND(chan_circid_map, &chan_circid_map, &search);
  1179. _last_circid_chan_ent = found;
  1180. }
  1181. if (found && found->circuit) {
  1182. log_debug(LD_CIRC,
  1183. "circuit_get_by_circid_channel_impl() returning circuit %p for"
  1184. " circ_id %u, channel ID " U64_FORMAT " (%p)",
  1185. found->circuit, (unsigned)circ_id,
  1186. U64_PRINTF_ARG(chan->global_identifier), chan);
  1187. if (found_entry_out)
  1188. *found_entry_out = 1;
  1189. return found->circuit;
  1190. }
  1191. log_debug(LD_CIRC,
  1192. "circuit_get_by_circid_channel_impl() found %s for"
  1193. " circ_id %u, channel ID " U64_FORMAT " (%p)",
  1194. found ? "placeholder" : "nothing",
  1195. (unsigned)circ_id,
  1196. U64_PRINTF_ARG(chan->global_identifier), chan);
  1197. if (found_entry_out)
  1198. *found_entry_out = found ? 1 : 0;
  1199. return NULL;
  1200. /* The rest of this checks for bugs. Disabled by default. */
  1201. /* We comment it out because coverity complains otherwise.
  1202. {
  1203. circuit_t *circ;
  1204. TOR_LIST_FOREACH(circ, &global_circuitlist, head) {
  1205. if (! CIRCUIT_IS_ORIGIN(circ)) {
  1206. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  1207. if (or_circ->p_chan == chan && or_circ->p_circ_id == circ_id) {
  1208. log_warn(LD_BUG,
  1209. "circuit matches p_chan, but not in hash table (Bug!)");
  1210. return circ;
  1211. }
  1212. }
  1213. if (circ->n_chan == chan && circ->n_circ_id == circ_id) {
  1214. log_warn(LD_BUG,
  1215. "circuit matches n_chan, but not in hash table (Bug!)");
  1216. return circ;
  1217. }
  1218. }
  1219. return NULL;
  1220. } */
  1221. }
  1222. /** Return a circ such that:
  1223. * - circ-\>n_circ_id or circ-\>p_circ_id is equal to <b>circ_id</b>, and
  1224. * - circ is attached to <b>chan</b>, either as p_chan or n_chan.
  1225. * - circ is not marked for close.
  1226. * Return NULL if no such circuit exists.
  1227. */
  1228. circuit_t *
  1229. circuit_get_by_circid_channel(circid_t circ_id, channel_t *chan)
  1230. {
  1231. circuit_t *circ = circuit_get_by_circid_channel_impl(circ_id, chan, NULL);
  1232. if (!circ || circ->marked_for_close)
  1233. return NULL;
  1234. else
  1235. return circ;
  1236. }
  1237. /** Return a circ such that:
  1238. * - circ-\>n_circ_id or circ-\>p_circ_id is equal to <b>circ_id</b>, and
  1239. * - circ is attached to <b>chan</b>, either as p_chan or n_chan.
  1240. * Return NULL if no such circuit exists.
  1241. */
  1242. circuit_t *
  1243. circuit_get_by_circid_channel_even_if_marked(circid_t circ_id,
  1244. channel_t *chan)
  1245. {
  1246. return circuit_get_by_circid_channel_impl(circ_id, chan, NULL);
  1247. }
  1248. /** Return true iff the circuit ID <b>circ_id</b> is currently used by a
  1249. * circuit, marked or not, on <b>chan</b>, or if the circ ID is reserved until
  1250. * a queued destroy cell can be sent.
  1251. *
  1252. * (Return 1 if the circuit is present, marked or not; Return 2
  1253. * if the circuit ID is pending a destroy.)
  1254. **/
  1255. int
  1256. circuit_id_in_use_on_channel(circid_t circ_id, channel_t *chan)
  1257. {
  1258. int found = 0;
  1259. if (circuit_get_by_circid_channel_impl(circ_id, chan, &found) != NULL)
  1260. return 1;
  1261. if (found)
  1262. return 2;
  1263. return 0;
  1264. }
  1265. /** Helper for debugging 12184. Returns the time since which 'circ_id' has
  1266. * been marked unusable on 'chan'. */
  1267. time_t
  1268. circuit_id_when_marked_unusable_on_channel(circid_t circ_id, channel_t *chan)
  1269. {
  1270. chan_circid_circuit_map_t search;
  1271. chan_circid_circuit_map_t *found;
  1272. memset(&search, 0, sizeof(search));
  1273. search.circ_id = circ_id;
  1274. search.chan = chan;
  1275. found = HT_FIND(chan_circid_map, &chan_circid_map, &search);
  1276. if (! found || found->circuit)
  1277. return 0;
  1278. return found->made_placeholder_at;
  1279. }
  1280. /** Return the circuit that a given edge connection is using. */
  1281. circuit_t *
  1282. circuit_get_by_edge_conn(edge_connection_t *conn)
  1283. {
  1284. circuit_t *circ;
  1285. circ = conn->on_circuit;
  1286. tor_assert(!circ ||
  1287. (CIRCUIT_IS_ORIGIN(circ) ? circ->magic == ORIGIN_CIRCUIT_MAGIC
  1288. : circ->magic == OR_CIRCUIT_MAGIC));
  1289. return circ;
  1290. }
  1291. /** For each circuit that has <b>chan</b> as n_chan or p_chan, unlink the
  1292. * circuit from the chan,circid map, and mark it for close if it hasn't
  1293. * been marked already.
  1294. */
  1295. void
  1296. circuit_unlink_all_from_channel(channel_t *chan, int reason)
  1297. {
  1298. smartlist_t *detached = smartlist_new();
  1299. /* #define DEBUG_CIRCUIT_UNLINK_ALL */
  1300. channel_unlink_all_circuits(chan, detached);
  1301. #ifdef DEBUG_CIRCUIT_UNLINK_ALL
  1302. {
  1303. smartlist_t *detached_2 = smartlist_new();
  1304. int mismatch = 0, badlen = 0;
  1305. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, circ) {
  1306. if (circ->n_chan == chan ||
  1307. (!CIRCUIT_IS_ORIGIN(circ) &&
  1308. TO_OR_CIRCUIT(circ)->p_chan == chan)) {
  1309. smartlist_add(detached_2, circ);
  1310. }
  1311. }
  1312. SMARTLIST_FOREACH_END(circ);
  1313. if (smartlist_len(detached) != smartlist_len(detached_2)) {
  1314. log_warn(LD_BUG, "List of detached circuits had the wrong length! "
  1315. "(got %d, should have gotten %d)",
  1316. (int)smartlist_len(detached),
  1317. (int)smartlist_len(detached_2));
  1318. badlen = 1;
  1319. }
  1320. smartlist_sort_pointers(detached);
  1321. smartlist_sort_pointers(detached_2);
  1322. SMARTLIST_FOREACH(detached, circuit_t *, c,
  1323. if (c != smartlist_get(detached_2, c_sl_idx))
  1324. mismatch = 1;
  1325. );
  1326. if (mismatch)
  1327. log_warn(LD_BUG, "Mismatch in list of detached circuits.");
  1328. if (badlen || mismatch) {
  1329. smartlist_free(detached);
  1330. detached = detached_2;
  1331. } else {
  1332. log_notice(LD_CIRC, "List of %d circuits was as expected.",
  1333. (int)smartlist_len(detached));
  1334. smartlist_free(detached_2);
  1335. }
  1336. }
  1337. #endif /* defined(DEBUG_CIRCUIT_UNLINK_ALL) */
  1338. SMARTLIST_FOREACH_BEGIN(detached, circuit_t *, circ) {
  1339. int mark = 0;
  1340. if (circ->n_chan == chan) {
  1341. circuit_set_n_circid_chan(circ, 0, NULL);
  1342. mark = 1;
  1343. /* If we didn't request this closure, pass the remote
  1344. * bit to mark_for_close. */
  1345. if (chan->reason_for_closing != CHANNEL_CLOSE_REQUESTED)
  1346. reason |= END_CIRC_REASON_FLAG_REMOTE;
  1347. }
  1348. if (! CIRCUIT_IS_ORIGIN(circ)) {
  1349. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  1350. if (or_circ->p_chan == chan) {
  1351. circuit_set_p_circid_chan(or_circ, 0, NULL);
  1352. mark = 1;
  1353. }
  1354. }
  1355. if (!mark) {
  1356. log_warn(LD_BUG, "Circuit on detached list which I had no reason "
  1357. "to mark");
  1358. continue;
  1359. }
  1360. if (!circ->marked_for_close)
  1361. circuit_mark_for_close(circ, reason);
  1362. } SMARTLIST_FOREACH_END(circ);
  1363. smartlist_free(detached);
  1364. }
  1365. /** Return a circ such that
  1366. * - circ-\>rend_data-\>onion_address is equal to
  1367. * <b>rend_data</b>-\>onion_address,
  1368. * - circ-\>rend_data-\>rend_cookie is equal to
  1369. * <b>rend_data</b>-\>rend_cookie, and
  1370. * - circ-\>purpose is equal to CIRCUIT_PURPOSE_C_REND_READY.
  1371. *
  1372. * Return NULL if no such circuit exists.
  1373. */
  1374. origin_circuit_t *
  1375. circuit_get_ready_rend_circ_by_rend_data(const rend_data_t *rend_data)
  1376. {
  1377. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, circ) {
  1378. if (!circ->marked_for_close &&
  1379. circ->purpose == CIRCUIT_PURPOSE_C_REND_READY) {
  1380. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  1381. if (ocirc->rend_data == NULL) {
  1382. continue;
  1383. }
  1384. if (!rend_cmp_service_ids(rend_data_get_address(rend_data),
  1385. rend_data_get_address(ocirc->rend_data)) &&
  1386. tor_memeq(ocirc->rend_data->rend_cookie,
  1387. rend_data->rend_cookie,
  1388. REND_COOKIE_LEN))
  1389. return ocirc;
  1390. }
  1391. }
  1392. SMARTLIST_FOREACH_END(circ);
  1393. return NULL;
  1394. }
  1395. /** Return the first service introduction circuit originating from the global
  1396. * circuit list after <b>start</b> or at the start of the list if <b>start</b>
  1397. * is NULL. Return NULL if no circuit is found.
  1398. *
  1399. * A service introduction point circuit has a purpose of either
  1400. * CIRCUIT_PURPOSE_S_ESTABLISH_INTRO or CIRCUIT_PURPOSE_S_INTRO. This does not
  1401. * return a circuit marked for close and its state must be open. */
  1402. origin_circuit_t *
  1403. circuit_get_next_service_intro_circ(origin_circuit_t *start)
  1404. {
  1405. int idx = 0;
  1406. smartlist_t *lst = circuit_get_global_list();
  1407. if (start) {
  1408. idx = TO_CIRCUIT(start)->global_circuitlist_idx + 1;
  1409. }
  1410. for ( ; idx < smartlist_len(lst); ++idx) {
  1411. circuit_t *circ = smartlist_get(lst, idx);
  1412. /* Ignore a marked for close circuit or purpose not matching a service
  1413. * intro point or if the state is not open. */
  1414. if (circ->marked_for_close || circ->state != CIRCUIT_STATE_OPEN ||
  1415. (circ->purpose != CIRCUIT_PURPOSE_S_ESTABLISH_INTRO &&
  1416. circ->purpose != CIRCUIT_PURPOSE_S_INTRO)) {
  1417. continue;
  1418. }
  1419. /* The purposes we are looking for are only for origin circuits so the
  1420. * following is valid. */
  1421. return TO_ORIGIN_CIRCUIT(circ);
  1422. }
  1423. /* Not found. */
  1424. return NULL;
  1425. }
  1426. /** Return the first service rendezvous circuit originating from the global
  1427. * circuit list after <b>start</b> or at the start of the list if <b>start</b>
  1428. * is NULL. Return NULL if no circuit is found.
  1429. *
  1430. * A service rendezvous point circuit has a purpose of either
  1431. * CIRCUIT_PURPOSE_S_CONNECT_REND or CIRCUIT_PURPOSE_S_REND_JOINED. This does
  1432. * not return a circuit marked for close and its state must be open. */
  1433. origin_circuit_t *
  1434. circuit_get_next_service_rp_circ(origin_circuit_t *start)
  1435. {
  1436. int idx = 0;
  1437. smartlist_t *lst = circuit_get_global_list();
  1438. if (start) {
  1439. idx = TO_CIRCUIT(start)->global_circuitlist_idx + 1;
  1440. }
  1441. for ( ; idx < smartlist_len(lst); ++idx) {
  1442. circuit_t *circ = smartlist_get(lst, idx);
  1443. /* Ignore a marked for close circuit or purpose not matching a service
  1444. * intro point or if the state is not open. */
  1445. if (circ->marked_for_close || circ->state != CIRCUIT_STATE_OPEN ||
  1446. (circ->purpose != CIRCUIT_PURPOSE_S_CONNECT_REND &&
  1447. circ->purpose != CIRCUIT_PURPOSE_S_REND_JOINED)) {
  1448. continue;
  1449. }
  1450. /* The purposes we are looking for are only for origin circuits so the
  1451. * following is valid. */
  1452. return TO_ORIGIN_CIRCUIT(circ);
  1453. }
  1454. /* Not found. */
  1455. return NULL;
  1456. }
  1457. /** Return the first circuit originating here in global_circuitlist after
  1458. * <b>start</b> whose purpose is <b>purpose</b>, and where <b>digest</b> (if
  1459. * set) matches the private key digest of the rend data associated with the
  1460. * circuit. Return NULL if no circuit is found. If <b>start</b> is NULL,
  1461. * begin at the start of the list.
  1462. */
  1463. origin_circuit_t *
  1464. circuit_get_next_by_pk_and_purpose(origin_circuit_t *start,
  1465. const uint8_t *digest, uint8_t purpose)
  1466. {
  1467. int idx;
  1468. smartlist_t *lst = circuit_get_global_list();
  1469. tor_assert(CIRCUIT_PURPOSE_IS_ORIGIN(purpose));
  1470. if (start == NULL)
  1471. idx = 0;
  1472. else
  1473. idx = TO_CIRCUIT(start)->global_circuitlist_idx + 1;
  1474. for ( ; idx < smartlist_len(lst); ++idx) {
  1475. circuit_t *circ = smartlist_get(lst, idx);
  1476. origin_circuit_t *ocirc;
  1477. if (circ->marked_for_close)
  1478. continue;
  1479. if (circ->purpose != purpose)
  1480. continue;
  1481. /* At this point we should be able to get a valid origin circuit because
  1482. * the origin purpose we are looking for matches this circuit. */
  1483. if (BUG(!CIRCUIT_PURPOSE_IS_ORIGIN(circ->purpose))) {
  1484. break;
  1485. }
  1486. ocirc = TO_ORIGIN_CIRCUIT(circ);
  1487. if (!digest)
  1488. return ocirc;
  1489. if (rend_circuit_pk_digest_eq(ocirc, digest)) {
  1490. return ocirc;
  1491. }
  1492. }
  1493. return NULL;
  1494. }
  1495. /** We might cannibalize this circuit: Return true if its last hop can be used
  1496. * as a v3 rendezvous point. */
  1497. static int
  1498. circuit_can_be_cannibalized_for_v3_rp(const origin_circuit_t *circ)
  1499. {
  1500. if (!circ->build_state) {
  1501. return 0;
  1502. }
  1503. extend_info_t *chosen_exit = circ->build_state->chosen_exit;
  1504. if (BUG(!chosen_exit)) {
  1505. return 0;
  1506. }
  1507. const node_t *rp_node = node_get_by_id(chosen_exit->identity_digest);
  1508. if (rp_node) {
  1509. if (node_supports_v3_rendezvous_point(rp_node)) {
  1510. return 1;
  1511. }
  1512. }
  1513. return 0;
  1514. }
  1515. /** We are trying to create a circuit of purpose <b>purpose</b> and we are
  1516. * looking for cannibalizable circuits. Return the circuit purpose we would be
  1517. * willing to cannibalize. */
  1518. static uint8_t
  1519. get_circuit_purpose_needed_to_cannibalize(uint8_t purpose)
  1520. {
  1521. if (circuit_should_use_vanguards(purpose)) {
  1522. /* If we are using vanguards, then we should only cannibalize vanguard
  1523. * circuits so that we get the same path construction logic. */
  1524. return CIRCUIT_PURPOSE_HS_VANGUARDS;
  1525. } else {
  1526. /* If no vanguards are used just get a general circuit! */
  1527. return CIRCUIT_PURPOSE_C_GENERAL;
  1528. }
  1529. }
  1530. /** Return a circuit that is open, is CIRCUIT_PURPOSE_C_GENERAL,
  1531. * has a timestamp_dirty value of 0, has flags matching the CIRCLAUNCH_*
  1532. * flags in <b>flags</b>, and if info is defined, does not already use info
  1533. * as any of its hops; or NULL if no circuit fits this description.
  1534. *
  1535. * The <b>purpose</b> argument refers to the purpose of the circuit we want to
  1536. * create, not the purpose of the circuit we want to cannibalize.
  1537. *
  1538. * If !CIRCLAUNCH_NEED_UPTIME, prefer returning non-uptime circuits.
  1539. *
  1540. * To "cannibalize" a circuit means to extend it an extra hop, and use it
  1541. * for some other purpose than we had originally intended. We do this when
  1542. * we want to perform some low-bandwidth task at a specific relay, and we
  1543. * would like the circuit to complete as soon as possible. (If we were going
  1544. * to use a lot of bandwidth, we wouldn't want a circuit with an extra hop.
  1545. * If we didn't care about circuit completion latency, we would just build
  1546. * a new circuit.)
  1547. */
  1548. origin_circuit_t *
  1549. circuit_find_to_cannibalize(uint8_t purpose_to_produce, extend_info_t *info,
  1550. int flags)
  1551. {
  1552. origin_circuit_t *best=NULL;
  1553. int need_uptime = (flags & CIRCLAUNCH_NEED_UPTIME) != 0;
  1554. int need_capacity = (flags & CIRCLAUNCH_NEED_CAPACITY) != 0;
  1555. int internal = (flags & CIRCLAUNCH_IS_INTERNAL) != 0;
  1556. const or_options_t *options = get_options();
  1557. /* We want the circuit we are trying to cannibalize to have this purpose */
  1558. int purpose_to_search_for;
  1559. /* Make sure we're not trying to create a onehop circ by
  1560. * cannibalization. */
  1561. tor_assert(!(flags & CIRCLAUNCH_ONEHOP_TUNNEL));
  1562. purpose_to_search_for = get_circuit_purpose_needed_to_cannibalize(
  1563. purpose_to_produce);
  1564. tor_assert_nonfatal(purpose_to_search_for == CIRCUIT_PURPOSE_C_GENERAL ||
  1565. purpose_to_search_for == CIRCUIT_PURPOSE_HS_VANGUARDS);
  1566. log_debug(LD_CIRC,
  1567. "Hunting for a circ to cannibalize: purpose %d, uptime %d, "
  1568. "capacity %d, internal %d",
  1569. purpose_to_produce, need_uptime, need_capacity, internal);
  1570. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, circ_) {
  1571. if (CIRCUIT_IS_ORIGIN(circ_) &&
  1572. circ_->state == CIRCUIT_STATE_OPEN &&
  1573. !circ_->marked_for_close &&
  1574. circ_->purpose == purpose_to_search_for &&
  1575. !circ_->timestamp_dirty) {
  1576. origin_circuit_t *circ = TO_ORIGIN_CIRCUIT(circ_);
  1577. /* Only cannibalize from reasonable length circuits. If we
  1578. * want C_GENERAL, then only choose 3 hop circs. If we want
  1579. * HS_VANGUARDS, only choose 4 hop circs.
  1580. */
  1581. if (circ->build_state->desired_path_len !=
  1582. route_len_for_purpose(purpose_to_search_for, NULL)) {
  1583. goto next;
  1584. }
  1585. /* Ignore any circuits for which we can't use the Guard. It is possible
  1586. * that the Guard was removed from the samepled set after the circuit
  1587. * was created so avoid using it. */
  1588. if (!entry_guard_could_succeed(circ->guard_state)) {
  1589. goto next;
  1590. }
  1591. if ((!need_uptime || circ->build_state->need_uptime) &&
  1592. (!need_capacity || circ->build_state->need_capacity) &&
  1593. (internal == circ->build_state->is_internal) &&
  1594. !circ->unusable_for_new_conns &&
  1595. circ->remaining_relay_early_cells &&
  1596. !circ->build_state->onehop_tunnel &&
  1597. !circ->isolation_values_set) {
  1598. if (info) {
  1599. /* need to make sure we don't duplicate hops */
  1600. crypt_path_t *hop = circ->cpath;
  1601. const node_t *ri1 = node_get_by_id(info->identity_digest);
  1602. do {
  1603. const node_t *ri2;
  1604. if (tor_memeq(hop->extend_info->identity_digest,
  1605. info->identity_digest, DIGEST_LEN))
  1606. goto next;
  1607. if (ri1 &&
  1608. (ri2 = node_get_by_id(hop->extend_info->identity_digest))
  1609. && nodes_in_same_family(ri1, ri2))
  1610. goto next;
  1611. hop=hop->next;
  1612. } while (hop!=circ->cpath);
  1613. }
  1614. if (options->ExcludeNodes) {
  1615. /* Make sure no existing nodes in the circuit are excluded for
  1616. * general use. (This may be possible if StrictNodes is 0, and we
  1617. * thought we needed to use an otherwise excluded node for, say, a
  1618. * directory operation.) */
  1619. crypt_path_t *hop = circ->cpath;
  1620. do {
  1621. if (routerset_contains_extendinfo(options->ExcludeNodes,
  1622. hop->extend_info))
  1623. goto next;
  1624. hop = hop->next;
  1625. } while (hop != circ->cpath);
  1626. }
  1627. if ((flags & CIRCLAUNCH_IS_V3_RP) &&
  1628. !circuit_can_be_cannibalized_for_v3_rp(circ)) {
  1629. log_debug(LD_GENERAL, "Skipping uncannibalizable circuit for v3 "
  1630. "rendezvous point.");
  1631. goto next;
  1632. }
  1633. if (!best || (best->build_state->need_uptime && !need_uptime))
  1634. best = circ;
  1635. next: ;
  1636. }
  1637. }
  1638. }
  1639. SMARTLIST_FOREACH_END(circ_);
  1640. return best;
  1641. }
  1642. /**
  1643. * Check whether any of the origin circuits that are waiting to see if
  1644. * their guard is good enough to use can be upgraded to "ready". If so,
  1645. * return a new smartlist containing them. Otherwise return NULL.
  1646. */
  1647. smartlist_t *
  1648. circuit_find_circuits_to_upgrade_from_guard_wait(void)
  1649. {
  1650. /* Only if some circuit is actually waiting on an upgrade should we
  1651. * run the algorithm. */
  1652. if (! circuits_pending_other_guards ||
  1653. smartlist_len(circuits_pending_other_guards)==0)
  1654. return NULL;
  1655. /* Only if we have some origin circuits should we run the algorithm. */
  1656. if (!global_origin_circuit_list)
  1657. return NULL;
  1658. /* Okay; we can pass our circuit list to entrynodes.c.*/
  1659. smartlist_t *result = smartlist_new();
  1660. int circuits_upgraded = entry_guards_upgrade_waiting_circuits(
  1661. get_guard_selection_info(),
  1662. global_origin_circuit_list,
  1663. result);
  1664. if (circuits_upgraded && smartlist_len(result)) {
  1665. return result;
  1666. } else {
  1667. smartlist_free(result);
  1668. return NULL;
  1669. }
  1670. }
  1671. /** Return the number of hops in circuit's path. If circ has no entries,
  1672. * or is NULL, returns 0. */
  1673. int
  1674. circuit_get_cpath_len(origin_circuit_t *circ)
  1675. {
  1676. int n = 0;
  1677. if (circ && circ->cpath) {
  1678. crypt_path_t *cpath, *cpath_next = NULL;
  1679. for (cpath = circ->cpath; cpath_next != circ->cpath; cpath = cpath_next) {
  1680. cpath_next = cpath->next;
  1681. ++n;
  1682. }
  1683. }
  1684. return n;
  1685. }
  1686. /** Return the number of opened hops in circuit's path.
  1687. * If circ has no entries, or is NULL, returns 0. */
  1688. int
  1689. circuit_get_cpath_opened_len(const origin_circuit_t *circ)
  1690. {
  1691. int n = 0;
  1692. if (circ && circ->cpath) {
  1693. crypt_path_t *cpath, *cpath_next = NULL;
  1694. for (cpath = circ->cpath;
  1695. cpath->state == CPATH_STATE_OPEN
  1696. && cpath_next != circ->cpath;
  1697. cpath = cpath_next) {
  1698. cpath_next = cpath->next;
  1699. ++n;
  1700. }
  1701. }
  1702. return n;
  1703. }
  1704. /** Return the <b>hopnum</b>th hop in <b>circ</b>->cpath, or NULL if there
  1705. * aren't that many hops in the list. <b>hopnum</b> starts at 1.
  1706. * Returns NULL if <b>hopnum</b> is 0 or negative. */
  1707. crypt_path_t *
  1708. circuit_get_cpath_hop(origin_circuit_t *circ, int hopnum)
  1709. {
  1710. if (circ && circ->cpath && hopnum > 0) {
  1711. crypt_path_t *cpath, *cpath_next = NULL;
  1712. for (cpath = circ->cpath; cpath_next != circ->cpath; cpath = cpath_next) {
  1713. cpath_next = cpath->next;
  1714. if (--hopnum <= 0)
  1715. return cpath;
  1716. }
  1717. }
  1718. return NULL;
  1719. }
  1720. /** Go through the circuitlist; mark-for-close each circuit that starts
  1721. * at us but has not yet been used. */
  1722. void
  1723. circuit_mark_all_unused_circs(void)
  1724. {
  1725. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, circ) {
  1726. if (CIRCUIT_IS_ORIGIN(circ) &&
  1727. !circ->marked_for_close &&
  1728. !circ->timestamp_dirty)
  1729. circuit_mark_for_close(circ, END_CIRC_REASON_FINISHED);
  1730. }
  1731. SMARTLIST_FOREACH_END(circ);
  1732. }
  1733. /** Go through the circuitlist; for each circuit that starts at us
  1734. * and is dirty, frob its timestamp_dirty so we won't use it for any
  1735. * new streams.
  1736. *
  1737. * This is useful for letting the user change pseudonyms, so new
  1738. * streams will not be linkable to old streams.
  1739. */
  1740. void
  1741. circuit_mark_all_dirty_circs_as_unusable(void)
  1742. {
  1743. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, circ) {
  1744. if (CIRCUIT_IS_ORIGIN(circ) &&
  1745. !circ->marked_for_close &&
  1746. circ->timestamp_dirty) {
  1747. mark_circuit_unusable_for_new_conns(TO_ORIGIN_CIRCUIT(circ));
  1748. }
  1749. }
  1750. SMARTLIST_FOREACH_END(circ);
  1751. }
  1752. /** Mark <b>circ</b> to be closed next time we call
  1753. * circuit_close_all_marked(). Do any cleanup needed:
  1754. * - If state is onionskin_pending, remove circ from the onion_pending
  1755. * list.
  1756. * - If circ isn't open yet: call circuit_build_failed() if we're
  1757. * the origin, and in either case call circuit_rep_hist_note_result()
  1758. * to note stats.
  1759. * - If purpose is C_INTRODUCE_ACK_WAIT, report the intro point
  1760. * failure we just had to the hidden service client module.
  1761. * - If purpose is C_INTRODUCING and <b>reason</b> isn't TIMEOUT,
  1762. * report to the hidden service client module that the intro point
  1763. * we just tried may be unreachable.
  1764. * - Send appropriate destroys and edge_destroys for conns and
  1765. * streams attached to circ.
  1766. * - If circ->rend_splice is set (we are the midpoint of a joined
  1767. * rendezvous stream), then mark the other circuit to close as well.
  1768. */
  1769. MOCK_IMPL(void,
  1770. circuit_mark_for_close_, (circuit_t *circ, int reason, int line,
  1771. const char *file))
  1772. {
  1773. int orig_reason = reason; /* Passed to the controller */
  1774. assert_circuit_ok(circ);
  1775. tor_assert(line);
  1776. tor_assert(file);
  1777. if (circ->marked_for_close) {
  1778. log_warn(LD_BUG,
  1779. "Duplicate call to circuit_mark_for_close at %s:%d"
  1780. " (first at %s:%d)", file, line,
  1781. circ->marked_for_close_file, circ->marked_for_close);
  1782. return;
  1783. }
  1784. if (reason == END_CIRC_AT_ORIGIN) {
  1785. if (!CIRCUIT_IS_ORIGIN(circ)) {
  1786. log_warn(LD_BUG, "Specified 'at-origin' non-reason for ending circuit, "
  1787. "but circuit was not at origin. (called %s:%d, purpose=%d)",
  1788. file, line, circ->purpose);
  1789. }
  1790. reason = END_CIRC_REASON_NONE;
  1791. }
  1792. if (CIRCUIT_IS_ORIGIN(circ)) {
  1793. if (pathbias_check_close(TO_ORIGIN_CIRCUIT(circ), reason) == -1) {
  1794. /* Don't close it yet, we need to test it first */
  1795. return;
  1796. }
  1797. /* We don't send reasons when closing circuits at the origin. */
  1798. reason = END_CIRC_REASON_NONE;
  1799. }
  1800. if (reason & END_CIRC_REASON_FLAG_REMOTE)
  1801. reason &= ~END_CIRC_REASON_FLAG_REMOTE;
  1802. if (reason < END_CIRC_REASON_MIN_ || reason > END_CIRC_REASON_MAX_) {
  1803. if (!(orig_reason & END_CIRC_REASON_FLAG_REMOTE))
  1804. log_warn(LD_BUG, "Reason %d out of range at %s:%d", reason, file, line);
  1805. reason = END_CIRC_REASON_NONE;
  1806. }
  1807. circ->marked_for_close = line;
  1808. circ->marked_for_close_file = file;
  1809. circ->marked_for_close_reason = reason;
  1810. circ->marked_for_close_orig_reason = orig_reason;
  1811. if (!CIRCUIT_IS_ORIGIN(circ)) {
  1812. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  1813. if (or_circ->rend_splice) {
  1814. if (!or_circ->rend_splice->base_.marked_for_close) {
  1815. /* do this after marking this circuit, to avoid infinite recursion. */
  1816. circuit_mark_for_close(TO_CIRCUIT(or_circ->rend_splice), reason);
  1817. }
  1818. or_circ->rend_splice = NULL;
  1819. }
  1820. }
  1821. /* Notify the HS subsystem that this circuit is closing. */
  1822. hs_circ_cleanup(circ);
  1823. if (circuits_pending_close == NULL)
  1824. circuits_pending_close = smartlist_new();
  1825. smartlist_add(circuits_pending_close, circ);
  1826. log_info(LD_GENERAL, "Circuit %u (id: %" PRIu32 ") marked for close at "
  1827. "%s:%d (orig reason: %d, new reason: %d)",
  1828. circ->n_circ_id,
  1829. CIRCUIT_IS_ORIGIN(circ) ?
  1830. TO_ORIGIN_CIRCUIT(circ)->global_identifier : 0,
  1831. file, line, orig_reason, reason);
  1832. }
  1833. /** Called immediately before freeing a marked circuit <b>circ</b> from
  1834. * circuit_free_all() while shutting down Tor; this is a safe-at-shutdown
  1835. * version of circuit_about_to_free(). It's important that it at least
  1836. * do circuitmux_detach_circuit() when appropriate.
  1837. */
  1838. static void
  1839. circuit_about_to_free_atexit(circuit_t *circ)
  1840. {
  1841. if (circ->n_chan) {
  1842. circuit_clear_cell_queue(circ, circ->n_chan);
  1843. circuitmux_detach_circuit(circ->n_chan->cmux, circ);
  1844. circuit_set_n_circid_chan(circ, 0, NULL);
  1845. }
  1846. if (! CIRCUIT_IS_ORIGIN(circ)) {
  1847. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  1848. if (or_circ->p_chan) {
  1849. circuit_clear_cell_queue(circ, or_circ->p_chan);
  1850. circuitmux_detach_circuit(or_circ->p_chan->cmux, circ);
  1851. circuit_set_p_circid_chan(or_circ, 0, NULL);
  1852. }
  1853. }
  1854. }
  1855. /** Called immediately before freeing a marked circuit <b>circ</b>.
  1856. * Disconnects the circuit from other data structures, launches events
  1857. * as appropriate, and performs other housekeeping.
  1858. */
  1859. static void
  1860. circuit_about_to_free(circuit_t *circ)
  1861. {
  1862. int reason = circ->marked_for_close_reason;
  1863. int orig_reason = circ->marked_for_close_orig_reason;
  1864. if (circ->state == CIRCUIT_STATE_ONIONSKIN_PENDING) {
  1865. onion_pending_remove(TO_OR_CIRCUIT(circ));
  1866. }
  1867. /* If the circuit ever became OPEN, we sent it to the reputation history
  1868. * module then. If it isn't OPEN, we send it there now to remember which
  1869. * links worked and which didn't.
  1870. */
  1871. if (circ->state != CIRCUIT_STATE_OPEN &&
  1872. circ->state != CIRCUIT_STATE_GUARD_WAIT) {
  1873. if (CIRCUIT_IS_ORIGIN(circ)) {
  1874. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  1875. circuit_build_failed(ocirc); /* take actions if necessary */
  1876. circuit_rep_hist_note_result(ocirc);
  1877. }
  1878. }
  1879. if (circ->state == CIRCUIT_STATE_CHAN_WAIT) {
  1880. if (circuits_pending_chans)
  1881. smartlist_remove(circuits_pending_chans, circ);
  1882. }
  1883. if (circuits_pending_other_guards) {
  1884. smartlist_remove(circuits_pending_other_guards, circ);
  1885. }
  1886. if (CIRCUIT_IS_ORIGIN(circ)) {
  1887. control_event_circuit_status(TO_ORIGIN_CIRCUIT(circ),
  1888. (circ->state == CIRCUIT_STATE_OPEN ||
  1889. circ->state == CIRCUIT_STATE_GUARD_WAIT) ?
  1890. CIRC_EVENT_CLOSED:CIRC_EVENT_FAILED,
  1891. orig_reason);
  1892. }
  1893. if (circ->purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT) {
  1894. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  1895. int timed_out = (reason == END_CIRC_REASON_TIMEOUT);
  1896. tor_assert(circ->state == CIRCUIT_STATE_OPEN);
  1897. tor_assert(ocirc->build_state->chosen_exit);
  1898. if (orig_reason != END_CIRC_REASON_IP_NOW_REDUNDANT &&
  1899. ocirc->rend_data) {
  1900. /* treat this like getting a nack from it */
  1901. log_info(LD_REND, "Failed intro circ %s to %s (awaiting ack). %s",
  1902. safe_str_client(rend_data_get_address(ocirc->rend_data)),
  1903. safe_str_client(build_state_get_exit_nickname(ocirc->build_state)),
  1904. timed_out ? "Recording timeout." : "Removing from descriptor.");
  1905. rend_client_report_intro_point_failure(ocirc->build_state->chosen_exit,
  1906. ocirc->rend_data,
  1907. timed_out ?
  1908. INTRO_POINT_FAILURE_TIMEOUT :
  1909. INTRO_POINT_FAILURE_GENERIC);
  1910. }
  1911. } else if (circ->purpose == CIRCUIT_PURPOSE_C_INTRODUCING &&
  1912. reason != END_CIRC_REASON_TIMEOUT) {
  1913. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  1914. if (ocirc->build_state->chosen_exit && ocirc->rend_data) {
  1915. if (orig_reason != END_CIRC_REASON_IP_NOW_REDUNDANT &&
  1916. ocirc->rend_data) {
  1917. log_info(LD_REND, "Failed intro circ %s to %s "
  1918. "(building circuit to intro point). "
  1919. "Marking intro point as possibly unreachable.",
  1920. safe_str_client(rend_data_get_address(ocirc->rend_data)),
  1921. safe_str_client(build_state_get_exit_nickname(
  1922. ocirc->build_state)));
  1923. rend_client_report_intro_point_failure(ocirc->build_state->chosen_exit,
  1924. ocirc->rend_data,
  1925. INTRO_POINT_FAILURE_UNREACHABLE);
  1926. }
  1927. }
  1928. }
  1929. if (circ->n_chan) {
  1930. circuit_clear_cell_queue(circ, circ->n_chan);
  1931. /* Only send destroy if the channel isn't closing anyway */
  1932. if (!CHANNEL_CONDEMNED(circ->n_chan)) {
  1933. channel_send_destroy(circ->n_circ_id, circ->n_chan, reason);
  1934. }
  1935. circuitmux_detach_circuit(circ->n_chan->cmux, circ);
  1936. circuit_set_n_circid_chan(circ, 0, NULL);
  1937. }
  1938. if (! CIRCUIT_IS_ORIGIN(circ)) {
  1939. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  1940. edge_connection_t *conn;
  1941. for (conn=or_circ->n_streams; conn; conn=conn->next_stream)
  1942. connection_edge_destroy(or_circ->p_circ_id, conn);
  1943. or_circ->n_streams = NULL;
  1944. while (or_circ->resolving_streams) {
  1945. conn = or_circ->resolving_streams;
  1946. or_circ->resolving_streams = conn->next_stream;
  1947. if (!conn->base_.marked_for_close) {
  1948. /* The client will see a DESTROY, and infer that the connections
  1949. * are closing because the circuit is getting torn down. No need
  1950. * to send an end cell. */
  1951. conn->edge_has_sent_end = 1;
  1952. conn->end_reason = END_STREAM_REASON_DESTROY;
  1953. conn->end_reason |= END_STREAM_REASON_FLAG_ALREADY_SENT_CLOSED;
  1954. connection_mark_for_close(TO_CONN(conn));
  1955. }
  1956. conn->on_circuit = NULL;
  1957. }
  1958. if (or_circ->p_chan) {
  1959. circuit_clear_cell_queue(circ, or_circ->p_chan);
  1960. /* Only send destroy if the channel isn't closing anyway */
  1961. if (!CHANNEL_CONDEMNED(or_circ->p_chan)) {
  1962. channel_send_destroy(or_circ->p_circ_id, or_circ->p_chan, reason);
  1963. }
  1964. circuitmux_detach_circuit(or_circ->p_chan->cmux, circ);
  1965. circuit_set_p_circid_chan(or_circ, 0, NULL);
  1966. }
  1967. } else {
  1968. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  1969. edge_connection_t *conn;
  1970. for (conn=ocirc->p_streams; conn; conn=conn->next_stream)
  1971. connection_edge_destroy(circ->n_circ_id, conn);
  1972. ocirc->p_streams = NULL;
  1973. }
  1974. }
  1975. /** Given a marked circuit <b>circ</b>, aggressively free its cell queues to
  1976. * recover memory. */
  1977. static void
  1978. marked_circuit_free_cells(circuit_t *circ)
  1979. {
  1980. if (!circ->marked_for_close) {
  1981. log_warn(LD_BUG, "Called on non-marked circuit");
  1982. return;
  1983. }
  1984. cell_queue_clear(&circ->n_chan_cells);
  1985. if (circ->n_mux)
  1986. circuitmux_clear_num_cells(circ->n_mux, circ);
  1987. if (! CIRCUIT_IS_ORIGIN(circ)) {
  1988. or_circuit_t *orcirc = TO_OR_CIRCUIT(circ);
  1989. cell_queue_clear(&orcirc->p_chan_cells);
  1990. if (orcirc->p_mux)
  1991. circuitmux_clear_num_cells(orcirc->p_mux, circ);
  1992. }
  1993. }
  1994. static size_t
  1995. single_conn_free_bytes(connection_t *conn)
  1996. {
  1997. size_t result = 0;
  1998. if (conn->inbuf) {
  1999. result += buf_allocation(conn->inbuf);
  2000. buf_clear(conn->inbuf);
  2001. }
  2002. if (conn->outbuf) {
  2003. result += buf_allocation(conn->outbuf);
  2004. buf_clear(conn->outbuf);
  2005. conn->outbuf_flushlen = 0;
  2006. }
  2007. if (conn->type == CONN_TYPE_DIR) {
  2008. dir_connection_t *dir_conn = TO_DIR_CONN(conn);
  2009. if (dir_conn->compress_state) {
  2010. result += tor_compress_state_size(dir_conn->compress_state);
  2011. tor_compress_free(dir_conn->compress_state);
  2012. dir_conn->compress_state = NULL;
  2013. }
  2014. }
  2015. return result;
  2016. }
  2017. /** Aggressively free buffer contents on all the buffers of all streams in the
  2018. * list starting at <b>stream</b>. Return the number of bytes recovered. */
  2019. static size_t
  2020. marked_circuit_streams_free_bytes(edge_connection_t *stream)
  2021. {
  2022. size_t result = 0;
  2023. for ( ; stream; stream = stream->next_stream) {
  2024. connection_t *conn = TO_CONN(stream);
  2025. result += single_conn_free_bytes(conn);
  2026. if (conn->linked_conn) {
  2027. result += single_conn_free_bytes(conn->linked_conn);
  2028. }
  2029. }
  2030. return result;
  2031. }
  2032. /** Aggressively free buffer contents on all the buffers of all streams on
  2033. * circuit <b>c</b>. Return the number of bytes recovered. */
  2034. static size_t
  2035. marked_circuit_free_stream_bytes(circuit_t *c)
  2036. {
  2037. if (CIRCUIT_IS_ORIGIN(c)) {
  2038. return marked_circuit_streams_free_bytes(TO_ORIGIN_CIRCUIT(c)->p_streams);
  2039. } else {
  2040. return marked_circuit_streams_free_bytes(TO_OR_CIRCUIT(c)->n_streams);
  2041. }
  2042. }
  2043. /** Return the number of cells used by the circuit <b>c</b>'s cell queues. */
  2044. STATIC size_t
  2045. n_cells_in_circ_queues(const circuit_t *c)
  2046. {
  2047. size_t n = c->n_chan_cells.n;
  2048. if (! CIRCUIT_IS_ORIGIN(c)) {
  2049. circuit_t *cc = (circuit_t *) c;
  2050. n += TO_OR_CIRCUIT(cc)->p_chan_cells.n;
  2051. }
  2052. return n;
  2053. }
  2054. /**
  2055. * Return the age of the oldest cell queued on <b>c</b>, in timestamp units.
  2056. * Return 0 if there are no cells queued on c. Requires that <b>now</b> be
  2057. * the current coarse timestamp.
  2058. *
  2059. * This function will return incorrect results if the oldest cell queued on
  2060. * the circuit is older than about 2**32 msec (about 49 days) old.
  2061. */
  2062. STATIC uint32_t
  2063. circuit_max_queued_cell_age(const circuit_t *c, uint32_t now)
  2064. {
  2065. uint32_t age = 0;
  2066. packed_cell_t *cell;
  2067. if (NULL != (cell = TOR_SIMPLEQ_FIRST(&c->n_chan_cells.head)))
  2068. age = now - cell->inserted_timestamp;
  2069. if (! CIRCUIT_IS_ORIGIN(c)) {
  2070. const or_circuit_t *orcirc = CONST_TO_OR_CIRCUIT(c);
  2071. if (NULL != (cell = TOR_SIMPLEQ_FIRST(&orcirc->p_chan_cells.head))) {
  2072. uint32_t age2 = now - cell->inserted_timestamp;
  2073. if (age2 > age)
  2074. return age2;
  2075. }
  2076. }
  2077. return age;
  2078. }
  2079. /** Return the age of the oldest buffer chunk on <b>conn</b>, where age is
  2080. * taken in timestamp units before the time <b>now</b>. If the connection has
  2081. * no data, treat it as having age zero.
  2082. **/
  2083. static uint32_t
  2084. conn_get_buffer_age(const connection_t *conn, uint32_t now_ts)
  2085. {
  2086. uint32_t age = 0, age2;
  2087. if (conn->outbuf) {
  2088. age2 = buf_get_oldest_chunk_timestamp(conn->outbuf, now_ts);
  2089. if (age2 > age)
  2090. age = age2;
  2091. }
  2092. if (conn->inbuf) {
  2093. age2 = buf_get_oldest_chunk_timestamp(conn->inbuf, now_ts);
  2094. if (age2 > age)
  2095. age = age2;
  2096. }
  2097. return age;
  2098. }
  2099. /** Return the age in timestamp units of the oldest buffer chunk on any stream
  2100. * in the linked list <b>stream</b>, where age is taken in timestamp units
  2101. * before the timestamp <b>now</b>. */
  2102. static uint32_t
  2103. circuit_get_streams_max_data_age(const edge_connection_t *stream, uint32_t now)
  2104. {
  2105. uint32_t age = 0, age2;
  2106. for (; stream; stream = stream->next_stream) {
  2107. const connection_t *conn = TO_CONN(stream);
  2108. age2 = conn_get_buffer_age(conn, now);
  2109. if (age2 > age)
  2110. age = age2;
  2111. if (conn->linked_conn) {
  2112. age2 = conn_get_buffer_age(conn->linked_conn, now);
  2113. if (age2 > age)
  2114. age = age2;
  2115. }
  2116. }
  2117. return age;
  2118. }
  2119. /** Return the age in timestamp units of the oldest buffer chunk on any stream
  2120. * attached to the circuit <b>c</b>, where age is taken before the timestamp
  2121. * <b>now</b>. */
  2122. STATIC uint32_t
  2123. circuit_max_queued_data_age(const circuit_t *c, uint32_t now)
  2124. {
  2125. if (CIRCUIT_IS_ORIGIN(c)) {
  2126. return circuit_get_streams_max_data_age(
  2127. CONST_TO_ORIGIN_CIRCUIT(c)->p_streams, now);
  2128. } else {
  2129. return circuit_get_streams_max_data_age(
  2130. CONST_TO_OR_CIRCUIT(c)->n_streams, now);
  2131. }
  2132. }
  2133. /** Return the age of the oldest cell or stream buffer chunk on the circuit
  2134. * <b>c</b>, where age is taken in timestamp units before the timestamp
  2135. * <b>now</b> */
  2136. STATIC uint32_t
  2137. circuit_max_queued_item_age(const circuit_t *c, uint32_t now)
  2138. {
  2139. uint32_t cell_age = circuit_max_queued_cell_age(c, now);
  2140. uint32_t data_age = circuit_max_queued_data_age(c, now);
  2141. if (cell_age > data_age)
  2142. return cell_age;
  2143. else
  2144. return data_age;
  2145. }
  2146. /** Helper to sort a list of circuit_t by age of oldest item, in descending
  2147. * order. */
  2148. static int
  2149. circuits_compare_by_oldest_queued_item_(const void **a_, const void **b_)
  2150. {
  2151. const circuit_t *a = *a_;
  2152. const circuit_t *b = *b_;
  2153. uint32_t age_a = a->age_tmp;
  2154. uint32_t age_b = b->age_tmp;
  2155. if (age_a < age_b)
  2156. return 1;
  2157. else if (age_a == age_b)
  2158. return 0;
  2159. else
  2160. return -1;
  2161. }
  2162. static uint32_t now_ts_for_buf_cmp;
  2163. /** Helper to sort a list of circuit_t by age of oldest item, in descending
  2164. * order. */
  2165. static int
  2166. conns_compare_by_buffer_age_(const void **a_, const void **b_)
  2167. {
  2168. const connection_t *a = *a_;
  2169. const connection_t *b = *b_;
  2170. time_t age_a = conn_get_buffer_age(a, now_ts_for_buf_cmp);
  2171. time_t age_b = conn_get_buffer_age(b, now_ts_for_buf_cmp);
  2172. if (age_a < age_b)
  2173. return 1;
  2174. else if (age_a == age_b)
  2175. return 0;
  2176. else
  2177. return -1;
  2178. }
  2179. #define FRACTION_OF_DATA_TO_RETAIN_ON_OOM 0.90
  2180. /** We're out of memory for cells, having allocated <b>current_allocation</b>
  2181. * bytes' worth. Kill the 'worst' circuits until we're under
  2182. * FRACTION_OF_DATA_TO_RETAIN_ON_OOM of our maximum usage. */
  2183. void
  2184. circuits_handle_oom(size_t current_allocation)
  2185. {
  2186. smartlist_t *circlist;
  2187. smartlist_t *connection_array = get_connection_array();
  2188. int conn_idx;
  2189. size_t mem_to_recover;
  2190. size_t mem_recovered=0;
  2191. int n_circuits_killed=0;
  2192. int n_dirconns_killed=0;
  2193. uint32_t now_ts;
  2194. log_notice(LD_GENERAL, "We're low on memory (cell queues total alloc:"
  2195. " %"TOR_PRIuSZ" buffer total alloc: %" TOR_PRIuSZ ","
  2196. " tor compress total alloc: %" TOR_PRIuSZ
  2197. " rendezvous cache total alloc: %" TOR_PRIuSZ "). Killing"
  2198. " circuits withover-long queues. (This behavior is controlled by"
  2199. " MaxMemInQueues.)",
  2200. cell_queues_get_total_allocation(),
  2201. buf_get_total_allocation(),
  2202. tor_compress_get_total_allocation(),
  2203. rend_cache_get_total_allocation());
  2204. {
  2205. size_t mem_target = (size_t)(get_options()->MaxMemInQueues *
  2206. FRACTION_OF_DATA_TO_RETAIN_ON_OOM);
  2207. if (current_allocation <= mem_target)
  2208. return;
  2209. mem_to_recover = current_allocation - mem_target;
  2210. }
  2211. now_ts = monotime_coarse_get_stamp();
  2212. circlist = circuit_get_global_list();
  2213. SMARTLIST_FOREACH_BEGIN(circlist, circuit_t *, circ) {
  2214. circ->age_tmp = circuit_max_queued_item_age(circ, now_ts);
  2215. } SMARTLIST_FOREACH_END(circ);
  2216. /* This is O(n log n); there are faster algorithms we could use instead.
  2217. * Let's hope this doesn't happen enough to be in the critical path. */
  2218. smartlist_sort(circlist, circuits_compare_by_oldest_queued_item_);
  2219. /* Fix up the indices before we run into trouble */
  2220. SMARTLIST_FOREACH_BEGIN(circlist, circuit_t *, circ) {
  2221. circ->global_circuitlist_idx = circ_sl_idx;
  2222. } SMARTLIST_FOREACH_END(circ);
  2223. /* Now sort the connection array ... */
  2224. now_ts_for_buf_cmp = now_ts;
  2225. smartlist_sort(connection_array, conns_compare_by_buffer_age_);
  2226. now_ts_for_buf_cmp = 0;
  2227. /* Fix up the connection array to its new order. */
  2228. SMARTLIST_FOREACH_BEGIN(connection_array, connection_t *, conn) {
  2229. conn->conn_array_index = conn_sl_idx;
  2230. } SMARTLIST_FOREACH_END(conn);
  2231. /* Okay, now the worst circuits and connections are at the front of their
  2232. * respective lists. Let's mark them, and reclaim their storage
  2233. * aggressively. */
  2234. conn_idx = 0;
  2235. SMARTLIST_FOREACH_BEGIN(circlist, circuit_t *, circ) {
  2236. size_t n;
  2237. size_t freed;
  2238. /* Free storage in any non-linked directory connections that have buffered
  2239. * data older than this circuit. */
  2240. while (conn_idx < smartlist_len(connection_array)) {
  2241. connection_t *conn = smartlist_get(connection_array, conn_idx);
  2242. uint32_t conn_age = conn_get_buffer_age(conn, now_ts);
  2243. if (conn_age < circ->age_tmp) {
  2244. break;
  2245. }
  2246. if (conn->type == CONN_TYPE_DIR && conn->linked_conn == NULL) {
  2247. if (!conn->marked_for_close)
  2248. connection_mark_for_close(conn);
  2249. mem_recovered += single_conn_free_bytes(conn);
  2250. ++n_dirconns_killed;
  2251. if (mem_recovered >= mem_to_recover)
  2252. goto done_recovering_mem;
  2253. }
  2254. ++conn_idx;
  2255. }
  2256. /* Now, kill the circuit. */
  2257. n = n_cells_in_circ_queues(circ);
  2258. if (! circ->marked_for_close) {
  2259. circuit_mark_for_close(circ, END_CIRC_REASON_RESOURCELIMIT);
  2260. }
  2261. marked_circuit_free_cells(circ);
  2262. freed = marked_circuit_free_stream_bytes(circ);
  2263. ++n_circuits_killed;
  2264. mem_recovered += n * packed_cell_mem_cost();
  2265. mem_recovered += freed;
  2266. if (mem_recovered >= mem_to_recover)
  2267. goto done_recovering_mem;
  2268. } SMARTLIST_FOREACH_END(circ);
  2269. done_recovering_mem:
  2270. log_notice(LD_GENERAL, "Removed "U64_FORMAT" bytes by killing %d circuits; "
  2271. "%d circuits remain alive. Also killed %d non-linked directory "
  2272. "connections.",
  2273. U64_PRINTF_ARG(mem_recovered),
  2274. n_circuits_killed,
  2275. smartlist_len(circlist) - n_circuits_killed,
  2276. n_dirconns_killed);
  2277. }
  2278. /** Verify that cpath layer <b>cp</b> has all of its invariants
  2279. * correct. Trigger an assert if anything is invalid.
  2280. */
  2281. void
  2282. assert_cpath_layer_ok(const crypt_path_t *cp)
  2283. {
  2284. // tor_assert(cp->addr); /* these are zero for rendezvous extra-hops */
  2285. // tor_assert(cp->port);
  2286. tor_assert(cp);
  2287. tor_assert(cp->magic == CRYPT_PATH_MAGIC);
  2288. switch (cp->state)
  2289. {
  2290. case CPATH_STATE_OPEN:
  2291. tor_assert(cp->f_crypto);
  2292. tor_assert(cp->b_crypto);
  2293. /* fall through */
  2294. case CPATH_STATE_CLOSED:
  2295. /*XXXX Assert that there's no handshake_state either. */
  2296. tor_assert(!cp->rend_dh_handshake_state);
  2297. break;
  2298. case CPATH_STATE_AWAITING_KEYS:
  2299. /* tor_assert(cp->dh_handshake_state); */
  2300. break;
  2301. default:
  2302. log_fn(LOG_ERR, LD_BUG, "Unexpected state %d", cp->state);
  2303. tor_assert(0);
  2304. }
  2305. tor_assert(cp->package_window >= 0);
  2306. tor_assert(cp->deliver_window >= 0);
  2307. }
  2308. /** Verify that cpath <b>cp</b> has all of its invariants
  2309. * correct. Trigger an assert if anything is invalid.
  2310. */
  2311. static void
  2312. assert_cpath_ok(const crypt_path_t *cp)
  2313. {
  2314. const crypt_path_t *start = cp;
  2315. do {
  2316. assert_cpath_layer_ok(cp);
  2317. /* layers must be in sequence of: "open* awaiting? closed*" */
  2318. if (cp != start) {
  2319. if (cp->state == CPATH_STATE_AWAITING_KEYS) {
  2320. tor_assert(cp->prev->state == CPATH_STATE_OPEN);
  2321. } else if (cp->state == CPATH_STATE_OPEN) {
  2322. tor_assert(cp->prev->state == CPATH_STATE_OPEN);
  2323. }
  2324. }
  2325. cp = cp->next;
  2326. tor_assert(cp);
  2327. } while (cp != start);
  2328. }
  2329. /** Verify that circuit <b>c</b> has all of its invariants
  2330. * correct. Trigger an assert if anything is invalid.
  2331. */
  2332. MOCK_IMPL(void,
  2333. assert_circuit_ok,(const circuit_t *c))
  2334. {
  2335. edge_connection_t *conn;
  2336. const or_circuit_t *or_circ = NULL;
  2337. const origin_circuit_t *origin_circ = NULL;
  2338. tor_assert(c);
  2339. tor_assert(c->magic == ORIGIN_CIRCUIT_MAGIC || c->magic == OR_CIRCUIT_MAGIC);
  2340. tor_assert(c->purpose >= CIRCUIT_PURPOSE_MIN_ &&
  2341. c->purpose <= CIRCUIT_PURPOSE_MAX_);
  2342. if (CIRCUIT_IS_ORIGIN(c))
  2343. origin_circ = CONST_TO_ORIGIN_CIRCUIT(c);
  2344. else
  2345. or_circ = CONST_TO_OR_CIRCUIT(c);
  2346. if (c->n_chan) {
  2347. tor_assert(!c->n_hop);
  2348. if (c->n_circ_id) {
  2349. /* We use the _impl variant here to make sure we don't fail on marked
  2350. * circuits, which would not be returned by the regular function. */
  2351. circuit_t *c2 = circuit_get_by_circid_channel_impl(c->n_circ_id,
  2352. c->n_chan, NULL);
  2353. tor_assert(c == c2);
  2354. }
  2355. }
  2356. if (or_circ && or_circ->p_chan) {
  2357. if (or_circ->p_circ_id) {
  2358. /* ibid */
  2359. circuit_t *c2 =
  2360. circuit_get_by_circid_channel_impl(or_circ->p_circ_id,
  2361. or_circ->p_chan, NULL);
  2362. tor_assert(c == c2);
  2363. }
  2364. }
  2365. if (or_circ)
  2366. for (conn = or_circ->n_streams; conn; conn = conn->next_stream)
  2367. tor_assert(conn->base_.type == CONN_TYPE_EXIT);
  2368. tor_assert(c->deliver_window >= 0);
  2369. tor_assert(c->package_window >= 0);
  2370. if (c->state == CIRCUIT_STATE_OPEN ||
  2371. c->state == CIRCUIT_STATE_GUARD_WAIT) {
  2372. tor_assert(!c->n_chan_create_cell);
  2373. if (or_circ) {
  2374. tor_assert(or_circ->n_crypto);
  2375. tor_assert(or_circ->p_crypto);
  2376. tor_assert(or_circ->n_digest);
  2377. tor_assert(or_circ->p_digest);
  2378. }
  2379. }
  2380. if (c->state == CIRCUIT_STATE_CHAN_WAIT && !c->marked_for_close) {
  2381. tor_assert(circuits_pending_chans &&
  2382. smartlist_contains(circuits_pending_chans, c));
  2383. } else {
  2384. tor_assert(!circuits_pending_chans ||
  2385. !smartlist_contains(circuits_pending_chans, c));
  2386. }
  2387. if (origin_circ && origin_circ->cpath) {
  2388. assert_cpath_ok(origin_circ->cpath);
  2389. }
  2390. if (c->purpose == CIRCUIT_PURPOSE_REND_ESTABLISHED) {
  2391. tor_assert(or_circ);
  2392. if (!c->marked_for_close) {
  2393. tor_assert(or_circ->rend_splice);
  2394. tor_assert(or_circ->rend_splice->rend_splice == or_circ);
  2395. }
  2396. tor_assert(or_circ->rend_splice != or_circ);
  2397. } else {
  2398. tor_assert(!or_circ || !or_circ->rend_splice);
  2399. }
  2400. }