circuitlist.c 87 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699
  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.
  1758. * - If purpose is C_INTRODUCE_ACK_WAIT, report the intro point
  1759. * failure we just had to the hidden service client module.
  1760. * - If purpose is C_INTRODUCING and <b>reason</b> isn't TIMEOUT,
  1761. * report to the hidden service client module that the intro point
  1762. * we just tried may be unreachable.
  1763. * - Send appropriate destroys and edge_destroys for conns and
  1764. * streams attached to circ.
  1765. * - If circ->rend_splice is set (we are the midpoint of a joined
  1766. * rendezvous stream), then mark the other circuit to close as well.
  1767. */
  1768. MOCK_IMPL(void,
  1769. circuit_mark_for_close_, (circuit_t *circ, int reason, int line,
  1770. const char *file))
  1771. {
  1772. int orig_reason = reason; /* Passed to the controller */
  1773. assert_circuit_ok(circ);
  1774. tor_assert(line);
  1775. tor_assert(file);
  1776. if (circ->marked_for_close) {
  1777. log_warn(LD_BUG,
  1778. "Duplicate call to circuit_mark_for_close at %s:%d"
  1779. " (first at %s:%d)", file, line,
  1780. circ->marked_for_close_file, circ->marked_for_close);
  1781. return;
  1782. }
  1783. if (reason == END_CIRC_AT_ORIGIN) {
  1784. if (!CIRCUIT_IS_ORIGIN(circ)) {
  1785. log_warn(LD_BUG, "Specified 'at-origin' non-reason for ending circuit, "
  1786. "but circuit was not at origin. (called %s:%d, purpose=%d)",
  1787. file, line, circ->purpose);
  1788. }
  1789. reason = END_CIRC_REASON_NONE;
  1790. }
  1791. if (CIRCUIT_IS_ORIGIN(circ)) {
  1792. if (pathbias_check_close(TO_ORIGIN_CIRCUIT(circ), reason) == -1) {
  1793. /* Don't close it yet, we need to test it first */
  1794. return;
  1795. }
  1796. /* We don't send reasons when closing circuits at the origin. */
  1797. reason = END_CIRC_REASON_NONE;
  1798. }
  1799. if (reason & END_CIRC_REASON_FLAG_REMOTE)
  1800. reason &= ~END_CIRC_REASON_FLAG_REMOTE;
  1801. if (reason < END_CIRC_REASON_MIN_ || reason > END_CIRC_REASON_MAX_) {
  1802. if (!(orig_reason & END_CIRC_REASON_FLAG_REMOTE))
  1803. log_warn(LD_BUG, "Reason %d out of range at %s:%d", reason, file, line);
  1804. reason = END_CIRC_REASON_NONE;
  1805. }
  1806. circ->marked_for_close = line;
  1807. circ->marked_for_close_file = file;
  1808. circ->marked_for_close_reason = reason;
  1809. circ->marked_for_close_orig_reason = orig_reason;
  1810. if (!CIRCUIT_IS_ORIGIN(circ)) {
  1811. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  1812. if (or_circ->rend_splice) {
  1813. if (!or_circ->rend_splice->base_.marked_for_close) {
  1814. /* do this after marking this circuit, to avoid infinite recursion. */
  1815. circuit_mark_for_close(TO_CIRCUIT(or_circ->rend_splice), reason);
  1816. }
  1817. or_circ->rend_splice = NULL;
  1818. }
  1819. }
  1820. /* Notify the HS subsystem that this circuit is closing. */
  1821. hs_circ_cleanup(circ);
  1822. if (circuits_pending_close == NULL)
  1823. circuits_pending_close = smartlist_new();
  1824. smartlist_add(circuits_pending_close, circ);
  1825. log_info(LD_GENERAL, "Circuit %u (id: %" PRIu32 ") marked for close at "
  1826. "%s:%d (orig reason: %d, new reason: %d)",
  1827. circ->n_circ_id,
  1828. CIRCUIT_IS_ORIGIN(circ) ?
  1829. TO_ORIGIN_CIRCUIT(circ)->global_identifier : 0,
  1830. file, line, orig_reason, reason);
  1831. }
  1832. /** Called immediately before freeing a marked circuit <b>circ</b> from
  1833. * circuit_free_all() while shutting down Tor; this is a safe-at-shutdown
  1834. * version of circuit_about_to_free(). It's important that it at least
  1835. * do circuitmux_detach_circuit() when appropriate.
  1836. */
  1837. static void
  1838. circuit_about_to_free_atexit(circuit_t *circ)
  1839. {
  1840. if (circ->n_chan) {
  1841. circuit_clear_cell_queue(circ, circ->n_chan);
  1842. circuitmux_detach_circuit(circ->n_chan->cmux, circ);
  1843. circuit_set_n_circid_chan(circ, 0, NULL);
  1844. }
  1845. if (! CIRCUIT_IS_ORIGIN(circ)) {
  1846. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  1847. if (or_circ->p_chan) {
  1848. circuit_clear_cell_queue(circ, or_circ->p_chan);
  1849. circuitmux_detach_circuit(or_circ->p_chan->cmux, circ);
  1850. circuit_set_p_circid_chan(or_circ, 0, NULL);
  1851. }
  1852. }
  1853. }
  1854. /** Called immediately before freeing a marked circuit <b>circ</b>.
  1855. * Disconnects the circuit from other data structures, launches events
  1856. * as appropriate, and performs other housekeeping.
  1857. */
  1858. static void
  1859. circuit_about_to_free(circuit_t *circ)
  1860. {
  1861. int reason = circ->marked_for_close_reason;
  1862. int orig_reason = circ->marked_for_close_orig_reason;
  1863. if (circ->state == CIRCUIT_STATE_ONIONSKIN_PENDING) {
  1864. onion_pending_remove(TO_OR_CIRCUIT(circ));
  1865. }
  1866. /* If the circuit ever became OPEN, we sent it to the reputation history
  1867. * module then. If it isn't OPEN, we send it there now to remember which
  1868. * links worked and which didn't.
  1869. */
  1870. if (circ->state != CIRCUIT_STATE_OPEN &&
  1871. circ->state != CIRCUIT_STATE_GUARD_WAIT) {
  1872. if (CIRCUIT_IS_ORIGIN(circ)) {
  1873. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  1874. circuit_build_failed(ocirc); /* take actions if necessary */
  1875. }
  1876. }
  1877. if (circ->state == CIRCUIT_STATE_CHAN_WAIT) {
  1878. if (circuits_pending_chans)
  1879. smartlist_remove(circuits_pending_chans, circ);
  1880. }
  1881. if (circuits_pending_other_guards) {
  1882. smartlist_remove(circuits_pending_other_guards, circ);
  1883. }
  1884. if (CIRCUIT_IS_ORIGIN(circ)) {
  1885. control_event_circuit_status(TO_ORIGIN_CIRCUIT(circ),
  1886. (circ->state == CIRCUIT_STATE_OPEN ||
  1887. circ->state == CIRCUIT_STATE_GUARD_WAIT) ?
  1888. CIRC_EVENT_CLOSED:CIRC_EVENT_FAILED,
  1889. orig_reason);
  1890. }
  1891. if (circ->purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT) {
  1892. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  1893. int timed_out = (reason == END_CIRC_REASON_TIMEOUT);
  1894. tor_assert(circ->state == CIRCUIT_STATE_OPEN);
  1895. tor_assert(ocirc->build_state->chosen_exit);
  1896. if (orig_reason != END_CIRC_REASON_IP_NOW_REDUNDANT &&
  1897. ocirc->rend_data) {
  1898. /* treat this like getting a nack from it */
  1899. log_info(LD_REND, "Failed intro circ %s to %s (awaiting ack). %s",
  1900. safe_str_client(rend_data_get_address(ocirc->rend_data)),
  1901. safe_str_client(build_state_get_exit_nickname(ocirc->build_state)),
  1902. timed_out ? "Recording timeout." : "Removing from descriptor.");
  1903. rend_client_report_intro_point_failure(ocirc->build_state->chosen_exit,
  1904. ocirc->rend_data,
  1905. timed_out ?
  1906. INTRO_POINT_FAILURE_TIMEOUT :
  1907. INTRO_POINT_FAILURE_GENERIC);
  1908. }
  1909. } else if (circ->purpose == CIRCUIT_PURPOSE_C_INTRODUCING &&
  1910. reason != END_CIRC_REASON_TIMEOUT) {
  1911. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  1912. if (ocirc->build_state->chosen_exit && ocirc->rend_data) {
  1913. if (orig_reason != END_CIRC_REASON_IP_NOW_REDUNDANT &&
  1914. ocirc->rend_data) {
  1915. log_info(LD_REND, "Failed intro circ %s to %s "
  1916. "(building circuit to intro point). "
  1917. "Marking intro point as possibly unreachable.",
  1918. safe_str_client(rend_data_get_address(ocirc->rend_data)),
  1919. safe_str_client(build_state_get_exit_nickname(
  1920. ocirc->build_state)));
  1921. rend_client_report_intro_point_failure(ocirc->build_state->chosen_exit,
  1922. ocirc->rend_data,
  1923. INTRO_POINT_FAILURE_UNREACHABLE);
  1924. }
  1925. }
  1926. }
  1927. if (circ->n_chan) {
  1928. circuit_clear_cell_queue(circ, circ->n_chan);
  1929. /* Only send destroy if the channel isn't closing anyway */
  1930. if (!CHANNEL_CONDEMNED(circ->n_chan)) {
  1931. channel_send_destroy(circ->n_circ_id, circ->n_chan, reason);
  1932. }
  1933. circuitmux_detach_circuit(circ->n_chan->cmux, circ);
  1934. circuit_set_n_circid_chan(circ, 0, NULL);
  1935. }
  1936. if (! CIRCUIT_IS_ORIGIN(circ)) {
  1937. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  1938. edge_connection_t *conn;
  1939. for (conn=or_circ->n_streams; conn; conn=conn->next_stream)
  1940. connection_edge_destroy(or_circ->p_circ_id, conn);
  1941. or_circ->n_streams = NULL;
  1942. while (or_circ->resolving_streams) {
  1943. conn = or_circ->resolving_streams;
  1944. or_circ->resolving_streams = conn->next_stream;
  1945. if (!conn->base_.marked_for_close) {
  1946. /* The client will see a DESTROY, and infer that the connections
  1947. * are closing because the circuit is getting torn down. No need
  1948. * to send an end cell. */
  1949. conn->edge_has_sent_end = 1;
  1950. conn->end_reason = END_STREAM_REASON_DESTROY;
  1951. conn->end_reason |= END_STREAM_REASON_FLAG_ALREADY_SENT_CLOSED;
  1952. connection_mark_for_close(TO_CONN(conn));
  1953. }
  1954. conn->on_circuit = NULL;
  1955. }
  1956. if (or_circ->p_chan) {
  1957. circuit_clear_cell_queue(circ, or_circ->p_chan);
  1958. /* Only send destroy if the channel isn't closing anyway */
  1959. if (!CHANNEL_CONDEMNED(or_circ->p_chan)) {
  1960. channel_send_destroy(or_circ->p_circ_id, or_circ->p_chan, reason);
  1961. }
  1962. circuitmux_detach_circuit(or_circ->p_chan->cmux, circ);
  1963. circuit_set_p_circid_chan(or_circ, 0, NULL);
  1964. }
  1965. } else {
  1966. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  1967. edge_connection_t *conn;
  1968. for (conn=ocirc->p_streams; conn; conn=conn->next_stream)
  1969. connection_edge_destroy(circ->n_circ_id, conn);
  1970. ocirc->p_streams = NULL;
  1971. }
  1972. }
  1973. /** Given a marked circuit <b>circ</b>, aggressively free its cell queues to
  1974. * recover memory. */
  1975. static void
  1976. marked_circuit_free_cells(circuit_t *circ)
  1977. {
  1978. if (!circ->marked_for_close) {
  1979. log_warn(LD_BUG, "Called on non-marked circuit");
  1980. return;
  1981. }
  1982. cell_queue_clear(&circ->n_chan_cells);
  1983. if (circ->n_mux)
  1984. circuitmux_clear_num_cells(circ->n_mux, circ);
  1985. if (! CIRCUIT_IS_ORIGIN(circ)) {
  1986. or_circuit_t *orcirc = TO_OR_CIRCUIT(circ);
  1987. cell_queue_clear(&orcirc->p_chan_cells);
  1988. if (orcirc->p_mux)
  1989. circuitmux_clear_num_cells(orcirc->p_mux, circ);
  1990. }
  1991. }
  1992. static size_t
  1993. single_conn_free_bytes(connection_t *conn)
  1994. {
  1995. size_t result = 0;
  1996. if (conn->inbuf) {
  1997. result += buf_allocation(conn->inbuf);
  1998. buf_clear(conn->inbuf);
  1999. }
  2000. if (conn->outbuf) {
  2001. result += buf_allocation(conn->outbuf);
  2002. buf_clear(conn->outbuf);
  2003. conn->outbuf_flushlen = 0;
  2004. }
  2005. if (conn->type == CONN_TYPE_DIR) {
  2006. dir_connection_t *dir_conn = TO_DIR_CONN(conn);
  2007. if (dir_conn->compress_state) {
  2008. result += tor_compress_state_size(dir_conn->compress_state);
  2009. tor_compress_free(dir_conn->compress_state);
  2010. dir_conn->compress_state = NULL;
  2011. }
  2012. }
  2013. return result;
  2014. }
  2015. /** Aggressively free buffer contents on all the buffers of all streams in the
  2016. * list starting at <b>stream</b>. Return the number of bytes recovered. */
  2017. static size_t
  2018. marked_circuit_streams_free_bytes(edge_connection_t *stream)
  2019. {
  2020. size_t result = 0;
  2021. for ( ; stream; stream = stream->next_stream) {
  2022. connection_t *conn = TO_CONN(stream);
  2023. result += single_conn_free_bytes(conn);
  2024. if (conn->linked_conn) {
  2025. result += single_conn_free_bytes(conn->linked_conn);
  2026. }
  2027. }
  2028. return result;
  2029. }
  2030. /** Aggressively free buffer contents on all the buffers of all streams on
  2031. * circuit <b>c</b>. Return the number of bytes recovered. */
  2032. static size_t
  2033. marked_circuit_free_stream_bytes(circuit_t *c)
  2034. {
  2035. if (CIRCUIT_IS_ORIGIN(c)) {
  2036. return marked_circuit_streams_free_bytes(TO_ORIGIN_CIRCUIT(c)->p_streams);
  2037. } else {
  2038. return marked_circuit_streams_free_bytes(TO_OR_CIRCUIT(c)->n_streams);
  2039. }
  2040. }
  2041. /** Return the number of cells used by the circuit <b>c</b>'s cell queues. */
  2042. STATIC size_t
  2043. n_cells_in_circ_queues(const circuit_t *c)
  2044. {
  2045. size_t n = c->n_chan_cells.n;
  2046. if (! CIRCUIT_IS_ORIGIN(c)) {
  2047. circuit_t *cc = (circuit_t *) c;
  2048. n += TO_OR_CIRCUIT(cc)->p_chan_cells.n;
  2049. }
  2050. return n;
  2051. }
  2052. /**
  2053. * Return the age of the oldest cell queued on <b>c</b>, in timestamp units.
  2054. * Return 0 if there are no cells queued on c. Requires that <b>now</b> be
  2055. * the current coarse timestamp.
  2056. *
  2057. * This function will return incorrect results if the oldest cell queued on
  2058. * the circuit is older than about 2**32 msec (about 49 days) old.
  2059. */
  2060. STATIC uint32_t
  2061. circuit_max_queued_cell_age(const circuit_t *c, uint32_t now)
  2062. {
  2063. uint32_t age = 0;
  2064. packed_cell_t *cell;
  2065. if (NULL != (cell = TOR_SIMPLEQ_FIRST(&c->n_chan_cells.head)))
  2066. age = now - cell->inserted_timestamp;
  2067. if (! CIRCUIT_IS_ORIGIN(c)) {
  2068. const or_circuit_t *orcirc = CONST_TO_OR_CIRCUIT(c);
  2069. if (NULL != (cell = TOR_SIMPLEQ_FIRST(&orcirc->p_chan_cells.head))) {
  2070. uint32_t age2 = now - cell->inserted_timestamp;
  2071. if (age2 > age)
  2072. return age2;
  2073. }
  2074. }
  2075. return age;
  2076. }
  2077. /** Return the age of the oldest buffer chunk on <b>conn</b>, where age is
  2078. * taken in timestamp units before the time <b>now</b>. If the connection has
  2079. * no data, treat it as having age zero.
  2080. **/
  2081. static uint32_t
  2082. conn_get_buffer_age(const connection_t *conn, uint32_t now_ts)
  2083. {
  2084. uint32_t age = 0, age2;
  2085. if (conn->outbuf) {
  2086. age2 = buf_get_oldest_chunk_timestamp(conn->outbuf, now_ts);
  2087. if (age2 > age)
  2088. age = age2;
  2089. }
  2090. if (conn->inbuf) {
  2091. age2 = buf_get_oldest_chunk_timestamp(conn->inbuf, now_ts);
  2092. if (age2 > age)
  2093. age = age2;
  2094. }
  2095. return age;
  2096. }
  2097. /** Return the age in timestamp units of the oldest buffer chunk on any stream
  2098. * in the linked list <b>stream</b>, where age is taken in timestamp units
  2099. * before the timestamp <b>now</b>. */
  2100. static uint32_t
  2101. circuit_get_streams_max_data_age(const edge_connection_t *stream, uint32_t now)
  2102. {
  2103. uint32_t age = 0, age2;
  2104. for (; stream; stream = stream->next_stream) {
  2105. const connection_t *conn = TO_CONN(stream);
  2106. age2 = conn_get_buffer_age(conn, now);
  2107. if (age2 > age)
  2108. age = age2;
  2109. if (conn->linked_conn) {
  2110. age2 = conn_get_buffer_age(conn->linked_conn, now);
  2111. if (age2 > age)
  2112. age = age2;
  2113. }
  2114. }
  2115. return age;
  2116. }
  2117. /** Return the age in timestamp units of the oldest buffer chunk on any stream
  2118. * attached to the circuit <b>c</b>, where age is taken before the timestamp
  2119. * <b>now</b>. */
  2120. STATIC uint32_t
  2121. circuit_max_queued_data_age(const circuit_t *c, uint32_t now)
  2122. {
  2123. if (CIRCUIT_IS_ORIGIN(c)) {
  2124. return circuit_get_streams_max_data_age(
  2125. CONST_TO_ORIGIN_CIRCUIT(c)->p_streams, now);
  2126. } else {
  2127. return circuit_get_streams_max_data_age(
  2128. CONST_TO_OR_CIRCUIT(c)->n_streams, now);
  2129. }
  2130. }
  2131. /** Return the age of the oldest cell or stream buffer chunk on the circuit
  2132. * <b>c</b>, where age is taken in timestamp units before the timestamp
  2133. * <b>now</b> */
  2134. STATIC uint32_t
  2135. circuit_max_queued_item_age(const circuit_t *c, uint32_t now)
  2136. {
  2137. uint32_t cell_age = circuit_max_queued_cell_age(c, now);
  2138. uint32_t data_age = circuit_max_queued_data_age(c, now);
  2139. if (cell_age > data_age)
  2140. return cell_age;
  2141. else
  2142. return data_age;
  2143. }
  2144. /** Helper to sort a list of circuit_t by age of oldest item, in descending
  2145. * order. */
  2146. static int
  2147. circuits_compare_by_oldest_queued_item_(const void **a_, const void **b_)
  2148. {
  2149. const circuit_t *a = *a_;
  2150. const circuit_t *b = *b_;
  2151. uint32_t age_a = a->age_tmp;
  2152. uint32_t age_b = b->age_tmp;
  2153. if (age_a < age_b)
  2154. return 1;
  2155. else if (age_a == age_b)
  2156. return 0;
  2157. else
  2158. return -1;
  2159. }
  2160. static uint32_t now_ts_for_buf_cmp;
  2161. /** Helper to sort a list of circuit_t by age of oldest item, in descending
  2162. * order. */
  2163. static int
  2164. conns_compare_by_buffer_age_(const void **a_, const void **b_)
  2165. {
  2166. const connection_t *a = *a_;
  2167. const connection_t *b = *b_;
  2168. time_t age_a = conn_get_buffer_age(a, now_ts_for_buf_cmp);
  2169. time_t age_b = conn_get_buffer_age(b, now_ts_for_buf_cmp);
  2170. if (age_a < age_b)
  2171. return 1;
  2172. else if (age_a == age_b)
  2173. return 0;
  2174. else
  2175. return -1;
  2176. }
  2177. #define FRACTION_OF_DATA_TO_RETAIN_ON_OOM 0.90
  2178. /** We're out of memory for cells, having allocated <b>current_allocation</b>
  2179. * bytes' worth. Kill the 'worst' circuits until we're under
  2180. * FRACTION_OF_DATA_TO_RETAIN_ON_OOM of our maximum usage. */
  2181. void
  2182. circuits_handle_oom(size_t current_allocation)
  2183. {
  2184. smartlist_t *circlist;
  2185. smartlist_t *connection_array = get_connection_array();
  2186. int conn_idx;
  2187. size_t mem_to_recover;
  2188. size_t mem_recovered=0;
  2189. int n_circuits_killed=0;
  2190. int n_dirconns_killed=0;
  2191. uint32_t now_ts;
  2192. log_notice(LD_GENERAL, "We're low on memory (cell queues total alloc:"
  2193. " %"TOR_PRIuSZ" buffer total alloc: %" TOR_PRIuSZ ","
  2194. " tor compress total alloc: %" TOR_PRIuSZ
  2195. " rendezvous cache total alloc: %" TOR_PRIuSZ "). Killing"
  2196. " circuits withover-long queues. (This behavior is controlled by"
  2197. " MaxMemInQueues.)",
  2198. cell_queues_get_total_allocation(),
  2199. buf_get_total_allocation(),
  2200. tor_compress_get_total_allocation(),
  2201. rend_cache_get_total_allocation());
  2202. {
  2203. size_t mem_target = (size_t)(get_options()->MaxMemInQueues *
  2204. FRACTION_OF_DATA_TO_RETAIN_ON_OOM);
  2205. if (current_allocation <= mem_target)
  2206. return;
  2207. mem_to_recover = current_allocation - mem_target;
  2208. }
  2209. now_ts = monotime_coarse_get_stamp();
  2210. circlist = circuit_get_global_list();
  2211. SMARTLIST_FOREACH_BEGIN(circlist, circuit_t *, circ) {
  2212. circ->age_tmp = circuit_max_queued_item_age(circ, now_ts);
  2213. } SMARTLIST_FOREACH_END(circ);
  2214. /* This is O(n log n); there are faster algorithms we could use instead.
  2215. * Let's hope this doesn't happen enough to be in the critical path. */
  2216. smartlist_sort(circlist, circuits_compare_by_oldest_queued_item_);
  2217. /* Fix up the indices before we run into trouble */
  2218. SMARTLIST_FOREACH_BEGIN(circlist, circuit_t *, circ) {
  2219. circ->global_circuitlist_idx = circ_sl_idx;
  2220. } SMARTLIST_FOREACH_END(circ);
  2221. /* Now sort the connection array ... */
  2222. now_ts_for_buf_cmp = now_ts;
  2223. smartlist_sort(connection_array, conns_compare_by_buffer_age_);
  2224. now_ts_for_buf_cmp = 0;
  2225. /* Fix up the connection array to its new order. */
  2226. SMARTLIST_FOREACH_BEGIN(connection_array, connection_t *, conn) {
  2227. conn->conn_array_index = conn_sl_idx;
  2228. } SMARTLIST_FOREACH_END(conn);
  2229. /* Okay, now the worst circuits and connections are at the front of their
  2230. * respective lists. Let's mark them, and reclaim their storage
  2231. * aggressively. */
  2232. conn_idx = 0;
  2233. SMARTLIST_FOREACH_BEGIN(circlist, circuit_t *, circ) {
  2234. size_t n;
  2235. size_t freed;
  2236. /* Free storage in any non-linked directory connections that have buffered
  2237. * data older than this circuit. */
  2238. while (conn_idx < smartlist_len(connection_array)) {
  2239. connection_t *conn = smartlist_get(connection_array, conn_idx);
  2240. uint32_t conn_age = conn_get_buffer_age(conn, now_ts);
  2241. if (conn_age < circ->age_tmp) {
  2242. break;
  2243. }
  2244. if (conn->type == CONN_TYPE_DIR && conn->linked_conn == NULL) {
  2245. if (!conn->marked_for_close)
  2246. connection_mark_for_close(conn);
  2247. mem_recovered += single_conn_free_bytes(conn);
  2248. ++n_dirconns_killed;
  2249. if (mem_recovered >= mem_to_recover)
  2250. goto done_recovering_mem;
  2251. }
  2252. ++conn_idx;
  2253. }
  2254. /* Now, kill the circuit. */
  2255. n = n_cells_in_circ_queues(circ);
  2256. if (! circ->marked_for_close) {
  2257. circuit_mark_for_close(circ, END_CIRC_REASON_RESOURCELIMIT);
  2258. }
  2259. marked_circuit_free_cells(circ);
  2260. freed = marked_circuit_free_stream_bytes(circ);
  2261. ++n_circuits_killed;
  2262. mem_recovered += n * packed_cell_mem_cost();
  2263. mem_recovered += freed;
  2264. if (mem_recovered >= mem_to_recover)
  2265. goto done_recovering_mem;
  2266. } SMARTLIST_FOREACH_END(circ);
  2267. done_recovering_mem:
  2268. log_notice(LD_GENERAL, "Removed "U64_FORMAT" bytes by killing %d circuits; "
  2269. "%d circuits remain alive. Also killed %d non-linked directory "
  2270. "connections.",
  2271. U64_PRINTF_ARG(mem_recovered),
  2272. n_circuits_killed,
  2273. smartlist_len(circlist) - n_circuits_killed,
  2274. n_dirconns_killed);
  2275. }
  2276. /** Verify that cpath layer <b>cp</b> has all of its invariants
  2277. * correct. Trigger an assert if anything is invalid.
  2278. */
  2279. void
  2280. assert_cpath_layer_ok(const crypt_path_t *cp)
  2281. {
  2282. // tor_assert(cp->addr); /* these are zero for rendezvous extra-hops */
  2283. // tor_assert(cp->port);
  2284. tor_assert(cp);
  2285. tor_assert(cp->magic == CRYPT_PATH_MAGIC);
  2286. switch (cp->state)
  2287. {
  2288. case CPATH_STATE_OPEN:
  2289. tor_assert(cp->f_crypto);
  2290. tor_assert(cp->b_crypto);
  2291. /* fall through */
  2292. case CPATH_STATE_CLOSED:
  2293. /*XXXX Assert that there's no handshake_state either. */
  2294. tor_assert(!cp->rend_dh_handshake_state);
  2295. break;
  2296. case CPATH_STATE_AWAITING_KEYS:
  2297. /* tor_assert(cp->dh_handshake_state); */
  2298. break;
  2299. default:
  2300. log_fn(LOG_ERR, LD_BUG, "Unexpected state %d", cp->state);
  2301. tor_assert(0);
  2302. }
  2303. tor_assert(cp->package_window >= 0);
  2304. tor_assert(cp->deliver_window >= 0);
  2305. }
  2306. /** Verify that cpath <b>cp</b> has all of its invariants
  2307. * correct. Trigger an assert if anything is invalid.
  2308. */
  2309. static void
  2310. assert_cpath_ok(const crypt_path_t *cp)
  2311. {
  2312. const crypt_path_t *start = cp;
  2313. do {
  2314. assert_cpath_layer_ok(cp);
  2315. /* layers must be in sequence of: "open* awaiting? closed*" */
  2316. if (cp != start) {
  2317. if (cp->state == CPATH_STATE_AWAITING_KEYS) {
  2318. tor_assert(cp->prev->state == CPATH_STATE_OPEN);
  2319. } else if (cp->state == CPATH_STATE_OPEN) {
  2320. tor_assert(cp->prev->state == CPATH_STATE_OPEN);
  2321. }
  2322. }
  2323. cp = cp->next;
  2324. tor_assert(cp);
  2325. } while (cp != start);
  2326. }
  2327. /** Verify that circuit <b>c</b> has all of its invariants
  2328. * correct. Trigger an assert if anything is invalid.
  2329. */
  2330. MOCK_IMPL(void,
  2331. assert_circuit_ok,(const circuit_t *c))
  2332. {
  2333. edge_connection_t *conn;
  2334. const or_circuit_t *or_circ = NULL;
  2335. const origin_circuit_t *origin_circ = NULL;
  2336. tor_assert(c);
  2337. tor_assert(c->magic == ORIGIN_CIRCUIT_MAGIC || c->magic == OR_CIRCUIT_MAGIC);
  2338. tor_assert(c->purpose >= CIRCUIT_PURPOSE_MIN_ &&
  2339. c->purpose <= CIRCUIT_PURPOSE_MAX_);
  2340. if (CIRCUIT_IS_ORIGIN(c))
  2341. origin_circ = CONST_TO_ORIGIN_CIRCUIT(c);
  2342. else
  2343. or_circ = CONST_TO_OR_CIRCUIT(c);
  2344. if (c->n_chan) {
  2345. tor_assert(!c->n_hop);
  2346. if (c->n_circ_id) {
  2347. /* We use the _impl variant here to make sure we don't fail on marked
  2348. * circuits, which would not be returned by the regular function. */
  2349. circuit_t *c2 = circuit_get_by_circid_channel_impl(c->n_circ_id,
  2350. c->n_chan, NULL);
  2351. tor_assert(c == c2);
  2352. }
  2353. }
  2354. if (or_circ && or_circ->p_chan) {
  2355. if (or_circ->p_circ_id) {
  2356. /* ibid */
  2357. circuit_t *c2 =
  2358. circuit_get_by_circid_channel_impl(or_circ->p_circ_id,
  2359. or_circ->p_chan, NULL);
  2360. tor_assert(c == c2);
  2361. }
  2362. }
  2363. if (or_circ)
  2364. for (conn = or_circ->n_streams; conn; conn = conn->next_stream)
  2365. tor_assert(conn->base_.type == CONN_TYPE_EXIT);
  2366. tor_assert(c->deliver_window >= 0);
  2367. tor_assert(c->package_window >= 0);
  2368. if (c->state == CIRCUIT_STATE_OPEN ||
  2369. c->state == CIRCUIT_STATE_GUARD_WAIT) {
  2370. tor_assert(!c->n_chan_create_cell);
  2371. if (or_circ) {
  2372. tor_assert(or_circ->n_crypto);
  2373. tor_assert(or_circ->p_crypto);
  2374. tor_assert(or_circ->n_digest);
  2375. tor_assert(or_circ->p_digest);
  2376. }
  2377. }
  2378. if (c->state == CIRCUIT_STATE_CHAN_WAIT && !c->marked_for_close) {
  2379. tor_assert(circuits_pending_chans &&
  2380. smartlist_contains(circuits_pending_chans, c));
  2381. } else {
  2382. tor_assert(!circuits_pending_chans ||
  2383. !smartlist_contains(circuits_pending_chans, c));
  2384. }
  2385. if (origin_circ && origin_circ->cpath) {
  2386. assert_cpath_ok(origin_circ->cpath);
  2387. }
  2388. if (c->purpose == CIRCUIT_PURPOSE_REND_ESTABLISHED) {
  2389. tor_assert(or_circ);
  2390. if (!c->marked_for_close) {
  2391. tor_assert(or_circ->rend_splice);
  2392. tor_assert(or_circ->rend_splice->rend_splice == or_circ);
  2393. }
  2394. tor_assert(or_circ->rend_splice != or_circ);
  2395. } else {
  2396. tor_assert(!or_circ || !or_circ->rend_splice);
  2397. }
  2398. }