circuitlist.c 37 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186
  1. /* Copyright 2001 Matej Pfajfar.
  2. * Copyright (c) 2001-2004, Roger Dingledine.
  3. * Copyright (c) 2004-2007, Roger Dingledine, Nick Mathewson. */
  4. /* See LICENSE for licensing information */
  5. /* $Id$ */
  6. const char circuitlist_c_id[] =
  7. "$Id$";
  8. /**
  9. * \file circuitlist.c
  10. * \brief Manage the global circuit list.
  11. **/
  12. #include "or.h"
  13. #include "ht.h"
  14. /********* START VARIABLES **********/
  15. /** A global list of all circuits at this hop. */
  16. circuit_t *global_circuitlist=NULL;
  17. /** A list of all the circuits in CIRCUIT_STATE_OR_WAIT. */
  18. static smartlist_t *circuits_pending_or_conns=NULL;
  19. static void circuit_free(circuit_t *circ);
  20. static void circuit_free_cpath(crypt_path_t *cpath);
  21. static void circuit_free_cpath_node(crypt_path_t *victim);
  22. /********* END VARIABLES ************/
  23. /** A map from OR connection and circuit ID to circuit. (Lookup performance is
  24. * very important here, since we need to do it every time a cell arrives.) */
  25. typedef struct orconn_circid_circuit_map_t {
  26. HT_ENTRY(orconn_circid_circuit_map_t) node;
  27. or_connection_t *or_conn;
  28. uint16_t circ_id;
  29. circuit_t *circuit;
  30. } orconn_circid_circuit_map_t;
  31. /** Helper for hash tables: compare the OR connection and circuit ID for a and
  32. * b, and return less than, equal to, or greater than zero appropriately.
  33. */
  34. static INLINE int
  35. _orconn_circid_entries_eq(orconn_circid_circuit_map_t *a,
  36. orconn_circid_circuit_map_t *b)
  37. {
  38. return a->or_conn == b->or_conn && a->circ_id == b->circ_id;
  39. }
  40. /** Helper: return a hash based on circuit ID and the pointer value of
  41. * or_conn in <b>a</b>. */
  42. static INLINE unsigned int
  43. _orconn_circid_entry_hash(orconn_circid_circuit_map_t *a)
  44. {
  45. return (((unsigned)a->circ_id)<<16) ^ (unsigned)(uintptr_t)(a->or_conn);
  46. }
  47. /** Map from [orconn,circid] to circuit. */
  48. static HT_HEAD(orconn_circid_map, orconn_circid_circuit_map_t)
  49. orconn_circid_circuit_map = HT_INITIALIZER();
  50. HT_PROTOTYPE(orconn_circid_map, orconn_circid_circuit_map_t, node,
  51. _orconn_circid_entry_hash, _orconn_circid_entries_eq)
  52. HT_GENERATE(orconn_circid_map, orconn_circid_circuit_map_t, node,
  53. _orconn_circid_entry_hash, _orconn_circid_entries_eq, 0.6,
  54. malloc, realloc, free)
  55. /** The most recently returned entry from circuit_get_by_circid_orconn;
  56. * used to improve performance when many cells arrive in a row from the
  57. * same circuit.
  58. */
  59. orconn_circid_circuit_map_t *_last_circid_orconn_ent = NULL;
  60. /** Implementation helper for circuit_set_{p,n}_circid_orconn: A circuit ID
  61. * and/or or_connection for circ has just changed from <b>old_conn, old_id</b>
  62. * to <b>conn, id</b>. Adjust the conn,circid map as appropriate, removing
  63. * the old entry (if any) and adding a new one. If <b>active</b> is true,
  64. * remove the circuit from the list of active circuits on old_conn and add it
  65. * to the list of active circuits on conn.
  66. * XXX "active" isn't an arg anymore */
  67. static void
  68. circuit_set_circid_orconn_helper(circuit_t *circ, int direction,
  69. uint16_t id,
  70. or_connection_t *conn)
  71. {
  72. orconn_circid_circuit_map_t search;
  73. orconn_circid_circuit_map_t *found;
  74. or_connection_t *old_conn, **conn_ptr;
  75. uint16_t old_id, *circid_ptr;
  76. int was_active, make_active;
  77. if (direction == CELL_DIRECTION_OUT) {
  78. conn_ptr = &circ->n_conn;
  79. circid_ptr = &circ->n_circ_id;
  80. was_active = circ->next_active_on_n_conn != NULL;
  81. make_active = circ->n_conn_cells.n > 0;
  82. } else {
  83. or_circuit_t *c = TO_OR_CIRCUIT(circ);
  84. conn_ptr = &c->p_conn;
  85. circid_ptr = &c->p_circ_id;
  86. was_active = c->next_active_on_p_conn != NULL;
  87. make_active = c->p_conn_cells.n > 0;
  88. }
  89. old_conn = *conn_ptr;
  90. old_id = *circid_ptr;
  91. if (id == old_id && conn == old_conn)
  92. return;
  93. if (_last_circid_orconn_ent &&
  94. ((old_id == _last_circid_orconn_ent->circ_id &&
  95. old_conn == _last_circid_orconn_ent->or_conn) ||
  96. (id == _last_circid_orconn_ent->circ_id &&
  97. conn == _last_circid_orconn_ent->or_conn))) {
  98. _last_circid_orconn_ent = NULL;
  99. }
  100. if (old_conn) { /* we may need to remove it from the conn-circid map */
  101. tor_assert(old_conn->_base.magic == OR_CONNECTION_MAGIC);
  102. search.circ_id = old_id;
  103. search.or_conn = old_conn;
  104. found = HT_REMOVE(orconn_circid_map, &orconn_circid_circuit_map, &search);
  105. if (found) {
  106. tor_free(found);
  107. --old_conn->n_circuits;
  108. }
  109. if (was_active && old_conn != conn)
  110. make_circuit_inactive_on_conn(circ,old_conn);
  111. }
  112. /* Change the values only after we have possibly made the circuit inactive
  113. * on the previous conn. */
  114. *conn_ptr = conn;
  115. *circid_ptr = id;
  116. if (conn == NULL)
  117. return;
  118. /* now add the new one to the conn-circid map */
  119. search.circ_id = id;
  120. search.or_conn = conn;
  121. found = HT_FIND(orconn_circid_map, &orconn_circid_circuit_map, &search);
  122. if (found) {
  123. found->circuit = circ;
  124. } else {
  125. found = tor_malloc_zero(sizeof(orconn_circid_circuit_map_t));
  126. found->circ_id = id;
  127. found->or_conn = conn;
  128. found->circuit = circ;
  129. HT_INSERT(orconn_circid_map, &orconn_circid_circuit_map, found);
  130. }
  131. if (make_active && old_conn != conn)
  132. make_circuit_active_on_conn(circ,conn);
  133. ++conn->n_circuits;
  134. }
  135. /** Set the p_conn field of a circuit <b>circ</b>, along
  136. * with the corresponding circuit ID, and add the circuit as appropriate
  137. * to the (orconn,id)-\>circuit map. */
  138. void
  139. circuit_set_p_circid_orconn(or_circuit_t *circ, uint16_t id,
  140. or_connection_t *conn)
  141. {
  142. circuit_set_circid_orconn_helper(TO_CIRCUIT(circ), CELL_DIRECTION_IN,
  143. id, conn);
  144. if (conn)
  145. tor_assert(bool_eq(circ->p_conn_cells.n, circ->next_active_on_p_conn));
  146. }
  147. /** Set the n_conn field of a circuit <b>circ</b>, along
  148. * with the corresponding circuit ID, and add the circuit as appropriate
  149. * to the (orconn,id)-\>circuit map. */
  150. void
  151. circuit_set_n_circid_orconn(circuit_t *circ, uint16_t id,
  152. or_connection_t *conn)
  153. {
  154. circuit_set_circid_orconn_helper(circ, CELL_DIRECTION_OUT, id, conn);
  155. if (conn)
  156. tor_assert(bool_eq(circ->n_conn_cells.n, circ->next_active_on_n_conn));
  157. }
  158. /** Change the state of <b>circ</b> to <b>state</b>, adding it to or removing
  159. * it from lists as appropriate. */
  160. void
  161. circuit_set_state(circuit_t *circ, int state)
  162. {
  163. tor_assert(circ);
  164. if (state == circ->state)
  165. return;
  166. if (!circuits_pending_or_conns)
  167. circuits_pending_or_conns = smartlist_create();
  168. if (circ->state == CIRCUIT_STATE_OR_WAIT) {
  169. /* remove from waiting-circuit list. */
  170. smartlist_remove(circuits_pending_or_conns, circ);
  171. }
  172. if (state == CIRCUIT_STATE_OR_WAIT) {
  173. /* add to waiting-circuit list. */
  174. smartlist_add(circuits_pending_or_conns, circ);
  175. }
  176. circ->state = state;
  177. }
  178. /** Add <b>circ</b> to the global list of circuits. This is called only from
  179. * within circuit_new.
  180. */
  181. static void
  182. circuit_add(circuit_t *circ)
  183. {
  184. if (!global_circuitlist) { /* first one */
  185. global_circuitlist = circ;
  186. circ->next = NULL;
  187. } else {
  188. circ->next = global_circuitlist;
  189. global_circuitlist = circ;
  190. }
  191. }
  192. /** Append to <b>out</b> all circuits in state OR_WAIT waiting for
  193. * the given connection. */
  194. void
  195. circuit_get_all_pending_on_or_conn(smartlist_t *out, or_connection_t *or_conn)
  196. {
  197. tor_assert(out);
  198. tor_assert(or_conn);
  199. if (!circuits_pending_or_conns)
  200. return;
  201. SMARTLIST_FOREACH(circuits_pending_or_conns, circuit_t *, circ,
  202. {
  203. if (circ->marked_for_close)
  204. continue;
  205. tor_assert(circ->state == CIRCUIT_STATE_OR_WAIT);
  206. if (tor_digest_is_zero(circ->n_conn_id_digest)) {
  207. /* Look at addr/port. This is an unkeyed connection. */
  208. if (circ->n_addr != or_conn->_base.addr ||
  209. circ->n_port != or_conn->_base.port)
  210. continue;
  211. } else {
  212. /* We expected a key. See if it's the right one. */
  213. if (memcmp(or_conn->identity_digest,
  214. circ->n_conn_id_digest, DIGEST_LEN))
  215. continue;
  216. }
  217. smartlist_add(out, circ);
  218. });
  219. }
  220. /** Return the number of circuits in state OR_WAIT, waiting for the given
  221. * connection. */
  222. int
  223. circuit_count_pending_on_or_conn(or_connection_t *or_conn)
  224. {
  225. int cnt;
  226. smartlist_t *sl = smartlist_create();
  227. circuit_get_all_pending_on_or_conn(sl, or_conn);
  228. cnt = smartlist_len(sl);
  229. smartlist_free(sl);
  230. log_debug(LD_CIRC,"or_conn to %s, %d pending circs",
  231. or_conn->nickname ? or_conn->nickname : "NULL", cnt);
  232. return cnt;
  233. }
  234. /** Detach from the global circuit list, and deallocate, all
  235. * circuits that have been marked for close.
  236. */
  237. void
  238. circuit_close_all_marked(void)
  239. {
  240. circuit_t *tmp,*m;
  241. while (global_circuitlist && global_circuitlist->marked_for_close) {
  242. tmp = global_circuitlist->next;
  243. circuit_free(global_circuitlist);
  244. global_circuitlist = tmp;
  245. }
  246. tmp = global_circuitlist;
  247. while (tmp && tmp->next) {
  248. if (tmp->next->marked_for_close) {
  249. m = tmp->next->next;
  250. circuit_free(tmp->next);
  251. tmp->next = m;
  252. /* Need to check new tmp->next; don't advance tmp. */
  253. } else {
  254. /* Advance tmp. */
  255. tmp = tmp->next;
  256. }
  257. }
  258. }
  259. /** Return the head of the global linked list of circuits. */
  260. circuit_t *
  261. _circuit_get_global_list(void)
  262. {
  263. return global_circuitlist;
  264. }
  265. /** Function to make circ-\>state human-readable */
  266. const char *
  267. circuit_state_to_string(int state)
  268. {
  269. static char buf[64];
  270. switch (state) {
  271. case CIRCUIT_STATE_BUILDING: return "doing handshakes";
  272. case CIRCUIT_STATE_ONIONSKIN_PENDING: return "processing the onion";
  273. case CIRCUIT_STATE_OR_WAIT: return "connecting to server";
  274. case CIRCUIT_STATE_OPEN: return "open";
  275. default:
  276. log_warn(LD_BUG, "Unknown circuit state %d", state);
  277. tor_snprintf(buf, sizeof(buf), "unknown state [%d]", state);
  278. return buf;
  279. }
  280. }
  281. /** Initialize the common elements in a circuit_t, and add it to the global
  282. * list. */
  283. static void
  284. init_circuit_base(circuit_t *circ)
  285. {
  286. circ->timestamp_created = time(NULL);
  287. circ->package_window = CIRCWINDOW_START;
  288. circ->deliver_window = CIRCWINDOW_START;
  289. circuit_add(circ);
  290. }
  291. /** Allocate space for a new circuit, initializing with <b>p_circ_id</b>
  292. * and <b>p_conn</b>. Add it to the global circuit list.
  293. */
  294. origin_circuit_t *
  295. origin_circuit_new(void)
  296. {
  297. origin_circuit_t *circ;
  298. /* never zero, since a global ID of 0 is treated specially by the
  299. * controller */
  300. static uint32_t n_circuits_allocated = 1;
  301. circ = tor_malloc_zero(sizeof(origin_circuit_t));
  302. circ->_base.magic = ORIGIN_CIRCUIT_MAGIC;
  303. circ->next_stream_id = crypto_rand_int(1<<16);
  304. circ->global_identifier = n_circuits_allocated++;
  305. init_circuit_base(TO_CIRCUIT(circ));
  306. return circ;
  307. }
  308. /** Allocate a new or_circuit_t, connected to <b>p_conn</b> as
  309. * <b>p_circ_id</b>. If <b>p_conn</b> is NULL, the circuit is unattached. */
  310. or_circuit_t *
  311. or_circuit_new(uint16_t p_circ_id, or_connection_t *p_conn)
  312. {
  313. /* CircIDs */
  314. or_circuit_t *circ;
  315. circ = tor_malloc_zero(sizeof(or_circuit_t));
  316. circ->_base.magic = OR_CIRCUIT_MAGIC;
  317. if (p_conn)
  318. circuit_set_p_circid_orconn(circ, p_circ_id, p_conn);
  319. init_circuit_base(TO_CIRCUIT(circ));
  320. return circ;
  321. }
  322. /** Deallocate space associated with circ.
  323. */
  324. static void
  325. circuit_free(circuit_t *circ)
  326. {
  327. void *mem;
  328. tor_assert(circ);
  329. if (CIRCUIT_IS_ORIGIN(circ)) {
  330. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  331. mem = ocirc;
  332. tor_assert(circ->magic == ORIGIN_CIRCUIT_MAGIC);
  333. if (ocirc->build_state) {
  334. if (ocirc->build_state->chosen_exit)
  335. extend_info_free(ocirc->build_state->chosen_exit);
  336. if (ocirc->build_state->pending_final_cpath)
  337. circuit_free_cpath_node(ocirc->build_state->pending_final_cpath);
  338. }
  339. tor_free(ocirc->build_state);
  340. circuit_free_cpath(ocirc->cpath);
  341. } else {
  342. or_circuit_t *ocirc = TO_OR_CIRCUIT(circ);
  343. mem = ocirc;
  344. tor_assert(circ->magic == OR_CIRCUIT_MAGIC);
  345. if (ocirc->p_crypto)
  346. crypto_free_cipher_env(ocirc->p_crypto);
  347. if (ocirc->p_digest)
  348. crypto_free_digest_env(ocirc->p_digest);
  349. if (ocirc->n_crypto)
  350. crypto_free_cipher_env(ocirc->n_crypto);
  351. if (ocirc->n_digest)
  352. crypto_free_digest_env(ocirc->n_digest);
  353. if (ocirc->rend_splice) {
  354. or_circuit_t *other = ocirc->rend_splice;
  355. tor_assert(other->_base.magic == OR_CIRCUIT_MAGIC);
  356. other->rend_splice = NULL;
  357. }
  358. tor_free(circ->onionskin);
  359. /* remove from map. */
  360. circuit_set_p_circid_orconn(ocirc, 0, NULL);
  361. /* Clear cell queue _after_ removing it from the map. Otherwise our
  362. * "active" checks will be violated. */
  363. cell_queue_clear(&ocirc->p_conn_cells);
  364. }
  365. /* Remove from map. */
  366. circuit_set_n_circid_orconn(circ, 0, NULL);
  367. /* Clear cell queue _after_ removing it from the map. Otherwise our
  368. * "active" checks will be violated. */
  369. cell_queue_clear(&circ->n_conn_cells);
  370. memset(circ, 0xAA, sizeof(circuit_t)); /* poison memory */
  371. tor_free(mem);
  372. }
  373. /** Deallocate space associated with the linked list <b>cpath</b>. */
  374. static void
  375. circuit_free_cpath(crypt_path_t *cpath)
  376. {
  377. crypt_path_t *victim, *head=cpath;
  378. if (!cpath)
  379. return;
  380. /* it's a doubly linked list, so we have to notice when we've
  381. * gone through it once. */
  382. while (cpath->next && cpath->next != head) {
  383. victim = cpath;
  384. cpath = victim->next;
  385. circuit_free_cpath_node(victim);
  386. }
  387. circuit_free_cpath_node(cpath);
  388. }
  389. /** Release all storage held by circuits. */
  390. void
  391. circuit_free_all(void)
  392. {
  393. circuit_t *next;
  394. while (global_circuitlist) {
  395. next = global_circuitlist->next;
  396. if (! CIRCUIT_IS_ORIGIN(global_circuitlist)) {
  397. or_circuit_t *or_circ = TO_OR_CIRCUIT(global_circuitlist);
  398. while (or_circ->resolving_streams) {
  399. edge_connection_t *next_conn;
  400. next_conn = or_circ->resolving_streams->next_stream;
  401. connection_free(TO_CONN(or_circ->resolving_streams));
  402. or_circ->resolving_streams = next_conn;
  403. }
  404. }
  405. circuit_free(global_circuitlist);
  406. global_circuitlist = next;
  407. }
  408. if (circuits_pending_or_conns) {
  409. smartlist_free(circuits_pending_or_conns);
  410. circuits_pending_or_conns = NULL;
  411. }
  412. HT_CLEAR(orconn_circid_map, &orconn_circid_circuit_map);
  413. }
  414. /** Deallocate space associated with the cpath node <b>victim</b>. */
  415. static void
  416. circuit_free_cpath_node(crypt_path_t *victim)
  417. {
  418. if (victim->f_crypto)
  419. crypto_free_cipher_env(victim->f_crypto);
  420. if (victim->b_crypto)
  421. crypto_free_cipher_env(victim->b_crypto);
  422. if (victim->f_digest)
  423. crypto_free_digest_env(victim->f_digest);
  424. if (victim->b_digest)
  425. crypto_free_digest_env(victim->b_digest);
  426. if (victim->dh_handshake_state)
  427. crypto_dh_free(victim->dh_handshake_state);
  428. if (victim->extend_info)
  429. extend_info_free(victim->extend_info);
  430. victim->magic = 0xDEADBEEFu;
  431. tor_free(victim);
  432. }
  433. /** A helper function for circuit_dump_by_conn() below. Log a bunch
  434. * of information about circuit <b>circ</b>.
  435. */
  436. static void
  437. circuit_dump_details(int severity, circuit_t *circ, int conn_array_index,
  438. const char *type, int this_circid, int other_circid)
  439. {
  440. log(severity, LD_CIRC, "Conn %d has %s circuit: circID %d (other side %d), "
  441. "state %d (%s), born %d:",
  442. conn_array_index, type, this_circid, other_circid, circ->state,
  443. circuit_state_to_string(circ->state), (int)circ->timestamp_created);
  444. if (CIRCUIT_IS_ORIGIN(circ)) { /* circ starts at this node */
  445. circuit_log_path(severity, LD_CIRC, TO_ORIGIN_CIRCUIT(circ));
  446. }
  447. }
  448. /** Log, at severity <b>severity</b>, information about each circuit
  449. * that is connected to <b>conn</b>.
  450. */
  451. void
  452. circuit_dump_by_conn(connection_t *conn, int severity)
  453. {
  454. circuit_t *circ;
  455. edge_connection_t *tmpconn;
  456. for (circ=global_circuitlist;circ;circ = circ->next) {
  457. circid_t n_circ_id = circ->n_circ_id, p_circ_id = 0;
  458. if (circ->marked_for_close)
  459. continue;
  460. if (! CIRCUIT_IS_ORIGIN(circ))
  461. p_circ_id = TO_OR_CIRCUIT(circ)->p_circ_id;
  462. if (! CIRCUIT_IS_ORIGIN(circ) && TO_OR_CIRCUIT(circ)->p_conn &&
  463. TO_CONN(TO_OR_CIRCUIT(circ)->p_conn) == conn)
  464. circuit_dump_details(severity, circ, conn->conn_array_index, "App-ward",
  465. p_circ_id, n_circ_id);
  466. if (CIRCUIT_IS_ORIGIN(circ)) {
  467. for (tmpconn=TO_ORIGIN_CIRCUIT(circ)->p_streams; tmpconn;
  468. tmpconn=tmpconn->next_stream) {
  469. if (TO_CONN(tmpconn) == conn) {
  470. circuit_dump_details(severity, circ, conn->conn_array_index,
  471. "App-ward", p_circ_id, n_circ_id);
  472. }
  473. }
  474. }
  475. if (circ->n_conn && TO_CONN(circ->n_conn) == conn)
  476. circuit_dump_details(severity, circ, conn->conn_array_index, "Exit-ward",
  477. n_circ_id, p_circ_id);
  478. if (! CIRCUIT_IS_ORIGIN(circ)) {
  479. for (tmpconn=TO_OR_CIRCUIT(circ)->n_streams; tmpconn;
  480. tmpconn=tmpconn->next_stream) {
  481. if (TO_CONN(tmpconn) == conn) {
  482. circuit_dump_details(severity, circ, conn->conn_array_index,
  483. "Exit-ward", n_circ_id, p_circ_id);
  484. }
  485. }
  486. }
  487. if (!circ->n_conn && circ->n_addr && circ->n_port &&
  488. circ->n_addr == conn->addr &&
  489. circ->n_port == conn->port &&
  490. conn->type == CONN_TYPE_OR &&
  491. !memcmp(TO_OR_CONN(conn)->identity_digest, circ->n_conn_id_digest,
  492. DIGEST_LEN)) {
  493. circuit_dump_details(severity, circ, conn->conn_array_index,
  494. (circ->state == CIRCUIT_STATE_OPEN &&
  495. !CIRCUIT_IS_ORIGIN(circ)) ?
  496. "Endpoint" : "Pending",
  497. n_circ_id, p_circ_id);
  498. }
  499. }
  500. }
  501. /** Return the circuit whose global ID is <b>id</b>, or NULL if no
  502. * such circuit exists. */
  503. origin_circuit_t *
  504. circuit_get_by_global_id(uint32_t id)
  505. {
  506. circuit_t *circ;
  507. for (circ=global_circuitlist;circ;circ = circ->next) {
  508. if (CIRCUIT_IS_ORIGIN(circ) &&
  509. TO_ORIGIN_CIRCUIT(circ)->global_identifier == id) {
  510. if (circ->marked_for_close)
  511. return NULL;
  512. else
  513. return TO_ORIGIN_CIRCUIT(circ);
  514. }
  515. }
  516. return NULL;
  517. }
  518. /** Return a circ such that:
  519. * - circ-\>n_circ_id or circ-\>p_circ_id is equal to <b>circ_id</b>, and
  520. * - circ is attached to <b>conn</b>, either as p_conn or n_conn.
  521. * Return NULL if no such circuit exists.
  522. */
  523. static INLINE circuit_t *
  524. circuit_get_by_circid_orconn_impl(uint16_t circ_id, or_connection_t *conn)
  525. {
  526. orconn_circid_circuit_map_t search;
  527. orconn_circid_circuit_map_t *found;
  528. if (_last_circid_orconn_ent &&
  529. circ_id == _last_circid_orconn_ent->circ_id &&
  530. conn == _last_circid_orconn_ent->or_conn) {
  531. found = _last_circid_orconn_ent;
  532. } else {
  533. search.circ_id = circ_id;
  534. search.or_conn = conn;
  535. found = HT_FIND(orconn_circid_map, &orconn_circid_circuit_map, &search);
  536. _last_circid_orconn_ent = found;
  537. }
  538. if (found && found->circuit)
  539. return found->circuit;
  540. return NULL;
  541. /* The rest of this checks for bugs. Disabled by default. */
  542. {
  543. circuit_t *circ;
  544. for (circ=global_circuitlist;circ;circ = circ->next) {
  545. if (! CIRCUIT_IS_ORIGIN(circ)) {
  546. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  547. if (or_circ->p_conn == conn && or_circ->p_circ_id == circ_id) {
  548. log_warn(LD_BUG,
  549. "circuit matches p_conn, but not in hash table (Bug!)");
  550. return circ;
  551. }
  552. }
  553. if (circ->n_conn == conn && circ->n_circ_id == circ_id) {
  554. log_warn(LD_BUG,
  555. "circuit matches n_conn, but not in hash table (Bug!)");
  556. return circ;
  557. }
  558. }
  559. return NULL;
  560. }
  561. }
  562. /** Return a circ such that:
  563. * - circ-\>n_circ_id or circ-\>p_circ_id is equal to <b>circ_id</b>, and
  564. * - circ is attached to <b>conn</b>, either as p_conn or n_conn.
  565. * - circ is not marked for close.
  566. * Return NULL if no such circuit exists.
  567. */
  568. circuit_t *
  569. circuit_get_by_circid_orconn(uint16_t circ_id, or_connection_t *conn)
  570. {
  571. circuit_t *circ = circuit_get_by_circid_orconn_impl(circ_id, conn);
  572. if (!circ || circ->marked_for_close)
  573. return NULL;
  574. else
  575. return circ;
  576. }
  577. /** Return the circuit that a given edge connection is using. */
  578. circuit_t *
  579. circuit_get_by_edge_conn(edge_connection_t *conn)
  580. {
  581. circuit_t *circ;
  582. circ = conn->on_circuit;
  583. tor_assert(!circ ||
  584. (CIRCUIT_IS_ORIGIN(circ) ? circ->magic == ORIGIN_CIRCUIT_MAGIC
  585. : circ->magic == OR_CIRCUIT_MAGIC));
  586. return circ;
  587. }
  588. /** For each circuit that has <b>conn</b> as n_conn or p_conn, unlink the
  589. * circuit from the orconn,circid map, and mark it for close if it hasn't
  590. * been marked already.
  591. */
  592. void
  593. circuit_unlink_all_from_or_conn(or_connection_t *conn, int reason)
  594. {
  595. circuit_t *circ;
  596. connection_or_unlink_all_active_circs(conn);
  597. for (circ = global_circuitlist; circ; circ = circ->next) {
  598. int mark = 0;
  599. if (circ->n_conn == conn) {
  600. circuit_set_n_circid_orconn(circ, 0, NULL);
  601. mark = 1;
  602. }
  603. if (! CIRCUIT_IS_ORIGIN(circ)) {
  604. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  605. if (or_circ->p_conn == conn) {
  606. circuit_set_p_circid_orconn(or_circ, 0, NULL);
  607. mark = 1;
  608. }
  609. }
  610. if (mark && !circ->marked_for_close)
  611. circuit_mark_for_close(circ, reason);
  612. }
  613. }
  614. /** Return a circ such that:
  615. * - circ-\>rend_query is equal to <b>rend_query</b>, and
  616. * - circ-\>purpose is equal to <b>purpose</b>.
  617. *
  618. * Return NULL if no such circuit exists.
  619. */
  620. origin_circuit_t *
  621. circuit_get_by_rend_query_and_purpose(const char *rend_query, uint8_t purpose)
  622. {
  623. circuit_t *circ;
  624. tor_assert(CIRCUIT_PURPOSE_IS_ORIGIN(purpose));
  625. for (circ = global_circuitlist; circ; circ = circ->next) {
  626. if (!circ->marked_for_close &&
  627. circ->purpose == purpose &&
  628. !rend_cmp_service_ids(rend_query, TO_ORIGIN_CIRCUIT(circ)->rend_query))
  629. return TO_ORIGIN_CIRCUIT(circ);
  630. }
  631. return NULL;
  632. }
  633. /** Return the first circuit originating here in global_circuitlist after
  634. * <b>start</b> whose purpose is <b>purpose</b>, and where
  635. * <b>digest</b> (if set) matches the rend_pk_digest field. Return NULL if no
  636. * circuit is found. If <b>start</b> is NULL, begin at the start of the list.
  637. */
  638. origin_circuit_t *
  639. circuit_get_next_by_pk_and_purpose(origin_circuit_t *start,
  640. const char *digest, uint8_t purpose)
  641. {
  642. circuit_t *circ;
  643. tor_assert(CIRCUIT_PURPOSE_IS_ORIGIN(purpose));
  644. if (start == NULL)
  645. circ = global_circuitlist;
  646. else
  647. circ = TO_CIRCUIT(start)->next;
  648. for ( ; circ; circ = circ->next) {
  649. if (circ->marked_for_close)
  650. continue;
  651. if (circ->purpose != purpose)
  652. continue;
  653. if (!digest)
  654. return TO_ORIGIN_CIRCUIT(circ);
  655. else if (!memcmp(TO_ORIGIN_CIRCUIT(circ)->rend_pk_digest,
  656. digest, DIGEST_LEN))
  657. return TO_ORIGIN_CIRCUIT(circ);
  658. }
  659. return NULL;
  660. }
  661. /** Return the first OR circuit in the global list whose purpose is
  662. * <b>purpose</b>, and whose rend_token is the <b>len</b>-byte
  663. * <b>token</b>. */
  664. static or_circuit_t *
  665. circuit_get_by_rend_token_and_purpose(uint8_t purpose, const char *token,
  666. size_t len)
  667. {
  668. circuit_t *circ;
  669. for (circ = global_circuitlist; circ; circ = circ->next) {
  670. if (! circ->marked_for_close &&
  671. circ->purpose == purpose &&
  672. ! memcmp(TO_OR_CIRCUIT(circ)->rend_token, token, len))
  673. return TO_OR_CIRCUIT(circ);
  674. }
  675. return NULL;
  676. }
  677. /** Return the circuit waiting for a rendezvous with the provided cookie.
  678. * Return NULL if no such circuit is found.
  679. */
  680. or_circuit_t *
  681. circuit_get_rendezvous(const char *cookie)
  682. {
  683. return circuit_get_by_rend_token_and_purpose(
  684. CIRCUIT_PURPOSE_REND_POINT_WAITING,
  685. cookie, REND_COOKIE_LEN);
  686. }
  687. /** Return the circuit waiting for intro cells of the given digest.
  688. * Return NULL if no such circuit is found.
  689. */
  690. or_circuit_t *
  691. circuit_get_intro_point(const char *digest)
  692. {
  693. return circuit_get_by_rend_token_and_purpose(
  694. CIRCUIT_PURPOSE_INTRO_POINT, digest,
  695. DIGEST_LEN);
  696. }
  697. /** Return a circuit that is open, is CIRCUIT_PURPOSE_C_GENERAL,
  698. * has a timestamp_dirty value of 0, is uptime/capacity/internal
  699. * if required, and if info is defined, does not already use info
  700. * as any of its hops; or NULL if no circuit fits this description.
  701. *
  702. * If ! need_uptime, prefer returning non-uptime circuits.
  703. */
  704. origin_circuit_t *
  705. circuit_find_to_cannibalize(uint8_t purpose, extend_info_t *info,
  706. int need_uptime,
  707. int need_capacity, int internal)
  708. {
  709. circuit_t *_circ;
  710. origin_circuit_t *best=NULL;
  711. log_debug(LD_CIRC,
  712. "Hunting for a circ to cannibalize: purpose %d, uptime %d, "
  713. "capacity %d, internal %d",
  714. purpose, need_uptime, need_capacity, internal);
  715. for (_circ=global_circuitlist; _circ; _circ = _circ->next) {
  716. if (CIRCUIT_IS_ORIGIN(_circ) &&
  717. _circ->state == CIRCUIT_STATE_OPEN &&
  718. !_circ->marked_for_close &&
  719. _circ->purpose == CIRCUIT_PURPOSE_C_GENERAL &&
  720. !_circ->timestamp_dirty) {
  721. origin_circuit_t *circ = TO_ORIGIN_CIRCUIT(_circ);
  722. #if 0 /* XXX here while roger investigates a reported RendNodes bug */
  723. if (_circ->purpose == CIRCUIT_PURPOSE_C_ESTABLISH_REND &&
  724. options->RendNodes) {
  725. routerinfo_t *exit = build_state_get_exit_router(circ->build_state);
  726. if (exit && !router_nickname_is_in_list(exit, options->RendNodes))
  727. continue; /* not one of our allowed RendNodes */
  728. }
  729. #endif
  730. if ((!need_uptime || circ->build_state->need_uptime) &&
  731. (!need_capacity || circ->build_state->need_capacity) &&
  732. (internal == circ->build_state->is_internal)) {
  733. if (info) {
  734. /* need to make sure we don't duplicate hops */
  735. crypt_path_t *hop = circ->cpath;
  736. routerinfo_t *ri1 = router_get_by_digest(info->identity_digest);
  737. do {
  738. routerinfo_t *ri2;
  739. if (!memcmp(hop->extend_info->identity_digest,
  740. info->identity_digest, DIGEST_LEN))
  741. goto next;
  742. if (ri1 &&
  743. (ri2 = router_get_by_digest(hop->extend_info->identity_digest))
  744. && routers_in_same_family(ri1, ri2))
  745. goto next;
  746. hop=hop->next;
  747. } while (hop!=circ->cpath);
  748. }
  749. if (!best || (best->build_state->need_uptime && !need_uptime))
  750. best = circ;
  751. next: ;
  752. }
  753. }
  754. }
  755. return best;
  756. }
  757. /** Return the number of hops in circuit's path. */
  758. int
  759. circuit_get_cpath_len(origin_circuit_t *circ)
  760. {
  761. int n = 0;
  762. if (circ && circ->cpath) {
  763. crypt_path_t *cpath, *cpath_next = NULL;
  764. for (cpath = circ->cpath; cpath_next != circ->cpath; cpath = cpath_next) {
  765. cpath_next = cpath->next;
  766. ++n;
  767. }
  768. }
  769. return n;
  770. }
  771. /** Return the <b>hopnum</b>th hop in <b>circ</b>->cpath, or NULL if there
  772. * aren't that many hops in the list. */
  773. crypt_path_t *
  774. circuit_get_cpath_hop(origin_circuit_t *circ, int hopnum)
  775. {
  776. if (circ && circ->cpath && hopnum > 0) {
  777. crypt_path_t *cpath, *cpath_next = NULL;
  778. for (cpath = circ->cpath; cpath_next != circ->cpath; cpath = cpath_next) {
  779. cpath_next = cpath->next;
  780. if (--hopnum <= 0)
  781. return cpath;
  782. }
  783. }
  784. return NULL;
  785. }
  786. /** Go through the circuitlist; mark-for-close each circuit that starts
  787. * at us but has not yet been used. */
  788. void
  789. circuit_mark_all_unused_circs(void)
  790. {
  791. circuit_t *circ;
  792. for (circ=global_circuitlist; circ; circ = circ->next) {
  793. if (CIRCUIT_IS_ORIGIN(circ) &&
  794. !circ->marked_for_close &&
  795. !circ->timestamp_dirty)
  796. circuit_mark_for_close(circ, END_CIRC_REASON_FINISHED);
  797. }
  798. }
  799. /** Go through the circuitlist; for each circuit that starts at us
  800. * and is dirty, frob its timestamp_dirty so we won't use it for any
  801. * new streams.
  802. *
  803. * This is useful for letting the user change pseudonyms, so new
  804. * streams will not be linkable to old streams.
  805. */
  806. void
  807. circuit_expire_all_dirty_circs(void)
  808. {
  809. circuit_t *circ;
  810. or_options_t *options = get_options();
  811. for (circ=global_circuitlist; circ; circ = circ->next) {
  812. if (CIRCUIT_IS_ORIGIN(circ) &&
  813. !circ->marked_for_close &&
  814. circ->timestamp_dirty)
  815. circ->timestamp_dirty -= options->MaxCircuitDirtiness;
  816. }
  817. }
  818. /** Mark <b>circ</b> to be closed next time we call
  819. * circuit_close_all_marked(). Do any cleanup needed:
  820. * - If state is onionskin_pending, remove circ from the onion_pending
  821. * list.
  822. * - If circ isn't open yet: call circuit_build_failed() if we're
  823. * the origin, and in either case call circuit_rep_hist_note_result()
  824. * to note stats.
  825. * - If purpose is C_INTRODUCE_ACK_WAIT, remove the intro point we
  826. * just tried from our list of intro points for that service
  827. * descriptor.
  828. * - Send appropriate destroys and edge_destroys for conns and
  829. * streams attached to circ.
  830. * - If circ->rend_splice is set (we are the midpoint of a joined
  831. * rendezvous stream), then mark the other circuit to close as well.
  832. */
  833. void
  834. _circuit_mark_for_close(circuit_t *circ, int reason, int line,
  835. const char *file)
  836. {
  837. int orig_reason = reason; /* Passed to the controller */
  838. assert_circuit_ok(circ);
  839. tor_assert(line);
  840. tor_assert(file);
  841. if (circ->marked_for_close) {
  842. log(LOG_WARN,LD_BUG,
  843. "Duplicate call to circuit_mark_for_close at %s:%d"
  844. " (first at %s:%d)", file, line,
  845. circ->marked_for_close_file, circ->marked_for_close);
  846. return;
  847. }
  848. if (reason == END_CIRC_AT_ORIGIN) {
  849. if (!CIRCUIT_IS_ORIGIN(circ)) {
  850. log_warn(LD_BUG, "Specified 'at-origin' non-reason for ending circuit, "
  851. "but circuit was not at origin. (called %s:%d, purpose=%d)",
  852. file, line, circ->purpose);
  853. }
  854. reason = END_CIRC_REASON_NONE;
  855. }
  856. if (CIRCUIT_IS_ORIGIN(circ)) {
  857. /* We don't send reasons when closing circuits at the origin. */
  858. reason = END_CIRC_REASON_NONE;
  859. }
  860. if (reason & END_CIRC_REASON_FLAG_REMOTE)
  861. reason &= ~END_CIRC_REASON_FLAG_REMOTE;
  862. if (reason < _END_CIRC_REASON_MIN || reason > _END_CIRC_REASON_MAX) {
  863. if (!(orig_reason & END_CIRC_REASON_FLAG_REMOTE))
  864. log_warn(LD_BUG, "Reason %d out of range at %s:%d", reason, file, line);
  865. reason = END_CIRC_REASON_NONE;
  866. }
  867. if (circ->state == CIRCUIT_STATE_ONIONSKIN_PENDING) {
  868. onion_pending_remove(TO_OR_CIRCUIT(circ));
  869. }
  870. /* If the circuit ever became OPEN, we sent it to the reputation history
  871. * module then. If it isn't OPEN, we send it there now to remember which
  872. * links worked and which didn't.
  873. */
  874. if (circ->state != CIRCUIT_STATE_OPEN) {
  875. if (CIRCUIT_IS_ORIGIN(circ)) {
  876. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  877. circuit_build_failed(ocirc); /* take actions if necessary */
  878. circuit_rep_hist_note_result(ocirc);
  879. }
  880. }
  881. if (circ->state == CIRCUIT_STATE_OR_WAIT) {
  882. if (circuits_pending_or_conns)
  883. smartlist_remove(circuits_pending_or_conns, circ);
  884. }
  885. if (CIRCUIT_IS_ORIGIN(circ)) {
  886. control_event_circuit_status(TO_ORIGIN_CIRCUIT(circ),
  887. (circ->state == CIRCUIT_STATE_OPEN)?CIRC_EVENT_CLOSED:CIRC_EVENT_FAILED,
  888. orig_reason);
  889. }
  890. if (circ->purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT) {
  891. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  892. tor_assert(circ->state == CIRCUIT_STATE_OPEN);
  893. tor_assert(ocirc->build_state->chosen_exit);
  894. /* treat this like getting a nack from it */
  895. log_info(LD_REND, "Failed intro circ %s to %s (awaiting ack). "
  896. "Removing from descriptor.",
  897. safe_str(ocirc->rend_query),
  898. safe_str(build_state_get_exit_nickname(ocirc->build_state)));
  899. rend_client_remove_intro_point(ocirc->build_state->chosen_exit,
  900. ocirc->rend_query);
  901. }
  902. if (circ->n_conn)
  903. connection_or_send_destroy(circ->n_circ_id, circ->n_conn, reason);
  904. if (! CIRCUIT_IS_ORIGIN(circ)) {
  905. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  906. edge_connection_t *conn;
  907. for (conn=or_circ->n_streams; conn; conn=conn->next_stream)
  908. connection_edge_destroy(or_circ->p_circ_id, conn);
  909. while (or_circ->resolving_streams) {
  910. conn = or_circ->resolving_streams;
  911. or_circ->resolving_streams = conn->next_stream;
  912. if (!conn->_base.marked_for_close) {
  913. /* The client will see a DESTROY, and infer that the connections
  914. * are closing because the circuit is getting torn down. No need
  915. * to send an end cell. */
  916. conn->_base.edge_has_sent_end = 1;
  917. conn->end_reason = END_STREAM_REASON_DESTROY;
  918. conn->end_reason |= END_STREAM_REASON_FLAG_ALREADY_SENT_CLOSED;
  919. connection_mark_for_close(TO_CONN(conn));
  920. }
  921. conn->on_circuit = NULL;
  922. }
  923. if (or_circ->p_conn)
  924. connection_or_send_destroy(or_circ->p_circ_id, or_circ->p_conn, reason);
  925. } else {
  926. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  927. edge_connection_t *conn;
  928. for (conn=ocirc->p_streams; conn; conn=conn->next_stream)
  929. connection_edge_destroy(circ->n_circ_id, conn);
  930. }
  931. circ->marked_for_close = line;
  932. circ->marked_for_close_file = file;
  933. if (!CIRCUIT_IS_ORIGIN(circ)) {
  934. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  935. if (or_circ->rend_splice) {
  936. if (!or_circ->rend_splice->_base.marked_for_close) {
  937. /* do this after marking this circuit, to avoid infinite recursion. */
  938. circuit_mark_for_close(TO_CIRCUIT(or_circ->rend_splice), reason);
  939. }
  940. or_circ->rend_splice = NULL;
  941. }
  942. }
  943. }
  944. /** Verify that cpath layer <b>cp</b> has all of its invariants
  945. * correct. Trigger an assert if anything is invalid.
  946. */
  947. void
  948. assert_cpath_layer_ok(const crypt_path_t *cp)
  949. {
  950. // tor_assert(cp->addr); /* these are zero for rendezvous extra-hops */
  951. // tor_assert(cp->port);
  952. tor_assert(cp);
  953. tor_assert(cp->magic == CRYPT_PATH_MAGIC);
  954. switch (cp->state)
  955. {
  956. case CPATH_STATE_OPEN:
  957. tor_assert(cp->f_crypto);
  958. tor_assert(cp->b_crypto);
  959. /* fall through */
  960. case CPATH_STATE_CLOSED:
  961. tor_assert(!cp->dh_handshake_state);
  962. break;
  963. case CPATH_STATE_AWAITING_KEYS:
  964. /* tor_assert(cp->dh_handshake_state); */
  965. break;
  966. default:
  967. log_fn(LOG_ERR, LD_BUG, "Unexpected state %d", cp->state);
  968. tor_assert(0);
  969. }
  970. tor_assert(cp->package_window >= 0);
  971. tor_assert(cp->deliver_window >= 0);
  972. }
  973. /** Verify that cpath <b>cp</b> has all of its invariants
  974. * correct. Trigger an assert if anything is invalid.
  975. */
  976. static void
  977. assert_cpath_ok(const crypt_path_t *cp)
  978. {
  979. const crypt_path_t *start = cp;
  980. do {
  981. assert_cpath_layer_ok(cp);
  982. /* layers must be in sequence of: "open* awaiting? closed*" */
  983. if (cp != start) {
  984. if (cp->state == CPATH_STATE_AWAITING_KEYS) {
  985. tor_assert(cp->prev->state == CPATH_STATE_OPEN);
  986. } else if (cp->state == CPATH_STATE_OPEN) {
  987. tor_assert(cp->prev->state == CPATH_STATE_OPEN);
  988. }
  989. }
  990. cp = cp->next;
  991. tor_assert(cp);
  992. } while (cp != start);
  993. }
  994. /** Verify that circuit <b>c</b> has all of its invariants
  995. * correct. Trigger an assert if anything is invalid.
  996. */
  997. void
  998. assert_circuit_ok(const circuit_t *c)
  999. {
  1000. edge_connection_t *conn;
  1001. const or_circuit_t *or_circ = NULL;
  1002. const origin_circuit_t *origin_circ = NULL;
  1003. tor_assert(c);
  1004. tor_assert(c->magic == ORIGIN_CIRCUIT_MAGIC || c->magic == OR_CIRCUIT_MAGIC);
  1005. tor_assert(c->purpose >= _CIRCUIT_PURPOSE_MIN &&
  1006. c->purpose <= _CIRCUIT_PURPOSE_MAX);
  1007. {
  1008. /* Having a separate variable for this pleases GCC 4.2 in ways I hope I
  1009. * never understand. -NM. */
  1010. circuit_t *nonconst_circ = (circuit_t*) c;
  1011. if (CIRCUIT_IS_ORIGIN(c))
  1012. origin_circ = TO_ORIGIN_CIRCUIT(nonconst_circ);
  1013. else
  1014. or_circ = TO_OR_CIRCUIT(nonconst_circ);
  1015. }
  1016. if (c->n_conn) {
  1017. tor_assert(!memcmp(c->n_conn->identity_digest, c->n_conn_id_digest,
  1018. DIGEST_LEN));
  1019. if (c->n_circ_id)
  1020. tor_assert(c == circuit_get_by_circid_orconn(c->n_circ_id, c->n_conn));
  1021. }
  1022. if (or_circ && or_circ->p_conn) {
  1023. if (or_circ->p_circ_id)
  1024. tor_assert(c == circuit_get_by_circid_orconn(or_circ->p_circ_id,
  1025. or_circ->p_conn));
  1026. }
  1027. #if 0 /* false now that rendezvous exits are attached to p_streams */
  1028. if (origin_circ)
  1029. for (conn = origin_circ->p_streams; conn; conn = conn->next_stream)
  1030. tor_assert(conn->_base.type == CONN_TYPE_AP);
  1031. #endif
  1032. if (or_circ)
  1033. for (conn = or_circ->n_streams; conn; conn = conn->next_stream)
  1034. tor_assert(conn->_base.type == CONN_TYPE_EXIT);
  1035. tor_assert(c->deliver_window >= 0);
  1036. tor_assert(c->package_window >= 0);
  1037. if (c->state == CIRCUIT_STATE_OPEN) {
  1038. tor_assert(!c->onionskin);
  1039. if (or_circ) {
  1040. tor_assert(or_circ->n_crypto);
  1041. tor_assert(or_circ->p_crypto);
  1042. tor_assert(or_circ->n_digest);
  1043. tor_assert(or_circ->p_digest);
  1044. }
  1045. }
  1046. if (c->state == CIRCUIT_STATE_OR_WAIT && !c->marked_for_close) {
  1047. tor_assert(circuits_pending_or_conns &&
  1048. smartlist_isin(circuits_pending_or_conns, c));
  1049. } else {
  1050. tor_assert(!circuits_pending_or_conns ||
  1051. !smartlist_isin(circuits_pending_or_conns, c));
  1052. }
  1053. if (origin_circ && origin_circ->cpath) {
  1054. assert_cpath_ok(origin_circ->cpath);
  1055. }
  1056. if (c->purpose == CIRCUIT_PURPOSE_REND_ESTABLISHED) {
  1057. tor_assert(or_circ);
  1058. if (!c->marked_for_close) {
  1059. tor_assert(or_circ->rend_splice);
  1060. tor_assert(or_circ->rend_splice->rend_splice == or_circ);
  1061. }
  1062. tor_assert(or_circ->rend_splice != or_circ);
  1063. } else {
  1064. tor_assert(!or_circ || !or_circ->rend_splice);
  1065. }
  1066. }