relay.c 110 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127
  1. /* Copyright (c) 2001 Matej Pfajfar.
  2. * Copyright (c) 2001-2004, Roger Dingledine.
  3. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  4. * Copyright (c) 2007-2017, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  6. /**
  7. * \file relay.c
  8. * \brief Handle relay cell encryption/decryption, plus packaging and
  9. * receiving from circuits, plus queuing on circuits.
  10. *
  11. * This is a core modules that makes Tor work. It's responsible for
  12. * dealing with RELAY cells (the ones that travel more than one hop along a
  13. * circuit), by:
  14. * <ul>
  15. * <li>constructing relays cells,
  16. * <li>encrypting relay cells,
  17. * <li>decrypting relay cells,
  18. * <li>demultiplexing relay cells as they arrive on a connection,
  19. * <li>queueing relay cells for retransmission,
  20. * <li>or handling relay cells that are for us to receive (as an exit or a
  21. * client).
  22. * </ul>
  23. *
  24. * RELAY cells are generated throughout the code at the client or relay side,
  25. * using relay_send_command_from_edge() or one of the functions like
  26. * connection_edge_send_command() that calls it. Of particular interest is
  27. * connection_edge_package_raw_inbuf(), which takes information that has
  28. * arrived on an edge connection socket, and packages it as a RELAY_DATA cell
  29. * -- this is how information is actually sent across the Tor network. The
  30. * cryptography for these functions is handled deep in
  31. * circuit_package_relay_cell(), which either adds a single layer of
  32. * encryption (if we're an exit), or multiple layers (if we're the origin of
  33. * the circuit). After construction and encryption, the RELAY cells are
  34. * passed to append_cell_to_circuit_queue(), which queues them for
  35. * transmission and tells the circuitmux (see circuitmux.c) that the circuit
  36. * is waiting to send something.
  37. *
  38. * Incoming RELAY cells arrive at circuit_receive_relay_cell(), called from
  39. * command.c. There they are decrypted and, if they are for us, are passed to
  40. * connection_edge_process_relay_cell(). If they're not for us, they're
  41. * re-queued for retransmission again with append_cell_to_circuit_queue().
  42. *
  43. * The connection_edge_process_relay_cell() function handles all the different
  44. * types of relay cells, launching requests or transmitting data as needed.
  45. **/
  46. #define RELAY_PRIVATE
  47. #include "or.h"
  48. #include "addressmap.h"
  49. #include "backtrace.h"
  50. #include "buffers.h"
  51. #include "channel.h"
  52. #include "circpathbias.h"
  53. #include "circuitbuild.h"
  54. #include "circuitlist.h"
  55. #include "circuituse.h"
  56. #include "compress.h"
  57. #include "config.h"
  58. #include "connection.h"
  59. #include "connection_edge.h"
  60. #include "connection_or.h"
  61. #include "control.h"
  62. #include "geoip.h"
  63. #include "hs_cache.h"
  64. #include "main.h"
  65. #include "networkstatus.h"
  66. #include "nodelist.h"
  67. #include "onion.h"
  68. #include "policies.h"
  69. #include "reasons.h"
  70. #include "relay.h"
  71. #include "rendcache.h"
  72. #include "rendcommon.h"
  73. #include "router.h"
  74. #include "routerlist.h"
  75. #include "routerparse.h"
  76. #include "scheduler.h"
  77. #include "rephist.h"
  78. static edge_connection_t *relay_lookup_conn(circuit_t *circ, cell_t *cell,
  79. cell_direction_t cell_direction,
  80. crypt_path_t *layer_hint);
  81. static int connection_edge_process_relay_cell(cell_t *cell, circuit_t *circ,
  82. edge_connection_t *conn,
  83. crypt_path_t *layer_hint);
  84. static void circuit_consider_sending_sendme(circuit_t *circ,
  85. crypt_path_t *layer_hint);
  86. static void circuit_resume_edge_reading(circuit_t *circ,
  87. crypt_path_t *layer_hint);
  88. static int circuit_resume_edge_reading_helper(edge_connection_t *conn,
  89. circuit_t *circ,
  90. crypt_path_t *layer_hint);
  91. static int circuit_consider_stop_edge_reading(circuit_t *circ,
  92. crypt_path_t *layer_hint);
  93. static int circuit_queue_streams_are_blocked(circuit_t *circ);
  94. static void adjust_exit_policy_from_exitpolicy_failure(origin_circuit_t *circ,
  95. entry_connection_t *conn,
  96. node_t *node,
  97. const tor_addr_t *addr);
  98. #if 0
  99. static int get_max_middle_cells(void);
  100. #endif
  101. /** Stop reading on edge connections when we have this many cells
  102. * waiting on the appropriate queue. */
  103. #define CELL_QUEUE_HIGHWATER_SIZE 256
  104. /** Start reading from edge connections again when we get down to this many
  105. * cells. */
  106. #define CELL_QUEUE_LOWWATER_SIZE 64
  107. /** Stats: how many relay cells have originated at this hop, or have
  108. * been relayed onward (not recognized at this hop)?
  109. */
  110. uint64_t stats_n_relay_cells_relayed = 0;
  111. /** Stats: how many relay cells have been delivered to streams at this
  112. * hop?
  113. */
  114. uint64_t stats_n_relay_cells_delivered = 0;
  115. /** Used to tell which stream to read from first on a circuit. */
  116. static tor_weak_rng_t stream_choice_rng = TOR_WEAK_RNG_INIT;
  117. /** Update digest from the payload of cell. Assign integrity part to
  118. * cell.
  119. */
  120. static void
  121. relay_set_digest(crypto_digest_t *digest, cell_t *cell)
  122. {
  123. char integrity[4];
  124. relay_header_t rh;
  125. crypto_digest_add_bytes(digest, (char*)cell->payload, CELL_PAYLOAD_SIZE);
  126. crypto_digest_get_digest(digest, integrity, 4);
  127. // log_fn(LOG_DEBUG,"Putting digest of %u %u %u %u into relay cell.",
  128. // integrity[0], integrity[1], integrity[2], integrity[3]);
  129. relay_header_unpack(&rh, cell->payload);
  130. memcpy(rh.integrity, integrity, 4);
  131. relay_header_pack(cell->payload, &rh);
  132. }
  133. /** Does the digest for this circuit indicate that this cell is for us?
  134. *
  135. * Update digest from the payload of cell (with the integrity part set
  136. * to 0). If the integrity part is valid, return 1, else restore digest
  137. * and cell to their original state and return 0.
  138. */
  139. static int
  140. relay_digest_matches(crypto_digest_t *digest, cell_t *cell)
  141. {
  142. uint32_t received_integrity, calculated_integrity;
  143. relay_header_t rh;
  144. crypto_digest_t *backup_digest=NULL;
  145. backup_digest = crypto_digest_dup(digest);
  146. relay_header_unpack(&rh, cell->payload);
  147. memcpy(&received_integrity, rh.integrity, 4);
  148. memset(rh.integrity, 0, 4);
  149. relay_header_pack(cell->payload, &rh);
  150. // log_fn(LOG_DEBUG,"Reading digest of %u %u %u %u from relay cell.",
  151. // received_integrity[0], received_integrity[1],
  152. // received_integrity[2], received_integrity[3]);
  153. crypto_digest_add_bytes(digest, (char*) cell->payload, CELL_PAYLOAD_SIZE);
  154. crypto_digest_get_digest(digest, (char*) &calculated_integrity, 4);
  155. if (calculated_integrity != received_integrity) {
  156. // log_fn(LOG_INFO,"Recognized=0 but bad digest. Not recognizing.");
  157. // (%d vs %d).", received_integrity, calculated_integrity);
  158. /* restore digest to its old form */
  159. crypto_digest_assign(digest, backup_digest);
  160. /* restore the relay header */
  161. memcpy(rh.integrity, &received_integrity, 4);
  162. relay_header_pack(cell->payload, &rh);
  163. crypto_digest_free(backup_digest);
  164. return 0;
  165. }
  166. crypto_digest_free(backup_digest);
  167. return 1;
  168. }
  169. /** Apply <b>cipher</b> to CELL_PAYLOAD_SIZE bytes of <b>in</b>
  170. * (in place).
  171. *
  172. * Note that we use the same operation for encrypting and for decrypting.
  173. */
  174. static void
  175. relay_crypt_one_payload(crypto_cipher_t *cipher, uint8_t *in)
  176. {
  177. crypto_cipher_crypt_inplace(cipher, (char*) in, CELL_PAYLOAD_SIZE);
  178. }
  179. /**
  180. * Update channel usage state based on the type of relay cell and
  181. * circuit properties.
  182. *
  183. * This is needed to determine if a client channel is being
  184. * used for application traffic, and if a relay channel is being
  185. * used for multihop circuits and application traffic. The decision
  186. * to pad in channelpadding.c depends upon this info (as well as
  187. * consensus parameters) to decide what channels to pad.
  188. */
  189. static void
  190. circuit_update_channel_usage(circuit_t *circ, cell_t *cell)
  191. {
  192. if (CIRCUIT_IS_ORIGIN(circ)) {
  193. /*
  194. * The client state was first set much earlier in
  195. * circuit_send_next_onion_skin(), so we can start padding as early as
  196. * possible.
  197. *
  198. * However, if padding turns out to be expensive, we may want to not do
  199. * it until actual application traffic starts flowing (which is controlled
  200. * via consensus param nf_pad_before_usage).
  201. *
  202. * So: If we're an origin circuit and we've created a full length circuit,
  203. * then any CELL_RELAY cell means application data. Increase the usage
  204. * state of the channel to indicate this.
  205. *
  206. * We want to wait for CELL_RELAY specifically here, so we know that
  207. * the channel was definitely being used for data and not for extends.
  208. * By default, we pad as soon as a channel has been used for *any*
  209. * circuits, so this state is irrelevant to the padding decision in
  210. * the default case. However, if padding turns out to be expensive,
  211. * we would like the ability to avoid padding until we're absolutely
  212. * sure that a channel is used for enough application data to be worth
  213. * padding.
  214. *
  215. * (So it does not matter that CELL_RELAY_EARLY can actually contain
  216. * application data. This is only a load reducing option and that edge
  217. * case does not matter if we're desperately trying to reduce overhead
  218. * anyway. See also consensus parameter nf_pad_before_usage).
  219. */
  220. if (BUG(!circ->n_chan))
  221. return;
  222. if (circ->n_chan->channel_usage == CHANNEL_USED_FOR_FULL_CIRCS &&
  223. cell->command == CELL_RELAY) {
  224. circ->n_chan->channel_usage = CHANNEL_USED_FOR_USER_TRAFFIC;
  225. }
  226. } else {
  227. /* If we're a relay circuit, the question is more complicated. Basically:
  228. * we only want to pad connections that carry multihop (anonymous)
  229. * circuits.
  230. *
  231. * We assume we're more than one hop if either the previous hop
  232. * is not a client, or if the previous hop is a client and there's
  233. * a next hop. Then, circuit traffic starts at RELAY_EARLY, and
  234. * user application traffic starts when we see RELAY cells.
  235. */
  236. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  237. if (BUG(!or_circ->p_chan))
  238. return;
  239. if (!channel_is_client(or_circ->p_chan) ||
  240. (channel_is_client(or_circ->p_chan) && circ->n_chan)) {
  241. if (cell->command == CELL_RELAY_EARLY) {
  242. if (or_circ->p_chan->channel_usage < CHANNEL_USED_FOR_FULL_CIRCS) {
  243. or_circ->p_chan->channel_usage = CHANNEL_USED_FOR_FULL_CIRCS;
  244. }
  245. } else if (cell->command == CELL_RELAY) {
  246. or_circ->p_chan->channel_usage = CHANNEL_USED_FOR_USER_TRAFFIC;
  247. }
  248. }
  249. }
  250. }
  251. /** Receive a relay cell:
  252. * - Crypt it (encrypt if headed toward the origin or if we <b>are</b> the
  253. * origin; decrypt if we're headed toward the exit).
  254. * - Check if recognized (if exitward).
  255. * - If recognized and the digest checks out, then find if there's a stream
  256. * that the cell is intended for, and deliver it to the right
  257. * connection_edge.
  258. * - If not recognized, then we need to relay it: append it to the appropriate
  259. * cell_queue on <b>circ</b>.
  260. *
  261. * Return -<b>reason</b> on failure.
  262. */
  263. int
  264. circuit_receive_relay_cell(cell_t *cell, circuit_t *circ,
  265. cell_direction_t cell_direction)
  266. {
  267. channel_t *chan = NULL;
  268. crypt_path_t *layer_hint=NULL;
  269. char recognized=0;
  270. int reason;
  271. tor_assert(cell);
  272. tor_assert(circ);
  273. tor_assert(cell_direction == CELL_DIRECTION_OUT ||
  274. cell_direction == CELL_DIRECTION_IN);
  275. if (circ->marked_for_close)
  276. return 0;
  277. if (relay_crypt(circ, cell, cell_direction, &layer_hint, &recognized) < 0) {
  278. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  279. "relay crypt failed. Dropping connection.");
  280. return -END_CIRC_REASON_INTERNAL;
  281. }
  282. circuit_update_channel_usage(circ, cell);
  283. if (recognized) {
  284. edge_connection_t *conn = NULL;
  285. if (circ->purpose == CIRCUIT_PURPOSE_PATH_BIAS_TESTING) {
  286. pathbias_check_probe_response(circ, cell);
  287. /* We need to drop this cell no matter what to avoid code that expects
  288. * a certain purpose (such as the hidserv code). */
  289. return 0;
  290. }
  291. conn = relay_lookup_conn(circ, cell, cell_direction, layer_hint);
  292. if (cell_direction == CELL_DIRECTION_OUT) {
  293. ++stats_n_relay_cells_delivered;
  294. log_debug(LD_OR,"Sending away from origin.");
  295. if ((reason=connection_edge_process_relay_cell(cell, circ, conn, NULL))
  296. < 0) {
  297. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  298. "connection_edge_process_relay_cell (away from origin) "
  299. "failed.");
  300. return reason;
  301. }
  302. }
  303. if (cell_direction == CELL_DIRECTION_IN) {
  304. ++stats_n_relay_cells_delivered;
  305. log_debug(LD_OR,"Sending to origin.");
  306. if ((reason = connection_edge_process_relay_cell(cell, circ, conn,
  307. layer_hint)) < 0) {
  308. /* If a client is trying to connect to unknown hidden service port,
  309. * END_CIRC_AT_ORIGIN is sent back so we can then close the circuit.
  310. * Do not log warn as this is an expected behavior for a service. */
  311. if (reason != END_CIRC_AT_ORIGIN) {
  312. log_warn(LD_OR,
  313. "connection_edge_process_relay_cell (at origin) failed.");
  314. }
  315. return reason;
  316. }
  317. }
  318. return 0;
  319. }
  320. /* not recognized. pass it on. */
  321. if (cell_direction == CELL_DIRECTION_OUT) {
  322. cell->circ_id = circ->n_circ_id; /* switch it */
  323. chan = circ->n_chan;
  324. } else if (! CIRCUIT_IS_ORIGIN(circ)) {
  325. cell->circ_id = TO_OR_CIRCUIT(circ)->p_circ_id; /* switch it */
  326. chan = TO_OR_CIRCUIT(circ)->p_chan;
  327. } else {
  328. log_fn(LOG_PROTOCOL_WARN, LD_OR,
  329. "Dropping unrecognized inbound cell on origin circuit.");
  330. /* If we see unrecognized cells on path bias testing circs,
  331. * it's bad mojo. Those circuits need to die.
  332. * XXX: Shouldn't they always die? */
  333. if (circ->purpose == CIRCUIT_PURPOSE_PATH_BIAS_TESTING) {
  334. TO_ORIGIN_CIRCUIT(circ)->path_state = PATH_STATE_USE_FAILED;
  335. return -END_CIRC_REASON_TORPROTOCOL;
  336. } else {
  337. return 0;
  338. }
  339. }
  340. if (!chan) {
  341. // XXXX Can this splice stuff be done more cleanly?
  342. if (! CIRCUIT_IS_ORIGIN(circ) &&
  343. TO_OR_CIRCUIT(circ)->rend_splice &&
  344. cell_direction == CELL_DIRECTION_OUT) {
  345. or_circuit_t *splice_ = TO_OR_CIRCUIT(circ)->rend_splice;
  346. tor_assert(circ->purpose == CIRCUIT_PURPOSE_REND_ESTABLISHED);
  347. tor_assert(splice_->base_.purpose == CIRCUIT_PURPOSE_REND_ESTABLISHED);
  348. cell->circ_id = splice_->p_circ_id;
  349. cell->command = CELL_RELAY; /* can't be relay_early anyway */
  350. if ((reason = circuit_receive_relay_cell(cell, TO_CIRCUIT(splice_),
  351. CELL_DIRECTION_IN)) < 0) {
  352. log_warn(LD_REND, "Error relaying cell across rendezvous; closing "
  353. "circuits");
  354. /* XXXX Do this here, or just return -1? */
  355. circuit_mark_for_close(circ, -reason);
  356. return reason;
  357. }
  358. return 0;
  359. }
  360. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  361. "Didn't recognize cell, but circ stops here! Closing circ.");
  362. return -END_CIRC_REASON_TORPROTOCOL;
  363. }
  364. log_debug(LD_OR,"Passing on unrecognized cell.");
  365. ++stats_n_relay_cells_relayed; /* XXXX no longer quite accurate {cells}
  366. * we might kill the circ before we relay
  367. * the cells. */
  368. append_cell_to_circuit_queue(circ, chan, cell, cell_direction, 0);
  369. return 0;
  370. }
  371. /** Do the appropriate en/decryptions for <b>cell</b> arriving on
  372. * <b>circ</b> in direction <b>cell_direction</b>.
  373. *
  374. * If cell_direction == CELL_DIRECTION_IN:
  375. * - If we're at the origin (we're the OP), for hops 1..N,
  376. * decrypt cell. If recognized, stop.
  377. * - Else (we're not the OP), encrypt one hop. Cell is not recognized.
  378. *
  379. * If cell_direction == CELL_DIRECTION_OUT:
  380. * - decrypt one hop. Check if recognized.
  381. *
  382. * If cell is recognized, set *recognized to 1, and set
  383. * *layer_hint to the hop that recognized it.
  384. *
  385. * Return -1 to indicate that we should mark the circuit for close,
  386. * else return 0.
  387. */
  388. int
  389. relay_crypt(circuit_t *circ, cell_t *cell, cell_direction_t cell_direction,
  390. crypt_path_t **layer_hint, char *recognized)
  391. {
  392. relay_header_t rh;
  393. tor_assert(circ);
  394. tor_assert(cell);
  395. tor_assert(recognized);
  396. tor_assert(cell_direction == CELL_DIRECTION_IN ||
  397. cell_direction == CELL_DIRECTION_OUT);
  398. if (cell_direction == CELL_DIRECTION_IN) {
  399. if (CIRCUIT_IS_ORIGIN(circ)) { /* We're at the beginning of the circuit.
  400. * We'll want to do layered decrypts. */
  401. crypt_path_t *thishop, *cpath = TO_ORIGIN_CIRCUIT(circ)->cpath;
  402. thishop = cpath;
  403. if (thishop->state != CPATH_STATE_OPEN) {
  404. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  405. "Relay cell before first created cell? Closing.");
  406. return -1;
  407. }
  408. do { /* Remember: cpath is in forward order, that is, first hop first. */
  409. tor_assert(thishop);
  410. /* decrypt one layer */
  411. relay_crypt_one_payload(thishop->b_crypto, cell->payload);
  412. relay_header_unpack(&rh, cell->payload);
  413. if (rh.recognized == 0) {
  414. /* it's possibly recognized. have to check digest to be sure. */
  415. if (relay_digest_matches(thishop->b_digest, cell)) {
  416. *recognized = 1;
  417. *layer_hint = thishop;
  418. return 0;
  419. }
  420. }
  421. thishop = thishop->next;
  422. } while (thishop != cpath && thishop->state == CPATH_STATE_OPEN);
  423. log_fn(LOG_PROTOCOL_WARN, LD_OR,
  424. "Incoming cell at client not recognized. Closing.");
  425. return -1;
  426. } else {
  427. /* We're in the middle. Encrypt one layer. */
  428. relay_crypt_one_payload(TO_OR_CIRCUIT(circ)->p_crypto, cell->payload);
  429. }
  430. } else /* cell_direction == CELL_DIRECTION_OUT */ {
  431. /* We're in the middle. Decrypt one layer. */
  432. relay_crypt_one_payload(TO_OR_CIRCUIT(circ)->n_crypto, cell->payload);
  433. relay_header_unpack(&rh, cell->payload);
  434. if (rh.recognized == 0) {
  435. /* it's possibly recognized. have to check digest to be sure. */
  436. if (relay_digest_matches(TO_OR_CIRCUIT(circ)->n_digest, cell)) {
  437. *recognized = 1;
  438. return 0;
  439. }
  440. }
  441. }
  442. return 0;
  443. }
  444. /** Package a relay cell from an edge:
  445. * - Encrypt it to the right layer
  446. * - Append it to the appropriate cell_queue on <b>circ</b>.
  447. */
  448. static int
  449. circuit_package_relay_cell(cell_t *cell, circuit_t *circ,
  450. cell_direction_t cell_direction,
  451. crypt_path_t *layer_hint, streamid_t on_stream,
  452. const char *filename, int lineno)
  453. {
  454. channel_t *chan; /* where to send the cell */
  455. if (circ->marked_for_close) {
  456. /* Circuit is marked; send nothing. */
  457. return 0;
  458. }
  459. if (cell_direction == CELL_DIRECTION_OUT) {
  460. crypt_path_t *thishop; /* counter for repeated crypts */
  461. chan = circ->n_chan;
  462. if (!chan) {
  463. log_warn(LD_BUG,"outgoing relay cell sent from %s:%d has n_chan==NULL."
  464. " Dropping. Circuit is in state %s (%d), and is "
  465. "%smarked for close. (%s:%d, %d)", filename, lineno,
  466. circuit_state_to_string(circ->state), circ->state,
  467. circ->marked_for_close ? "" : "not ",
  468. circ->marked_for_close_file?circ->marked_for_close_file:"",
  469. circ->marked_for_close, circ->marked_for_close_reason);
  470. if (CIRCUIT_IS_ORIGIN(circ)) {
  471. circuit_log_path(LOG_WARN, LD_BUG, TO_ORIGIN_CIRCUIT(circ));
  472. }
  473. log_backtrace(LOG_WARN,LD_BUG,"");
  474. return 0; /* just drop it */
  475. }
  476. if (!CIRCUIT_IS_ORIGIN(circ)) {
  477. log_warn(LD_BUG,"outgoing relay cell sent from %s:%d on non-origin "
  478. "circ. Dropping.", filename, lineno);
  479. log_backtrace(LOG_WARN,LD_BUG,"");
  480. return 0; /* just drop it */
  481. }
  482. relay_set_digest(layer_hint->f_digest, cell);
  483. thishop = layer_hint;
  484. /* moving from farthest to nearest hop */
  485. do {
  486. tor_assert(thishop);
  487. log_debug(LD_OR,"encrypting a layer of the relay cell.");
  488. relay_crypt_one_payload(thishop->f_crypto, cell->payload);
  489. thishop = thishop->prev;
  490. } while (thishop != TO_ORIGIN_CIRCUIT(circ)->cpath->prev);
  491. } else { /* incoming cell */
  492. or_circuit_t *or_circ;
  493. if (CIRCUIT_IS_ORIGIN(circ)) {
  494. /* We should never package an _incoming_ cell from the circuit
  495. * origin; that means we messed up somewhere. */
  496. log_warn(LD_BUG,"incoming relay cell at origin circuit. Dropping.");
  497. assert_circuit_ok(circ);
  498. return 0; /* just drop it */
  499. }
  500. or_circ = TO_OR_CIRCUIT(circ);
  501. chan = or_circ->p_chan;
  502. relay_set_digest(or_circ->p_digest, cell);
  503. /* encrypt one layer */
  504. relay_crypt_one_payload(or_circ->p_crypto, cell->payload);
  505. }
  506. ++stats_n_relay_cells_relayed;
  507. append_cell_to_circuit_queue(circ, chan, cell, cell_direction, on_stream);
  508. return 0;
  509. }
  510. /** If cell's stream_id matches the stream_id of any conn that's
  511. * attached to circ, return that conn, else return NULL.
  512. */
  513. static edge_connection_t *
  514. relay_lookup_conn(circuit_t *circ, cell_t *cell,
  515. cell_direction_t cell_direction, crypt_path_t *layer_hint)
  516. {
  517. edge_connection_t *tmpconn;
  518. relay_header_t rh;
  519. relay_header_unpack(&rh, cell->payload);
  520. if (!rh.stream_id)
  521. return NULL;
  522. /* IN or OUT cells could have come from either direction, now
  523. * that we allow rendezvous *to* an OP.
  524. */
  525. if (CIRCUIT_IS_ORIGIN(circ)) {
  526. for (tmpconn = TO_ORIGIN_CIRCUIT(circ)->p_streams; tmpconn;
  527. tmpconn=tmpconn->next_stream) {
  528. if (rh.stream_id == tmpconn->stream_id &&
  529. !tmpconn->base_.marked_for_close &&
  530. tmpconn->cpath_layer == layer_hint) {
  531. log_debug(LD_APP,"found conn for stream %d.", rh.stream_id);
  532. return tmpconn;
  533. }
  534. }
  535. } else {
  536. for (tmpconn = TO_OR_CIRCUIT(circ)->n_streams; tmpconn;
  537. tmpconn=tmpconn->next_stream) {
  538. if (rh.stream_id == tmpconn->stream_id &&
  539. !tmpconn->base_.marked_for_close) {
  540. log_debug(LD_EXIT,"found conn for stream %d.", rh.stream_id);
  541. if (cell_direction == CELL_DIRECTION_OUT ||
  542. connection_edge_is_rendezvous_stream(tmpconn))
  543. return tmpconn;
  544. }
  545. }
  546. for (tmpconn = TO_OR_CIRCUIT(circ)->resolving_streams; tmpconn;
  547. tmpconn=tmpconn->next_stream) {
  548. if (rh.stream_id == tmpconn->stream_id &&
  549. !tmpconn->base_.marked_for_close) {
  550. log_debug(LD_EXIT,"found conn for stream %d.", rh.stream_id);
  551. return tmpconn;
  552. }
  553. }
  554. }
  555. return NULL; /* probably a begin relay cell */
  556. }
  557. /** Pack the relay_header_t host-order structure <b>src</b> into
  558. * network-order in the buffer <b>dest</b>. See tor-spec.txt for details
  559. * about the wire format.
  560. */
  561. void
  562. relay_header_pack(uint8_t *dest, const relay_header_t *src)
  563. {
  564. set_uint8(dest, src->command);
  565. set_uint16(dest+1, htons(src->recognized));
  566. set_uint16(dest+3, htons(src->stream_id));
  567. memcpy(dest+5, src->integrity, 4);
  568. set_uint16(dest+9, htons(src->length));
  569. }
  570. /** Unpack the network-order buffer <b>src</b> into a host-order
  571. * relay_header_t structure <b>dest</b>.
  572. */
  573. void
  574. relay_header_unpack(relay_header_t *dest, const uint8_t *src)
  575. {
  576. dest->command = get_uint8(src);
  577. dest->recognized = ntohs(get_uint16(src+1));
  578. dest->stream_id = ntohs(get_uint16(src+3));
  579. memcpy(dest->integrity, src+5, 4);
  580. dest->length = ntohs(get_uint16(src+9));
  581. }
  582. /** Convert the relay <b>command</b> into a human-readable string. */
  583. static const char *
  584. relay_command_to_string(uint8_t command)
  585. {
  586. static char buf[64];
  587. switch (command) {
  588. case RELAY_COMMAND_BEGIN: return "BEGIN";
  589. case RELAY_COMMAND_DATA: return "DATA";
  590. case RELAY_COMMAND_END: return "END";
  591. case RELAY_COMMAND_CONNECTED: return "CONNECTED";
  592. case RELAY_COMMAND_SENDME: return "SENDME";
  593. case RELAY_COMMAND_EXTEND: return "EXTEND";
  594. case RELAY_COMMAND_EXTENDED: return "EXTENDED";
  595. case RELAY_COMMAND_TRUNCATE: return "TRUNCATE";
  596. case RELAY_COMMAND_TRUNCATED: return "TRUNCATED";
  597. case RELAY_COMMAND_DROP: return "DROP";
  598. case RELAY_COMMAND_RESOLVE: return "RESOLVE";
  599. case RELAY_COMMAND_RESOLVED: return "RESOLVED";
  600. case RELAY_COMMAND_BEGIN_DIR: return "BEGIN_DIR";
  601. case RELAY_COMMAND_ESTABLISH_INTRO: return "ESTABLISH_INTRO";
  602. case RELAY_COMMAND_ESTABLISH_RENDEZVOUS: return "ESTABLISH_RENDEZVOUS";
  603. case RELAY_COMMAND_INTRODUCE1: return "INTRODUCE1";
  604. case RELAY_COMMAND_INTRODUCE2: return "INTRODUCE2";
  605. case RELAY_COMMAND_RENDEZVOUS1: return "RENDEZVOUS1";
  606. case RELAY_COMMAND_RENDEZVOUS2: return "RENDEZVOUS2";
  607. case RELAY_COMMAND_INTRO_ESTABLISHED: return "INTRO_ESTABLISHED";
  608. case RELAY_COMMAND_RENDEZVOUS_ESTABLISHED:
  609. return "RENDEZVOUS_ESTABLISHED";
  610. case RELAY_COMMAND_INTRODUCE_ACK: return "INTRODUCE_ACK";
  611. case RELAY_COMMAND_EXTEND2: return "EXTEND2";
  612. case RELAY_COMMAND_EXTENDED2: return "EXTENDED2";
  613. default:
  614. tor_snprintf(buf, sizeof(buf), "Unrecognized relay command %u",
  615. (unsigned)command);
  616. return buf;
  617. }
  618. }
  619. /** Make a relay cell out of <b>relay_command</b> and <b>payload</b>, and send
  620. * it onto the open circuit <b>circ</b>. <b>stream_id</b> is the ID on
  621. * <b>circ</b> for the stream that's sending the relay cell, or 0 if it's a
  622. * control cell. <b>cpath_layer</b> is NULL for OR->OP cells, or the
  623. * destination hop for OP->OR cells.
  624. *
  625. * If you can't send the cell, mark the circuit for close and return -1. Else
  626. * return 0.
  627. */
  628. MOCK_IMPL(int,
  629. relay_send_command_from_edge_,(streamid_t stream_id, circuit_t *circ,
  630. uint8_t relay_command, const char *payload,
  631. size_t payload_len, crypt_path_t *cpath_layer,
  632. const char *filename, int lineno))
  633. {
  634. cell_t cell;
  635. relay_header_t rh;
  636. cell_direction_t cell_direction;
  637. /* XXXX NM Split this function into a separate versions per circuit type? */
  638. tor_assert(circ);
  639. tor_assert(payload_len <= RELAY_PAYLOAD_SIZE);
  640. memset(&cell, 0, sizeof(cell_t));
  641. cell.command = CELL_RELAY;
  642. if (CIRCUIT_IS_ORIGIN(circ)) {
  643. tor_assert(cpath_layer);
  644. cell.circ_id = circ->n_circ_id;
  645. cell_direction = CELL_DIRECTION_OUT;
  646. } else {
  647. tor_assert(! cpath_layer);
  648. cell.circ_id = TO_OR_CIRCUIT(circ)->p_circ_id;
  649. cell_direction = CELL_DIRECTION_IN;
  650. }
  651. memset(&rh, 0, sizeof(rh));
  652. rh.command = relay_command;
  653. rh.stream_id = stream_id;
  654. rh.length = payload_len;
  655. relay_header_pack(cell.payload, &rh);
  656. if (payload_len)
  657. memcpy(cell.payload+RELAY_HEADER_SIZE, payload, payload_len);
  658. log_debug(LD_OR,"delivering %d cell %s.", relay_command,
  659. cell_direction == CELL_DIRECTION_OUT ? "forward" : "backward");
  660. if (relay_command == RELAY_COMMAND_DROP)
  661. rep_hist_padding_count_write(PADDING_TYPE_DROP);
  662. /* If we are sending an END cell and this circuit is used for a tunneled
  663. * directory request, advance its state. */
  664. if (relay_command == RELAY_COMMAND_END && circ->dirreq_id)
  665. geoip_change_dirreq_state(circ->dirreq_id, DIRREQ_TUNNELED,
  666. DIRREQ_END_CELL_SENT);
  667. if (cell_direction == CELL_DIRECTION_OUT && circ->n_chan) {
  668. /* if we're using relaybandwidthrate, this conn wants priority */
  669. channel_timestamp_client(circ->n_chan);
  670. }
  671. if (cell_direction == CELL_DIRECTION_OUT) {
  672. origin_circuit_t *origin_circ = TO_ORIGIN_CIRCUIT(circ);
  673. if (origin_circ->remaining_relay_early_cells > 0 &&
  674. (relay_command == RELAY_COMMAND_EXTEND ||
  675. relay_command == RELAY_COMMAND_EXTEND2 ||
  676. cpath_layer != origin_circ->cpath)) {
  677. /* If we've got any relay_early cells left and (we're sending
  678. * an extend cell or we're not talking to the first hop), use
  679. * one of them. Don't worry about the conn protocol version:
  680. * append_cell_to_circuit_queue will fix it up. */
  681. cell.command = CELL_RELAY_EARLY;
  682. --origin_circ->remaining_relay_early_cells;
  683. log_debug(LD_OR, "Sending a RELAY_EARLY cell; %d remaining.",
  684. (int)origin_circ->remaining_relay_early_cells);
  685. /* Memorize the command that is sent as RELAY_EARLY cell; helps debug
  686. * task 878. */
  687. origin_circ->relay_early_commands[
  688. origin_circ->relay_early_cells_sent++] = relay_command;
  689. } else if (relay_command == RELAY_COMMAND_EXTEND ||
  690. relay_command == RELAY_COMMAND_EXTEND2) {
  691. /* If no RELAY_EARLY cells can be sent over this circuit, log which
  692. * commands have been sent as RELAY_EARLY cells before; helps debug
  693. * task 878. */
  694. smartlist_t *commands_list = smartlist_new();
  695. int i = 0;
  696. char *commands = NULL;
  697. for (; i < origin_circ->relay_early_cells_sent; i++)
  698. smartlist_add(commands_list, (char *)
  699. relay_command_to_string(origin_circ->relay_early_commands[i]));
  700. commands = smartlist_join_strings(commands_list, ",", 0, NULL);
  701. log_warn(LD_BUG, "Uh-oh. We're sending a RELAY_COMMAND_EXTEND cell, "
  702. "but we have run out of RELAY_EARLY cells on that circuit. "
  703. "Commands sent before: %s", commands);
  704. tor_free(commands);
  705. smartlist_free(commands_list);
  706. }
  707. }
  708. if (circuit_package_relay_cell(&cell, circ, cell_direction, cpath_layer,
  709. stream_id, filename, lineno) < 0) {
  710. log_warn(LD_BUG,"circuit_package_relay_cell failed. Closing.");
  711. circuit_mark_for_close(circ, END_CIRC_REASON_INTERNAL);
  712. return -1;
  713. }
  714. return 0;
  715. }
  716. /** Make a relay cell out of <b>relay_command</b> and <b>payload</b>, and
  717. * send it onto the open circuit <b>circ</b>. <b>fromconn</b> is the stream
  718. * that's sending the relay cell, or NULL if it's a control cell.
  719. * <b>cpath_layer</b> is NULL for OR->OP cells, or the destination hop
  720. * for OP->OR cells.
  721. *
  722. * If you can't send the cell, mark the circuit for close and
  723. * return -1. Else return 0.
  724. */
  725. int
  726. connection_edge_send_command(edge_connection_t *fromconn,
  727. uint8_t relay_command, const char *payload,
  728. size_t payload_len)
  729. {
  730. /* XXXX NM Split this function into a separate versions per circuit type? */
  731. circuit_t *circ;
  732. crypt_path_t *cpath_layer = fromconn->cpath_layer;
  733. tor_assert(fromconn);
  734. circ = fromconn->on_circuit;
  735. if (fromconn->base_.marked_for_close) {
  736. log_warn(LD_BUG,
  737. "called on conn that's already marked for close at %s:%d.",
  738. fromconn->base_.marked_for_close_file,
  739. fromconn->base_.marked_for_close);
  740. return 0;
  741. }
  742. if (!circ) {
  743. if (fromconn->base_.type == CONN_TYPE_AP) {
  744. log_info(LD_APP,"no circ. Closing conn.");
  745. connection_mark_unattached_ap(EDGE_TO_ENTRY_CONN(fromconn),
  746. END_STREAM_REASON_INTERNAL);
  747. } else {
  748. log_info(LD_EXIT,"no circ. Closing conn.");
  749. fromconn->edge_has_sent_end = 1; /* no circ to send to */
  750. fromconn->end_reason = END_STREAM_REASON_INTERNAL;
  751. connection_mark_for_close(TO_CONN(fromconn));
  752. }
  753. return -1;
  754. }
  755. if (circ->marked_for_close) {
  756. /* The circuit has been marked, but not freed yet. When it's freed, it
  757. * will mark this connection for close. */
  758. return -1;
  759. }
  760. #ifdef MEASUREMENTS_21206
  761. /* Keep track of the number of RELAY_DATA cells sent for directory
  762. * connections. */
  763. connection_t *linked_conn = TO_CONN(fromconn)->linked_conn;
  764. if (linked_conn && linked_conn->type == CONN_TYPE_DIR) {
  765. ++(TO_DIR_CONN(linked_conn)->data_cells_sent);
  766. }
  767. #endif /* defined(MEASUREMENTS_21206) */
  768. return relay_send_command_from_edge(fromconn->stream_id, circ,
  769. relay_command, payload,
  770. payload_len, cpath_layer);
  771. }
  772. /** How many times will I retry a stream that fails due to DNS
  773. * resolve failure or misc error?
  774. */
  775. #define MAX_RESOLVE_FAILURES 3
  776. /** Return 1 if reason is something that you should retry if you
  777. * get the end cell before you've connected; else return 0. */
  778. static int
  779. edge_reason_is_retriable(int reason)
  780. {
  781. return reason == END_STREAM_REASON_HIBERNATING ||
  782. reason == END_STREAM_REASON_RESOURCELIMIT ||
  783. reason == END_STREAM_REASON_EXITPOLICY ||
  784. reason == END_STREAM_REASON_RESOLVEFAILED ||
  785. reason == END_STREAM_REASON_MISC ||
  786. reason == END_STREAM_REASON_NOROUTE;
  787. }
  788. /** Called when we receive an END cell on a stream that isn't open yet,
  789. * from the client side.
  790. * Arguments are as for connection_edge_process_relay_cell().
  791. */
  792. static int
  793. connection_ap_process_end_not_open(
  794. relay_header_t *rh, cell_t *cell, origin_circuit_t *circ,
  795. entry_connection_t *conn, crypt_path_t *layer_hint)
  796. {
  797. node_t *exitrouter;
  798. int reason = *(cell->payload+RELAY_HEADER_SIZE);
  799. int control_reason;
  800. edge_connection_t *edge_conn = ENTRY_TO_EDGE_CONN(conn);
  801. (void) layer_hint; /* unused */
  802. if (rh->length > 0) {
  803. if (reason == END_STREAM_REASON_TORPROTOCOL ||
  804. reason == END_STREAM_REASON_DESTROY) {
  805. /* Both of these reasons could mean a failed tag
  806. * hit the exit and it complained. Do not probe.
  807. * Fail the circuit. */
  808. circ->path_state = PATH_STATE_USE_FAILED;
  809. return -END_CIRC_REASON_TORPROTOCOL;
  810. } else if (reason == END_STREAM_REASON_INTERNAL) {
  811. /* We can't infer success or failure, since older Tors report
  812. * ENETUNREACH as END_STREAM_REASON_INTERNAL. */
  813. } else {
  814. /* Path bias: If we get a valid reason code from the exit,
  815. * it wasn't due to tagging.
  816. *
  817. * We rely on recognized+digest being strong enough to make
  818. * tags unlikely to allow us to get tagged, yet 'recognized'
  819. * reason codes here. */
  820. pathbias_mark_use_success(circ);
  821. }
  822. }
  823. if (rh->length == 0) {
  824. reason = END_STREAM_REASON_MISC;
  825. }
  826. control_reason = reason | END_STREAM_REASON_FLAG_REMOTE;
  827. if (edge_reason_is_retriable(reason) &&
  828. /* avoid retry if rend */
  829. !connection_edge_is_rendezvous_stream(edge_conn)) {
  830. const char *chosen_exit_digest =
  831. circ->build_state->chosen_exit->identity_digest;
  832. log_info(LD_APP,"Address '%s' refused due to '%s'. Considering retrying.",
  833. safe_str(conn->socks_request->address),
  834. stream_end_reason_to_string(reason));
  835. exitrouter = node_get_mutable_by_id(chosen_exit_digest);
  836. switch (reason) {
  837. case END_STREAM_REASON_EXITPOLICY: {
  838. tor_addr_t addr;
  839. tor_addr_make_unspec(&addr);
  840. if (rh->length >= 5) {
  841. int ttl = -1;
  842. tor_addr_make_unspec(&addr);
  843. if (rh->length == 5 || rh->length == 9) {
  844. tor_addr_from_ipv4n(&addr,
  845. get_uint32(cell->payload+RELAY_HEADER_SIZE+1));
  846. if (rh->length == 9)
  847. ttl = (int)ntohl(get_uint32(cell->payload+RELAY_HEADER_SIZE+5));
  848. } else if (rh->length == 17 || rh->length == 21) {
  849. tor_addr_from_ipv6_bytes(&addr,
  850. (char*)(cell->payload+RELAY_HEADER_SIZE+1));
  851. if (rh->length == 21)
  852. ttl = (int)ntohl(get_uint32(cell->payload+RELAY_HEADER_SIZE+17));
  853. }
  854. if (tor_addr_is_null(&addr)) {
  855. log_info(LD_APP,"Address '%s' resolved to 0.0.0.0. Closing,",
  856. safe_str(conn->socks_request->address));
  857. connection_mark_unattached_ap(conn, END_STREAM_REASON_TORPROTOCOL);
  858. return 0;
  859. }
  860. if ((tor_addr_family(&addr) == AF_INET &&
  861. !conn->entry_cfg.ipv4_traffic) ||
  862. (tor_addr_family(&addr) == AF_INET6 &&
  863. !conn->entry_cfg.ipv6_traffic)) {
  864. log_fn(LOG_PROTOCOL_WARN, LD_APP,
  865. "Got an EXITPOLICY failure on a connection with a "
  866. "mismatched family. Closing.");
  867. connection_mark_unattached_ap(conn, END_STREAM_REASON_TORPROTOCOL);
  868. return 0;
  869. }
  870. if (get_options()->ClientDNSRejectInternalAddresses &&
  871. tor_addr_is_internal(&addr, 0)) {
  872. log_info(LD_APP,"Address '%s' resolved to internal. Closing,",
  873. safe_str(conn->socks_request->address));
  874. connection_mark_unattached_ap(conn, END_STREAM_REASON_TORPROTOCOL);
  875. return 0;
  876. }
  877. client_dns_set_addressmap(conn,
  878. conn->socks_request->address, &addr,
  879. conn->chosen_exit_name, ttl);
  880. {
  881. char new_addr[TOR_ADDR_BUF_LEN];
  882. tor_addr_to_str(new_addr, &addr, sizeof(new_addr), 1);
  883. if (strcmp(conn->socks_request->address, new_addr)) {
  884. strlcpy(conn->socks_request->address, new_addr,
  885. sizeof(conn->socks_request->address));
  886. control_event_stream_status(conn, STREAM_EVENT_REMAP, 0);
  887. }
  888. }
  889. }
  890. /* check if the exit *ought* to have allowed it */
  891. adjust_exit_policy_from_exitpolicy_failure(circ,
  892. conn,
  893. exitrouter,
  894. &addr);
  895. if (conn->chosen_exit_optional ||
  896. conn->chosen_exit_retries) {
  897. /* stop wanting a specific exit */
  898. conn->chosen_exit_optional = 0;
  899. /* A non-zero chosen_exit_retries can happen if we set a
  900. * TrackHostExits for this address under a port that the exit
  901. * relay allows, but then try the same address with a different
  902. * port that it doesn't allow to exit. We shouldn't unregister
  903. * the mapping, since it is probably still wanted on the
  904. * original port. But now we give away to the exit relay that
  905. * we probably have a TrackHostExits on it. So be it. */
  906. conn->chosen_exit_retries = 0;
  907. tor_free(conn->chosen_exit_name); /* clears it */
  908. }
  909. if (connection_ap_detach_retriable(conn, circ, control_reason) >= 0)
  910. return 0;
  911. /* else, conn will get closed below */
  912. break;
  913. }
  914. case END_STREAM_REASON_CONNECTREFUSED:
  915. if (!conn->chosen_exit_optional)
  916. break; /* break means it'll close, below */
  917. /* Else fall through: expire this circuit, clear the
  918. * chosen_exit_name field, and try again. */
  919. /* Falls through. */
  920. case END_STREAM_REASON_RESOLVEFAILED:
  921. case END_STREAM_REASON_TIMEOUT:
  922. case END_STREAM_REASON_MISC:
  923. case END_STREAM_REASON_NOROUTE:
  924. if (client_dns_incr_failures(conn->socks_request->address)
  925. < MAX_RESOLVE_FAILURES) {
  926. /* We haven't retried too many times; reattach the connection. */
  927. circuit_log_path(LOG_INFO,LD_APP,circ);
  928. /* Mark this circuit "unusable for new streams". */
  929. mark_circuit_unusable_for_new_conns(circ);
  930. if (conn->chosen_exit_optional) {
  931. /* stop wanting a specific exit */
  932. conn->chosen_exit_optional = 0;
  933. tor_free(conn->chosen_exit_name); /* clears it */
  934. }
  935. if (connection_ap_detach_retriable(conn, circ, control_reason) >= 0)
  936. return 0;
  937. /* else, conn will get closed below */
  938. } else {
  939. log_notice(LD_APP,
  940. "Have tried resolving or connecting to address '%s' "
  941. "at %d different places. Giving up.",
  942. safe_str(conn->socks_request->address),
  943. MAX_RESOLVE_FAILURES);
  944. /* clear the failures, so it will have a full try next time */
  945. client_dns_clear_failures(conn->socks_request->address);
  946. }
  947. break;
  948. case END_STREAM_REASON_HIBERNATING:
  949. case END_STREAM_REASON_RESOURCELIMIT:
  950. if (exitrouter) {
  951. policies_set_node_exitpolicy_to_reject_all(exitrouter);
  952. }
  953. if (conn->chosen_exit_optional) {
  954. /* stop wanting a specific exit */
  955. conn->chosen_exit_optional = 0;
  956. tor_free(conn->chosen_exit_name); /* clears it */
  957. }
  958. if (connection_ap_detach_retriable(conn, circ, control_reason) >= 0)
  959. return 0;
  960. /* else, will close below */
  961. break;
  962. } /* end switch */
  963. log_info(LD_APP,"Giving up on retrying; conn can't be handled.");
  964. }
  965. log_info(LD_APP,
  966. "Edge got end (%s) before we're connected. Marking for close.",
  967. stream_end_reason_to_string(rh->length > 0 ? reason : -1));
  968. circuit_log_path(LOG_INFO,LD_APP,circ);
  969. /* need to test because of detach_retriable */
  970. if (!ENTRY_TO_CONN(conn)->marked_for_close)
  971. connection_mark_unattached_ap(conn, control_reason);
  972. return 0;
  973. }
  974. /** Called when we have gotten an END_REASON_EXITPOLICY failure on <b>circ</b>
  975. * for <b>conn</b>, while attempting to connect via <b>node</b>. If the node
  976. * told us which address it rejected, then <b>addr</b> is that address;
  977. * otherwise it is AF_UNSPEC.
  978. *
  979. * If we are sure the node should have allowed this address, mark the node as
  980. * having a reject *:* exit policy. Otherwise, mark the circuit as unusable
  981. * for this particular address.
  982. **/
  983. static void
  984. adjust_exit_policy_from_exitpolicy_failure(origin_circuit_t *circ,
  985. entry_connection_t *conn,
  986. node_t *node,
  987. const tor_addr_t *addr)
  988. {
  989. int make_reject_all = 0;
  990. const sa_family_t family = tor_addr_family(addr);
  991. if (node) {
  992. tor_addr_t tmp;
  993. int asked_for_family = tor_addr_parse(&tmp, conn->socks_request->address);
  994. if (family == AF_UNSPEC) {
  995. make_reject_all = 1;
  996. } else if (node_exit_policy_is_exact(node, family) &&
  997. asked_for_family != -1 && !conn->chosen_exit_name) {
  998. make_reject_all = 1;
  999. }
  1000. if (make_reject_all) {
  1001. log_info(LD_APP,
  1002. "Exitrouter %s seems to be more restrictive than its exit "
  1003. "policy. Not using this router as exit for now.",
  1004. node_describe(node));
  1005. policies_set_node_exitpolicy_to_reject_all(node);
  1006. }
  1007. }
  1008. if (family != AF_UNSPEC)
  1009. addr_policy_append_reject_addr(&circ->prepend_policy, addr);
  1010. }
  1011. /** Helper: change the socks_request-&gt;address field on conn to the
  1012. * dotted-quad representation of <b>new_addr</b>,
  1013. * and send an appropriate REMAP event. */
  1014. static void
  1015. remap_event_helper(entry_connection_t *conn, const tor_addr_t *new_addr)
  1016. {
  1017. tor_addr_to_str(conn->socks_request->address, new_addr,
  1018. sizeof(conn->socks_request->address),
  1019. 1);
  1020. control_event_stream_status(conn, STREAM_EVENT_REMAP,
  1021. REMAP_STREAM_SOURCE_EXIT);
  1022. }
  1023. /** Extract the contents of a connected cell in <b>cell</b>, whose relay
  1024. * header has already been parsed into <b>rh</b>. On success, set
  1025. * <b>addr_out</b> to the address we're connected to, and <b>ttl_out</b> to
  1026. * the ttl of that address, in seconds, and return 0. On failure, return
  1027. * -1. */
  1028. STATIC int
  1029. connected_cell_parse(const relay_header_t *rh, const cell_t *cell,
  1030. tor_addr_t *addr_out, int *ttl_out)
  1031. {
  1032. uint32_t bytes;
  1033. const uint8_t *payload = cell->payload + RELAY_HEADER_SIZE;
  1034. tor_addr_make_unspec(addr_out);
  1035. *ttl_out = -1;
  1036. if (rh->length == 0)
  1037. return 0;
  1038. if (rh->length < 4)
  1039. return -1;
  1040. bytes = ntohl(get_uint32(payload));
  1041. /* If bytes is 0, this is maybe a v6 address. Otherwise it's a v4 address */
  1042. if (bytes != 0) {
  1043. /* v4 address */
  1044. tor_addr_from_ipv4h(addr_out, bytes);
  1045. if (rh->length >= 8) {
  1046. bytes = ntohl(get_uint32(payload + 4));
  1047. if (bytes <= INT32_MAX)
  1048. *ttl_out = bytes;
  1049. }
  1050. } else {
  1051. if (rh->length < 25) /* 4 bytes of 0s, 1 addr, 16 ipv4, 4 ttl. */
  1052. return -1;
  1053. if (get_uint8(payload + 4) != 6)
  1054. return -1;
  1055. tor_addr_from_ipv6_bytes(addr_out, (char*)(payload + 5));
  1056. bytes = ntohl(get_uint32(payload + 21));
  1057. if (bytes <= INT32_MAX)
  1058. *ttl_out = (int) bytes;
  1059. }
  1060. return 0;
  1061. }
  1062. /** Drop all storage held by <b>addr</b>. */
  1063. STATIC void
  1064. address_ttl_free_(address_ttl_t *addr)
  1065. {
  1066. if (!addr)
  1067. return;
  1068. tor_free(addr->hostname);
  1069. tor_free(addr);
  1070. }
  1071. /** Parse a resolved cell in <b>cell</b>, with parsed header in <b>rh</b>.
  1072. * Return -1 on parse error. On success, add one or more newly allocated
  1073. * address_ttl_t to <b>addresses_out</b>; set *<b>errcode_out</b> to
  1074. * one of 0, RESOLVED_TYPE_ERROR, or RESOLVED_TYPE_ERROR_TRANSIENT, and
  1075. * return 0. */
  1076. STATIC int
  1077. resolved_cell_parse(const cell_t *cell, const relay_header_t *rh,
  1078. smartlist_t *addresses_out, int *errcode_out)
  1079. {
  1080. const uint8_t *cp;
  1081. uint8_t answer_type;
  1082. size_t answer_len;
  1083. address_ttl_t *addr;
  1084. size_t remaining;
  1085. int errcode = 0;
  1086. smartlist_t *addrs;
  1087. tor_assert(cell);
  1088. tor_assert(rh);
  1089. tor_assert(addresses_out);
  1090. tor_assert(errcode_out);
  1091. *errcode_out = 0;
  1092. if (rh->length > RELAY_PAYLOAD_SIZE)
  1093. return -1;
  1094. addrs = smartlist_new();
  1095. cp = cell->payload + RELAY_HEADER_SIZE;
  1096. remaining = rh->length;
  1097. while (remaining) {
  1098. const uint8_t *cp_orig = cp;
  1099. if (remaining < 2)
  1100. goto err;
  1101. answer_type = *cp++;
  1102. answer_len = *cp++;
  1103. if (remaining < 2 + answer_len + 4) {
  1104. goto err;
  1105. }
  1106. if (answer_type == RESOLVED_TYPE_IPV4) {
  1107. if (answer_len != 4) {
  1108. goto err;
  1109. }
  1110. addr = tor_malloc_zero(sizeof(*addr));
  1111. tor_addr_from_ipv4n(&addr->addr, get_uint32(cp));
  1112. cp += 4;
  1113. addr->ttl = ntohl(get_uint32(cp));
  1114. cp += 4;
  1115. smartlist_add(addrs, addr);
  1116. } else if (answer_type == RESOLVED_TYPE_IPV6) {
  1117. if (answer_len != 16)
  1118. goto err;
  1119. addr = tor_malloc_zero(sizeof(*addr));
  1120. tor_addr_from_ipv6_bytes(&addr->addr, (const char*) cp);
  1121. cp += 16;
  1122. addr->ttl = ntohl(get_uint32(cp));
  1123. cp += 4;
  1124. smartlist_add(addrs, addr);
  1125. } else if (answer_type == RESOLVED_TYPE_HOSTNAME) {
  1126. if (answer_len == 0) {
  1127. goto err;
  1128. }
  1129. addr = tor_malloc_zero(sizeof(*addr));
  1130. addr->hostname = tor_memdup_nulterm(cp, answer_len);
  1131. cp += answer_len;
  1132. addr->ttl = ntohl(get_uint32(cp));
  1133. cp += 4;
  1134. smartlist_add(addrs, addr);
  1135. } else if (answer_type == RESOLVED_TYPE_ERROR_TRANSIENT ||
  1136. answer_type == RESOLVED_TYPE_ERROR) {
  1137. errcode = answer_type;
  1138. /* Ignore the error contents */
  1139. cp += answer_len + 4;
  1140. } else {
  1141. cp += answer_len + 4;
  1142. }
  1143. tor_assert(((ssize_t)remaining) >= (cp - cp_orig));
  1144. remaining -= (cp - cp_orig);
  1145. }
  1146. if (errcode && smartlist_len(addrs) == 0) {
  1147. /* Report an error only if there were no results. */
  1148. *errcode_out = errcode;
  1149. }
  1150. smartlist_add_all(addresses_out, addrs);
  1151. smartlist_free(addrs);
  1152. return 0;
  1153. err:
  1154. /* On parse error, don't report any results */
  1155. SMARTLIST_FOREACH(addrs, address_ttl_t *, a, address_ttl_free(a));
  1156. smartlist_free(addrs);
  1157. return -1;
  1158. }
  1159. /** Helper for connection_edge_process_resolved_cell: given an error code,
  1160. * an entry_connection, and a list of address_ttl_t *, report the best answer
  1161. * to the entry_connection. */
  1162. static void
  1163. connection_ap_handshake_socks_got_resolved_cell(entry_connection_t *conn,
  1164. int error_code,
  1165. smartlist_t *results)
  1166. {
  1167. address_ttl_t *addr_ipv4 = NULL;
  1168. address_ttl_t *addr_ipv6 = NULL;
  1169. address_ttl_t *addr_hostname = NULL;
  1170. address_ttl_t *addr_best = NULL;
  1171. /* If it's an error code, that's easy. */
  1172. if (error_code) {
  1173. tor_assert(error_code == RESOLVED_TYPE_ERROR ||
  1174. error_code == RESOLVED_TYPE_ERROR_TRANSIENT);
  1175. connection_ap_handshake_socks_resolved(conn,
  1176. error_code,0,NULL,-1,-1);
  1177. return;
  1178. }
  1179. /* Get the first answer of each type. */
  1180. SMARTLIST_FOREACH_BEGIN(results, address_ttl_t *, addr) {
  1181. if (addr->hostname) {
  1182. if (!addr_hostname) {
  1183. addr_hostname = addr;
  1184. }
  1185. } else if (tor_addr_family(&addr->addr) == AF_INET) {
  1186. if (!addr_ipv4 && conn->entry_cfg.ipv4_traffic) {
  1187. addr_ipv4 = addr;
  1188. }
  1189. } else if (tor_addr_family(&addr->addr) == AF_INET6) {
  1190. if (!addr_ipv6 && conn->entry_cfg.ipv6_traffic) {
  1191. addr_ipv6 = addr;
  1192. }
  1193. }
  1194. } SMARTLIST_FOREACH_END(addr);
  1195. /* Now figure out which type we wanted to deliver. */
  1196. if (conn->socks_request->command == SOCKS_COMMAND_RESOLVE_PTR) {
  1197. if (addr_hostname) {
  1198. connection_ap_handshake_socks_resolved(conn,
  1199. RESOLVED_TYPE_HOSTNAME,
  1200. strlen(addr_hostname->hostname),
  1201. (uint8_t*)addr_hostname->hostname,
  1202. addr_hostname->ttl,-1);
  1203. } else {
  1204. connection_ap_handshake_socks_resolved(conn,
  1205. RESOLVED_TYPE_ERROR,0,NULL,-1,-1);
  1206. }
  1207. return;
  1208. }
  1209. if (conn->entry_cfg.prefer_ipv6) {
  1210. addr_best = addr_ipv6 ? addr_ipv6 : addr_ipv4;
  1211. } else {
  1212. addr_best = addr_ipv4 ? addr_ipv4 : addr_ipv6;
  1213. }
  1214. /* Now convert it to the ugly old interface */
  1215. if (! addr_best) {
  1216. connection_ap_handshake_socks_resolved(conn,
  1217. RESOLVED_TYPE_ERROR,0,NULL,-1,-1);
  1218. return;
  1219. }
  1220. connection_ap_handshake_socks_resolved_addr(conn,
  1221. &addr_best->addr,
  1222. addr_best->ttl,
  1223. -1);
  1224. remap_event_helper(conn, &addr_best->addr);
  1225. }
  1226. /** Handle a RELAY_COMMAND_RESOLVED cell that we received on a non-open AP
  1227. * stream. */
  1228. STATIC int
  1229. connection_edge_process_resolved_cell(edge_connection_t *conn,
  1230. const cell_t *cell,
  1231. const relay_header_t *rh)
  1232. {
  1233. entry_connection_t *entry_conn = EDGE_TO_ENTRY_CONN(conn);
  1234. smartlist_t *resolved_addresses = NULL;
  1235. int errcode = 0;
  1236. if (conn->base_.state != AP_CONN_STATE_RESOLVE_WAIT) {
  1237. log_fn(LOG_PROTOCOL_WARN, LD_APP, "Got a 'resolved' cell while "
  1238. "not in state resolve_wait. Dropping.");
  1239. return 0;
  1240. }
  1241. tor_assert(SOCKS_COMMAND_IS_RESOLVE(entry_conn->socks_request->command));
  1242. resolved_addresses = smartlist_new();
  1243. if (resolved_cell_parse(cell, rh, resolved_addresses, &errcode)) {
  1244. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  1245. "Dropping malformed 'resolved' cell");
  1246. connection_mark_unattached_ap(entry_conn, END_STREAM_REASON_TORPROTOCOL);
  1247. goto done;
  1248. }
  1249. if (get_options()->ClientDNSRejectInternalAddresses) {
  1250. int orig_len = smartlist_len(resolved_addresses);
  1251. SMARTLIST_FOREACH_BEGIN(resolved_addresses, address_ttl_t *, addr) {
  1252. if (addr->hostname == NULL && tor_addr_is_internal(&addr->addr, 0)) {
  1253. log_info(LD_APP, "Got a resolved cell with answer %s; dropping that "
  1254. "answer.",
  1255. safe_str_client(fmt_addr(&addr->addr)));
  1256. address_ttl_free(addr);
  1257. SMARTLIST_DEL_CURRENT(resolved_addresses, addr);
  1258. }
  1259. } SMARTLIST_FOREACH_END(addr);
  1260. if (orig_len && smartlist_len(resolved_addresses) == 0) {
  1261. log_info(LD_APP, "Got a resolved cell with only private addresses; "
  1262. "dropping it.");
  1263. connection_ap_handshake_socks_resolved(entry_conn,
  1264. RESOLVED_TYPE_ERROR_TRANSIENT,
  1265. 0, NULL, 0, TIME_MAX);
  1266. connection_mark_unattached_ap(entry_conn,
  1267. END_STREAM_REASON_TORPROTOCOL);
  1268. goto done;
  1269. }
  1270. }
  1271. connection_ap_handshake_socks_got_resolved_cell(entry_conn,
  1272. errcode,
  1273. resolved_addresses);
  1274. connection_mark_unattached_ap(entry_conn,
  1275. END_STREAM_REASON_DONE |
  1276. END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
  1277. done:
  1278. SMARTLIST_FOREACH(resolved_addresses, address_ttl_t *, addr,
  1279. address_ttl_free(addr));
  1280. smartlist_free(resolved_addresses);
  1281. return 0;
  1282. }
  1283. /** An incoming relay cell has arrived from circuit <b>circ</b> to
  1284. * stream <b>conn</b>.
  1285. *
  1286. * The arguments here are the same as in
  1287. * connection_edge_process_relay_cell() below; this function is called
  1288. * from there when <b>conn</b> is defined and not in an open state.
  1289. */
  1290. static int
  1291. connection_edge_process_relay_cell_not_open(
  1292. relay_header_t *rh, cell_t *cell, circuit_t *circ,
  1293. edge_connection_t *conn, crypt_path_t *layer_hint)
  1294. {
  1295. if (rh->command == RELAY_COMMAND_END) {
  1296. if (CIRCUIT_IS_ORIGIN(circ) && conn->base_.type == CONN_TYPE_AP) {
  1297. return connection_ap_process_end_not_open(rh, cell,
  1298. TO_ORIGIN_CIRCUIT(circ),
  1299. EDGE_TO_ENTRY_CONN(conn),
  1300. layer_hint);
  1301. } else {
  1302. /* we just got an 'end', don't need to send one */
  1303. conn->edge_has_sent_end = 1;
  1304. conn->end_reason = *(cell->payload+RELAY_HEADER_SIZE) |
  1305. END_STREAM_REASON_FLAG_REMOTE;
  1306. connection_mark_for_close(TO_CONN(conn));
  1307. return 0;
  1308. }
  1309. }
  1310. if (conn->base_.type == CONN_TYPE_AP &&
  1311. rh->command == RELAY_COMMAND_CONNECTED) {
  1312. tor_addr_t addr;
  1313. int ttl;
  1314. entry_connection_t *entry_conn = EDGE_TO_ENTRY_CONN(conn);
  1315. tor_assert(CIRCUIT_IS_ORIGIN(circ));
  1316. if (conn->base_.state != AP_CONN_STATE_CONNECT_WAIT) {
  1317. log_fn(LOG_PROTOCOL_WARN, LD_APP,
  1318. "Got 'connected' while not in state connect_wait. Dropping.");
  1319. return 0;
  1320. }
  1321. CONNECTION_AP_EXPECT_NONPENDING(entry_conn);
  1322. conn->base_.state = AP_CONN_STATE_OPEN;
  1323. log_info(LD_APP,"'connected' received for circid %u streamid %d "
  1324. "after %d seconds.",
  1325. (unsigned)circ->n_circ_id,
  1326. rh->stream_id,
  1327. (int)(time(NULL) - conn->base_.timestamp_lastread));
  1328. if (connected_cell_parse(rh, cell, &addr, &ttl) < 0) {
  1329. log_fn(LOG_PROTOCOL_WARN, LD_APP,
  1330. "Got a badly formatted connected cell. Closing.");
  1331. connection_edge_end(conn, END_STREAM_REASON_TORPROTOCOL);
  1332. connection_mark_unattached_ap(entry_conn, END_STREAM_REASON_TORPROTOCOL);
  1333. }
  1334. if (tor_addr_family(&addr) != AF_UNSPEC) {
  1335. const sa_family_t family = tor_addr_family(&addr);
  1336. if (tor_addr_is_null(&addr) ||
  1337. (get_options()->ClientDNSRejectInternalAddresses &&
  1338. tor_addr_is_internal(&addr, 0))) {
  1339. log_info(LD_APP, "...but it claims the IP address was %s. Closing.",
  1340. fmt_addr(&addr));
  1341. connection_edge_end(conn, END_STREAM_REASON_TORPROTOCOL);
  1342. connection_mark_unattached_ap(entry_conn,
  1343. END_STREAM_REASON_TORPROTOCOL);
  1344. return 0;
  1345. }
  1346. if ((family == AF_INET && ! entry_conn->entry_cfg.ipv4_traffic) ||
  1347. (family == AF_INET6 && ! entry_conn->entry_cfg.ipv6_traffic)) {
  1348. log_fn(LOG_PROTOCOL_WARN, LD_APP,
  1349. "Got a connected cell to %s with unsupported address family."
  1350. " Closing.", fmt_addr(&addr));
  1351. connection_edge_end(conn, END_STREAM_REASON_TORPROTOCOL);
  1352. connection_mark_unattached_ap(entry_conn,
  1353. END_STREAM_REASON_TORPROTOCOL);
  1354. return 0;
  1355. }
  1356. client_dns_set_addressmap(entry_conn,
  1357. entry_conn->socks_request->address, &addr,
  1358. entry_conn->chosen_exit_name, ttl);
  1359. remap_event_helper(entry_conn, &addr);
  1360. }
  1361. circuit_log_path(LOG_INFO,LD_APP,TO_ORIGIN_CIRCUIT(circ));
  1362. /* don't send a socks reply to transparent conns */
  1363. tor_assert(entry_conn->socks_request != NULL);
  1364. if (!entry_conn->socks_request->has_finished) {
  1365. connection_ap_handshake_socks_reply(entry_conn, NULL, 0, 0);
  1366. }
  1367. /* Was it a linked dir conn? If so, a dir request just started to
  1368. * fetch something; this could be a bootstrap status milestone. */
  1369. log_debug(LD_APP, "considering");
  1370. if (TO_CONN(conn)->linked_conn &&
  1371. TO_CONN(conn)->linked_conn->type == CONN_TYPE_DIR) {
  1372. connection_t *dirconn = TO_CONN(conn)->linked_conn;
  1373. log_debug(LD_APP, "it is! %d", dirconn->purpose);
  1374. switch (dirconn->purpose) {
  1375. case DIR_PURPOSE_FETCH_CERTIFICATE:
  1376. if (consensus_is_waiting_for_certs())
  1377. control_event_bootstrap(BOOTSTRAP_STATUS_LOADING_KEYS, 0);
  1378. break;
  1379. case DIR_PURPOSE_FETCH_CONSENSUS:
  1380. control_event_bootstrap(BOOTSTRAP_STATUS_LOADING_STATUS, 0);
  1381. break;
  1382. case DIR_PURPOSE_FETCH_SERVERDESC:
  1383. case DIR_PURPOSE_FETCH_MICRODESC:
  1384. if (TO_DIR_CONN(dirconn)->router_purpose == ROUTER_PURPOSE_GENERAL)
  1385. control_event_bootstrap(BOOTSTRAP_STATUS_LOADING_DESCRIPTORS,
  1386. count_loading_descriptors_progress());
  1387. break;
  1388. }
  1389. }
  1390. /* This is definitely a success, so forget about any pending data we
  1391. * had sent. */
  1392. if (entry_conn->pending_optimistic_data) {
  1393. buf_free(entry_conn->pending_optimistic_data);
  1394. entry_conn->pending_optimistic_data = NULL;
  1395. }
  1396. /* handle anything that might have queued */
  1397. if (connection_edge_package_raw_inbuf(conn, 1, NULL) < 0) {
  1398. /* (We already sent an end cell if possible) */
  1399. connection_mark_for_close(TO_CONN(conn));
  1400. return 0;
  1401. }
  1402. return 0;
  1403. }
  1404. if (conn->base_.type == CONN_TYPE_AP &&
  1405. rh->command == RELAY_COMMAND_RESOLVED) {
  1406. return connection_edge_process_resolved_cell(conn, cell, rh);
  1407. }
  1408. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  1409. "Got an unexpected relay command %d, in state %d (%s). Dropping.",
  1410. rh->command, conn->base_.state,
  1411. conn_state_to_string(conn->base_.type, conn->base_.state));
  1412. return 0; /* for forward compatibility, don't kill the circuit */
  1413. // connection_edge_end(conn, END_STREAM_REASON_TORPROTOCOL);
  1414. // connection_mark_for_close(conn);
  1415. // return -1;
  1416. }
  1417. /** An incoming relay cell has arrived on circuit <b>circ</b>. If
  1418. * <b>conn</b> is NULL this is a control cell, else <b>cell</b> is
  1419. * destined for <b>conn</b>.
  1420. *
  1421. * If <b>layer_hint</b> is defined, then we're the origin of the
  1422. * circuit, and it specifies the hop that packaged <b>cell</b>.
  1423. *
  1424. * Return -reason if you want to warn and tear down the circuit, else 0.
  1425. */
  1426. static int
  1427. connection_edge_process_relay_cell(cell_t *cell, circuit_t *circ,
  1428. edge_connection_t *conn,
  1429. crypt_path_t *layer_hint)
  1430. {
  1431. static int num_seen=0;
  1432. relay_header_t rh;
  1433. unsigned domain = layer_hint?LD_APP:LD_EXIT;
  1434. int reason;
  1435. int optimistic_data = 0; /* Set to 1 if we receive data on a stream
  1436. * that's in the EXIT_CONN_STATE_RESOLVING
  1437. * or EXIT_CONN_STATE_CONNECTING states. */
  1438. tor_assert(cell);
  1439. tor_assert(circ);
  1440. relay_header_unpack(&rh, cell->payload);
  1441. // log_fn(LOG_DEBUG,"command %d stream %d", rh.command, rh.stream_id);
  1442. num_seen++;
  1443. log_debug(domain, "Now seen %d relay cells here (command %d, stream %d).",
  1444. num_seen, rh.command, rh.stream_id);
  1445. if (rh.length > RELAY_PAYLOAD_SIZE) {
  1446. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  1447. "Relay cell length field too long. Closing circuit.");
  1448. return - END_CIRC_REASON_TORPROTOCOL;
  1449. }
  1450. if (rh.stream_id == 0) {
  1451. switch (rh.command) {
  1452. case RELAY_COMMAND_BEGIN:
  1453. case RELAY_COMMAND_CONNECTED:
  1454. case RELAY_COMMAND_END:
  1455. case RELAY_COMMAND_RESOLVE:
  1456. case RELAY_COMMAND_RESOLVED:
  1457. case RELAY_COMMAND_BEGIN_DIR:
  1458. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL, "Relay command %d with zero "
  1459. "stream_id. Dropping.", (int)rh.command);
  1460. return 0;
  1461. default:
  1462. ;
  1463. }
  1464. }
  1465. /* either conn is NULL, in which case we've got a control cell, or else
  1466. * conn points to the recognized stream. */
  1467. if (conn && !connection_state_is_open(TO_CONN(conn))) {
  1468. if (conn->base_.type == CONN_TYPE_EXIT &&
  1469. (conn->base_.state == EXIT_CONN_STATE_CONNECTING ||
  1470. conn->base_.state == EXIT_CONN_STATE_RESOLVING) &&
  1471. rh.command == RELAY_COMMAND_DATA) {
  1472. /* Allow DATA cells to be delivered to an exit node in state
  1473. * EXIT_CONN_STATE_CONNECTING or EXIT_CONN_STATE_RESOLVING.
  1474. * This speeds up HTTP, for example. */
  1475. optimistic_data = 1;
  1476. } else if (rh.stream_id == 0 && rh.command == RELAY_COMMAND_DATA) {
  1477. log_warn(LD_BUG, "Somehow I had a connection that matched a "
  1478. "data cell with stream ID 0.");
  1479. } else {
  1480. return connection_edge_process_relay_cell_not_open(
  1481. &rh, cell, circ, conn, layer_hint);
  1482. }
  1483. }
  1484. switch (rh.command) {
  1485. case RELAY_COMMAND_DROP:
  1486. rep_hist_padding_count_read(PADDING_TYPE_DROP);
  1487. // log_info(domain,"Got a relay-level padding cell. Dropping.");
  1488. return 0;
  1489. case RELAY_COMMAND_BEGIN:
  1490. case RELAY_COMMAND_BEGIN_DIR:
  1491. if (layer_hint &&
  1492. circ->purpose != CIRCUIT_PURPOSE_S_REND_JOINED) {
  1493. log_fn(LOG_PROTOCOL_WARN, LD_APP,
  1494. "Relay begin request unsupported at AP. Dropping.");
  1495. return 0;
  1496. }
  1497. if (circ->purpose == CIRCUIT_PURPOSE_S_REND_JOINED &&
  1498. layer_hint != TO_ORIGIN_CIRCUIT(circ)->cpath->prev) {
  1499. log_fn(LOG_PROTOCOL_WARN, LD_APP,
  1500. "Relay begin request to Hidden Service "
  1501. "from intermediary node. Dropping.");
  1502. return 0;
  1503. }
  1504. if (conn) {
  1505. log_fn(LOG_PROTOCOL_WARN, domain,
  1506. "Begin cell for known stream. Dropping.");
  1507. return 0;
  1508. }
  1509. if (rh.command == RELAY_COMMAND_BEGIN_DIR &&
  1510. circ->purpose != CIRCUIT_PURPOSE_S_REND_JOINED) {
  1511. /* Assign this circuit and its app-ward OR connection a unique ID,
  1512. * so that we can measure download times. The local edge and dir
  1513. * connection will be assigned the same ID when they are created
  1514. * and linked. */
  1515. static uint64_t next_id = 0;
  1516. circ->dirreq_id = ++next_id;
  1517. TO_OR_CIRCUIT(circ)->p_chan->dirreq_id = circ->dirreq_id;
  1518. }
  1519. return connection_exit_begin_conn(cell, circ);
  1520. case RELAY_COMMAND_DATA:
  1521. ++stats_n_data_cells_received;
  1522. if (( layer_hint && --layer_hint->deliver_window < 0) ||
  1523. (!layer_hint && --circ->deliver_window < 0)) {
  1524. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  1525. "(relay data) circ deliver_window below 0. Killing.");
  1526. if (conn) {
  1527. /* XXXX Do we actually need to do this? Will killing the circuit
  1528. * not send an END and mark the stream for close as appropriate? */
  1529. connection_edge_end(conn, END_STREAM_REASON_TORPROTOCOL);
  1530. connection_mark_for_close(TO_CONN(conn));
  1531. }
  1532. return -END_CIRC_REASON_TORPROTOCOL;
  1533. }
  1534. log_debug(domain,"circ deliver_window now %d.", layer_hint ?
  1535. layer_hint->deliver_window : circ->deliver_window);
  1536. circuit_consider_sending_sendme(circ, layer_hint);
  1537. if (rh.stream_id == 0) {
  1538. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL, "Relay data cell with zero "
  1539. "stream_id. Dropping.");
  1540. return 0;
  1541. } else if (!conn) {
  1542. log_info(domain,"data cell dropped, unknown stream (streamid %d).",
  1543. rh.stream_id);
  1544. return 0;
  1545. }
  1546. if (--conn->deliver_window < 0) { /* is it below 0 after decrement? */
  1547. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  1548. "(relay data) conn deliver_window below 0. Killing.");
  1549. return -END_CIRC_REASON_TORPROTOCOL;
  1550. }
  1551. stats_n_data_bytes_received += rh.length;
  1552. connection_buf_add((char*)(cell->payload + RELAY_HEADER_SIZE),
  1553. rh.length, TO_CONN(conn));
  1554. #ifdef MEASUREMENTS_21206
  1555. /* Count number of RELAY_DATA cells received on a linked directory
  1556. * connection. */
  1557. connection_t *linked_conn = TO_CONN(conn)->linked_conn;
  1558. if (linked_conn && linked_conn->type == CONN_TYPE_DIR) {
  1559. ++(TO_DIR_CONN(linked_conn)->data_cells_received);
  1560. }
  1561. #endif /* defined(MEASUREMENTS_21206) */
  1562. if (!optimistic_data) {
  1563. /* Only send a SENDME if we're not getting optimistic data; otherwise
  1564. * a SENDME could arrive before the CONNECTED.
  1565. */
  1566. connection_edge_consider_sending_sendme(conn);
  1567. }
  1568. return 0;
  1569. case RELAY_COMMAND_END:
  1570. reason = rh.length > 0 ?
  1571. get_uint8(cell->payload+RELAY_HEADER_SIZE) : END_STREAM_REASON_MISC;
  1572. if (!conn) {
  1573. log_info(domain,"end cell (%s) dropped, unknown stream.",
  1574. stream_end_reason_to_string(reason));
  1575. return 0;
  1576. }
  1577. /* XXX add to this log_fn the exit node's nickname? */
  1578. log_info(domain,TOR_SOCKET_T_FORMAT": end cell (%s) for stream %d. "
  1579. "Removing stream.",
  1580. conn->base_.s,
  1581. stream_end_reason_to_string(reason),
  1582. conn->stream_id);
  1583. if (conn->base_.type == CONN_TYPE_AP) {
  1584. entry_connection_t *entry_conn = EDGE_TO_ENTRY_CONN(conn);
  1585. if (entry_conn->socks_request &&
  1586. !entry_conn->socks_request->has_finished)
  1587. log_warn(LD_BUG,
  1588. "open stream hasn't sent socks answer yet? Closing.");
  1589. }
  1590. /* We just *got* an end; no reason to send one. */
  1591. conn->edge_has_sent_end = 1;
  1592. if (!conn->end_reason)
  1593. conn->end_reason = reason | END_STREAM_REASON_FLAG_REMOTE;
  1594. if (!conn->base_.marked_for_close) {
  1595. /* only mark it if not already marked. it's possible to
  1596. * get the 'end' right around when the client hangs up on us. */
  1597. connection_mark_and_flush(TO_CONN(conn));
  1598. }
  1599. return 0;
  1600. case RELAY_COMMAND_EXTEND:
  1601. case RELAY_COMMAND_EXTEND2: {
  1602. static uint64_t total_n_extend=0, total_nonearly=0;
  1603. total_n_extend++;
  1604. if (rh.stream_id) {
  1605. log_fn(LOG_PROTOCOL_WARN, domain,
  1606. "'extend' cell received for non-zero stream. Dropping.");
  1607. return 0;
  1608. }
  1609. if (cell->command != CELL_RELAY_EARLY &&
  1610. !networkstatus_get_param(NULL,"AllowNonearlyExtend",0,0,1)) {
  1611. #define EARLY_WARNING_INTERVAL 3600
  1612. static ratelim_t early_warning_limit =
  1613. RATELIM_INIT(EARLY_WARNING_INTERVAL);
  1614. char *m;
  1615. if (cell->command == CELL_RELAY) {
  1616. ++total_nonearly;
  1617. if ((m = rate_limit_log(&early_warning_limit, approx_time()))) {
  1618. double percentage = ((double)total_nonearly)/total_n_extend;
  1619. percentage *= 100;
  1620. log_fn(LOG_PROTOCOL_WARN, domain, "EXTEND cell received, "
  1621. "but not via RELAY_EARLY. Dropping.%s", m);
  1622. log_fn(LOG_PROTOCOL_WARN, domain, " (We have dropped %.02f%% of "
  1623. "all EXTEND cells for this reason)", percentage);
  1624. tor_free(m);
  1625. }
  1626. } else {
  1627. log_fn(LOG_WARN, domain,
  1628. "EXTEND cell received, in a cell with type %d! Dropping.",
  1629. cell->command);
  1630. }
  1631. return 0;
  1632. }
  1633. return circuit_extend(cell, circ);
  1634. }
  1635. case RELAY_COMMAND_EXTENDED:
  1636. case RELAY_COMMAND_EXTENDED2:
  1637. if (!layer_hint) {
  1638. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  1639. "'extended' unsupported at non-origin. Dropping.");
  1640. return 0;
  1641. }
  1642. log_debug(domain,"Got an extended cell! Yay.");
  1643. {
  1644. extended_cell_t extended_cell;
  1645. if (extended_cell_parse(&extended_cell, rh.command,
  1646. (const uint8_t*)cell->payload+RELAY_HEADER_SIZE,
  1647. rh.length)<0) {
  1648. log_warn(LD_PROTOCOL,
  1649. "Can't parse EXTENDED cell; killing circuit.");
  1650. return -END_CIRC_REASON_TORPROTOCOL;
  1651. }
  1652. if ((reason = circuit_finish_handshake(TO_ORIGIN_CIRCUIT(circ),
  1653. &extended_cell.created_cell)) < 0) {
  1654. circuit_mark_for_close(circ, -reason);
  1655. return 0; /* We don't want to cause a warning, so we mark the circuit
  1656. * here. */
  1657. }
  1658. }
  1659. if ((reason=circuit_send_next_onion_skin(TO_ORIGIN_CIRCUIT(circ)))<0) {
  1660. log_info(domain,"circuit_send_next_onion_skin() failed.");
  1661. return reason;
  1662. }
  1663. return 0;
  1664. case RELAY_COMMAND_TRUNCATE:
  1665. if (layer_hint) {
  1666. log_fn(LOG_PROTOCOL_WARN, LD_APP,
  1667. "'truncate' unsupported at origin. Dropping.");
  1668. return 0;
  1669. }
  1670. if (circ->n_hop) {
  1671. if (circ->n_chan)
  1672. log_warn(LD_BUG, "n_chan and n_hop set on the same circuit!");
  1673. extend_info_free(circ->n_hop);
  1674. circ->n_hop = NULL;
  1675. tor_free(circ->n_chan_create_cell);
  1676. circuit_set_state(circ, CIRCUIT_STATE_OPEN);
  1677. }
  1678. if (circ->n_chan) {
  1679. uint8_t trunc_reason = get_uint8(cell->payload + RELAY_HEADER_SIZE);
  1680. circuit_clear_cell_queue(circ, circ->n_chan);
  1681. channel_send_destroy(circ->n_circ_id, circ->n_chan,
  1682. trunc_reason);
  1683. circuit_set_n_circid_chan(circ, 0, NULL);
  1684. }
  1685. log_debug(LD_EXIT, "Processed 'truncate', replying.");
  1686. {
  1687. char payload[1];
  1688. payload[0] = (char)END_CIRC_REASON_REQUESTED;
  1689. relay_send_command_from_edge(0, circ, RELAY_COMMAND_TRUNCATED,
  1690. payload, sizeof(payload), NULL);
  1691. }
  1692. return 0;
  1693. case RELAY_COMMAND_TRUNCATED:
  1694. if (!layer_hint) {
  1695. log_fn(LOG_PROTOCOL_WARN, LD_EXIT,
  1696. "'truncated' unsupported at non-origin. Dropping.");
  1697. return 0;
  1698. }
  1699. circuit_truncated(TO_ORIGIN_CIRCUIT(circ), layer_hint,
  1700. get_uint8(cell->payload + RELAY_HEADER_SIZE));
  1701. return 0;
  1702. case RELAY_COMMAND_CONNECTED:
  1703. if (conn) {
  1704. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  1705. "'connected' unsupported while open. Closing circ.");
  1706. return -END_CIRC_REASON_TORPROTOCOL;
  1707. }
  1708. log_info(domain,
  1709. "'connected' received on circid %u for streamid %d, "
  1710. "no conn attached anymore. Ignoring.",
  1711. (unsigned)circ->n_circ_id, rh.stream_id);
  1712. return 0;
  1713. case RELAY_COMMAND_SENDME:
  1714. if (!rh.stream_id) {
  1715. if (layer_hint) {
  1716. if (layer_hint->package_window + CIRCWINDOW_INCREMENT >
  1717. CIRCWINDOW_START_MAX) {
  1718. static struct ratelim_t exit_warn_ratelim = RATELIM_INIT(600);
  1719. log_fn_ratelim(&exit_warn_ratelim, LOG_WARN, LD_PROTOCOL,
  1720. "Unexpected sendme cell from exit relay. "
  1721. "Closing circ.");
  1722. return -END_CIRC_REASON_TORPROTOCOL;
  1723. }
  1724. layer_hint->package_window += CIRCWINDOW_INCREMENT;
  1725. log_debug(LD_APP,"circ-level sendme at origin, packagewindow %d.",
  1726. layer_hint->package_window);
  1727. circuit_resume_edge_reading(circ, layer_hint);
  1728. } else {
  1729. if (circ->package_window + CIRCWINDOW_INCREMENT >
  1730. CIRCWINDOW_START_MAX) {
  1731. static struct ratelim_t client_warn_ratelim = RATELIM_INIT(600);
  1732. log_fn_ratelim(&client_warn_ratelim,LOG_PROTOCOL_WARN, LD_PROTOCOL,
  1733. "Unexpected sendme cell from client. "
  1734. "Closing circ (window %d).",
  1735. circ->package_window);
  1736. return -END_CIRC_REASON_TORPROTOCOL;
  1737. }
  1738. circ->package_window += CIRCWINDOW_INCREMENT;
  1739. log_debug(LD_APP,
  1740. "circ-level sendme at non-origin, packagewindow %d.",
  1741. circ->package_window);
  1742. circuit_resume_edge_reading(circ, layer_hint);
  1743. }
  1744. return 0;
  1745. }
  1746. if (!conn) {
  1747. log_info(domain,"sendme cell dropped, unknown stream (streamid %d).",
  1748. rh.stream_id);
  1749. return 0;
  1750. }
  1751. conn->package_window += STREAMWINDOW_INCREMENT;
  1752. log_debug(domain,"stream-level sendme, packagewindow now %d.",
  1753. conn->package_window);
  1754. if (circuit_queue_streams_are_blocked(circ)) {
  1755. /* Still waiting for queue to flush; don't touch conn */
  1756. return 0;
  1757. }
  1758. connection_start_reading(TO_CONN(conn));
  1759. /* handle whatever might still be on the inbuf */
  1760. if (connection_edge_package_raw_inbuf(conn, 1, NULL) < 0) {
  1761. /* (We already sent an end cell if possible) */
  1762. connection_mark_for_close(TO_CONN(conn));
  1763. return 0;
  1764. }
  1765. return 0;
  1766. case RELAY_COMMAND_RESOLVE:
  1767. if (layer_hint) {
  1768. log_fn(LOG_PROTOCOL_WARN, LD_APP,
  1769. "resolve request unsupported at AP; dropping.");
  1770. return 0;
  1771. } else if (conn) {
  1772. log_fn(LOG_PROTOCOL_WARN, domain,
  1773. "resolve request for known stream; dropping.");
  1774. return 0;
  1775. } else if (circ->purpose != CIRCUIT_PURPOSE_OR) {
  1776. log_fn(LOG_PROTOCOL_WARN, domain,
  1777. "resolve request on circ with purpose %d; dropping",
  1778. circ->purpose);
  1779. return 0;
  1780. }
  1781. connection_exit_begin_resolve(cell, TO_OR_CIRCUIT(circ));
  1782. return 0;
  1783. case RELAY_COMMAND_RESOLVED:
  1784. if (conn) {
  1785. log_fn(LOG_PROTOCOL_WARN, domain,
  1786. "'resolved' unsupported while open. Closing circ.");
  1787. return -END_CIRC_REASON_TORPROTOCOL;
  1788. }
  1789. log_info(domain,
  1790. "'resolved' received, no conn attached anymore. Ignoring.");
  1791. return 0;
  1792. case RELAY_COMMAND_ESTABLISH_INTRO:
  1793. case RELAY_COMMAND_ESTABLISH_RENDEZVOUS:
  1794. case RELAY_COMMAND_INTRODUCE1:
  1795. case RELAY_COMMAND_INTRODUCE2:
  1796. case RELAY_COMMAND_INTRODUCE_ACK:
  1797. case RELAY_COMMAND_RENDEZVOUS1:
  1798. case RELAY_COMMAND_RENDEZVOUS2:
  1799. case RELAY_COMMAND_INTRO_ESTABLISHED:
  1800. case RELAY_COMMAND_RENDEZVOUS_ESTABLISHED:
  1801. rend_process_relay_cell(circ, layer_hint,
  1802. rh.command, rh.length,
  1803. cell->payload+RELAY_HEADER_SIZE);
  1804. return 0;
  1805. }
  1806. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  1807. "Received unknown relay command %d. Perhaps the other side is using "
  1808. "a newer version of Tor? Dropping.",
  1809. rh.command);
  1810. return 0; /* for forward compatibility, don't kill the circuit */
  1811. }
  1812. /** How many relay_data cells have we built, ever? */
  1813. uint64_t stats_n_data_cells_packaged = 0;
  1814. /** How many bytes of data have we put in relay_data cells have we built,
  1815. * ever? This would be RELAY_PAYLOAD_SIZE*stats_n_data_cells_packaged if
  1816. * every relay cell we ever sent were completely full of data. */
  1817. uint64_t stats_n_data_bytes_packaged = 0;
  1818. /** How many relay_data cells have we received, ever? */
  1819. uint64_t stats_n_data_cells_received = 0;
  1820. /** How many bytes of data have we received relay_data cells, ever? This would
  1821. * be RELAY_PAYLOAD_SIZE*stats_n_data_cells_packaged if every relay cell we
  1822. * ever received were completely full of data. */
  1823. uint64_t stats_n_data_bytes_received = 0;
  1824. /** If <b>conn</b> has an entire relay payload of bytes on its inbuf (or
  1825. * <b>package_partial</b> is true), and the appropriate package windows aren't
  1826. * empty, grab a cell and send it down the circuit.
  1827. *
  1828. * If *<b>max_cells</b> is given, package no more than max_cells. Decrement
  1829. * *<b>max_cells</b> by the number of cells packaged.
  1830. *
  1831. * Return -1 (and send a RELAY_COMMAND_END cell if necessary) if conn should
  1832. * be marked for close, else return 0.
  1833. */
  1834. int
  1835. connection_edge_package_raw_inbuf(edge_connection_t *conn, int package_partial,
  1836. int *max_cells)
  1837. {
  1838. size_t bytes_to_process, length;
  1839. char payload[CELL_PAYLOAD_SIZE];
  1840. circuit_t *circ;
  1841. const unsigned domain = conn->base_.type == CONN_TYPE_AP ? LD_APP : LD_EXIT;
  1842. int sending_from_optimistic = 0;
  1843. entry_connection_t *entry_conn =
  1844. conn->base_.type == CONN_TYPE_AP ? EDGE_TO_ENTRY_CONN(conn) : NULL;
  1845. const int sending_optimistically =
  1846. entry_conn &&
  1847. conn->base_.type == CONN_TYPE_AP &&
  1848. conn->base_.state != AP_CONN_STATE_OPEN;
  1849. crypt_path_t *cpath_layer = conn->cpath_layer;
  1850. tor_assert(conn);
  1851. if (conn->base_.marked_for_close) {
  1852. log_warn(LD_BUG,
  1853. "called on conn that's already marked for close at %s:%d.",
  1854. conn->base_.marked_for_close_file, conn->base_.marked_for_close);
  1855. return 0;
  1856. }
  1857. if (max_cells && *max_cells <= 0)
  1858. return 0;
  1859. repeat_connection_edge_package_raw_inbuf:
  1860. circ = circuit_get_by_edge_conn(conn);
  1861. if (!circ) {
  1862. log_info(domain,"conn has no circuit! Closing.");
  1863. conn->end_reason = END_STREAM_REASON_CANT_ATTACH;
  1864. return -1;
  1865. }
  1866. if (circuit_consider_stop_edge_reading(circ, cpath_layer))
  1867. return 0;
  1868. if (conn->package_window <= 0) {
  1869. log_info(domain,"called with package_window %d. Skipping.",
  1870. conn->package_window);
  1871. connection_stop_reading(TO_CONN(conn));
  1872. return 0;
  1873. }
  1874. sending_from_optimistic = entry_conn &&
  1875. entry_conn->sending_optimistic_data != NULL;
  1876. if (PREDICT_UNLIKELY(sending_from_optimistic)) {
  1877. bytes_to_process = buf_datalen(entry_conn->sending_optimistic_data);
  1878. if (PREDICT_UNLIKELY(!bytes_to_process)) {
  1879. log_warn(LD_BUG, "sending_optimistic_data was non-NULL but empty");
  1880. bytes_to_process = connection_get_inbuf_len(TO_CONN(conn));
  1881. sending_from_optimistic = 0;
  1882. }
  1883. } else {
  1884. bytes_to_process = connection_get_inbuf_len(TO_CONN(conn));
  1885. }
  1886. if (!bytes_to_process)
  1887. return 0;
  1888. if (!package_partial && bytes_to_process < RELAY_PAYLOAD_SIZE)
  1889. return 0;
  1890. if (bytes_to_process > RELAY_PAYLOAD_SIZE) {
  1891. length = RELAY_PAYLOAD_SIZE;
  1892. } else {
  1893. length = bytes_to_process;
  1894. }
  1895. stats_n_data_bytes_packaged += length;
  1896. stats_n_data_cells_packaged += 1;
  1897. if (PREDICT_UNLIKELY(sending_from_optimistic)) {
  1898. /* XXXX We could be more efficient here by sometimes packing
  1899. * previously-sent optimistic data in the same cell with data
  1900. * from the inbuf. */
  1901. buf_get_bytes(entry_conn->sending_optimistic_data, payload, length);
  1902. if (!buf_datalen(entry_conn->sending_optimistic_data)) {
  1903. buf_free(entry_conn->sending_optimistic_data);
  1904. entry_conn->sending_optimistic_data = NULL;
  1905. }
  1906. } else {
  1907. connection_buf_get_bytes(payload, length, TO_CONN(conn));
  1908. }
  1909. log_debug(domain,TOR_SOCKET_T_FORMAT": Packaging %d bytes (%d waiting).",
  1910. conn->base_.s,
  1911. (int)length, (int)connection_get_inbuf_len(TO_CONN(conn)));
  1912. if (sending_optimistically && !sending_from_optimistic) {
  1913. /* This is new optimistic data; remember it in case we need to detach and
  1914. retry */
  1915. if (!entry_conn->pending_optimistic_data)
  1916. entry_conn->pending_optimistic_data = buf_new();
  1917. buf_add(entry_conn->pending_optimistic_data, payload, length);
  1918. }
  1919. if (connection_edge_send_command(conn, RELAY_COMMAND_DATA,
  1920. payload, length) < 0 )
  1921. /* circuit got marked for close, don't continue, don't need to mark conn */
  1922. return 0;
  1923. if (!cpath_layer) { /* non-rendezvous exit */
  1924. tor_assert(circ->package_window > 0);
  1925. circ->package_window--;
  1926. } else { /* we're an AP, or an exit on a rendezvous circ */
  1927. tor_assert(cpath_layer->package_window > 0);
  1928. cpath_layer->package_window--;
  1929. }
  1930. if (--conn->package_window <= 0) { /* is it 0 after decrement? */
  1931. connection_stop_reading(TO_CONN(conn));
  1932. log_debug(domain,"conn->package_window reached 0.");
  1933. circuit_consider_stop_edge_reading(circ, cpath_layer);
  1934. return 0; /* don't process the inbuf any more */
  1935. }
  1936. log_debug(domain,"conn->package_window is now %d",conn->package_window);
  1937. if (max_cells) {
  1938. *max_cells -= 1;
  1939. if (*max_cells <= 0)
  1940. return 0;
  1941. }
  1942. /* handle more if there's more, or return 0 if there isn't */
  1943. goto repeat_connection_edge_package_raw_inbuf;
  1944. }
  1945. /** Called when we've just received a relay data cell, when
  1946. * we've just finished flushing all bytes to stream <b>conn</b>,
  1947. * or when we've flushed *some* bytes to the stream <b>conn</b>.
  1948. *
  1949. * If conn->outbuf is not too full, and our deliver window is
  1950. * low, send back a suitable number of stream-level sendme cells.
  1951. */
  1952. void
  1953. connection_edge_consider_sending_sendme(edge_connection_t *conn)
  1954. {
  1955. circuit_t *circ;
  1956. if (connection_outbuf_too_full(TO_CONN(conn)))
  1957. return;
  1958. circ = circuit_get_by_edge_conn(conn);
  1959. if (!circ) {
  1960. /* this can legitimately happen if the destroy has already
  1961. * arrived and torn down the circuit */
  1962. log_info(LD_APP,"No circuit associated with conn. Skipping.");
  1963. return;
  1964. }
  1965. while (conn->deliver_window <= STREAMWINDOW_START - STREAMWINDOW_INCREMENT) {
  1966. log_debug(conn->base_.type == CONN_TYPE_AP ?LD_APP:LD_EXIT,
  1967. "Outbuf %d, Queuing stream sendme.",
  1968. (int)conn->base_.outbuf_flushlen);
  1969. conn->deliver_window += STREAMWINDOW_INCREMENT;
  1970. if (connection_edge_send_command(conn, RELAY_COMMAND_SENDME,
  1971. NULL, 0) < 0) {
  1972. log_warn(LD_APP,"connection_edge_send_command failed. Skipping.");
  1973. return; /* the circuit's closed, don't continue */
  1974. }
  1975. }
  1976. }
  1977. /** The circuit <b>circ</b> has received a circuit-level sendme
  1978. * (on hop <b>layer_hint</b>, if we're the OP). Go through all the
  1979. * attached streams and let them resume reading and packaging, if
  1980. * their stream windows allow it.
  1981. */
  1982. static void
  1983. circuit_resume_edge_reading(circuit_t *circ, crypt_path_t *layer_hint)
  1984. {
  1985. if (circuit_queue_streams_are_blocked(circ)) {
  1986. log_debug(layer_hint?LD_APP:LD_EXIT,"Too big queue, no resuming");
  1987. return;
  1988. }
  1989. log_debug(layer_hint?LD_APP:LD_EXIT,"resuming");
  1990. if (CIRCUIT_IS_ORIGIN(circ))
  1991. circuit_resume_edge_reading_helper(TO_ORIGIN_CIRCUIT(circ)->p_streams,
  1992. circ, layer_hint);
  1993. else
  1994. circuit_resume_edge_reading_helper(TO_OR_CIRCUIT(circ)->n_streams,
  1995. circ, layer_hint);
  1996. }
  1997. void
  1998. stream_choice_seed_weak_rng(void)
  1999. {
  2000. crypto_seed_weak_rng(&stream_choice_rng);
  2001. }
  2002. /** A helper function for circuit_resume_edge_reading() above.
  2003. * The arguments are the same, except that <b>conn</b> is the head
  2004. * of a linked list of edge streams that should each be considered.
  2005. */
  2006. static int
  2007. circuit_resume_edge_reading_helper(edge_connection_t *first_conn,
  2008. circuit_t *circ,
  2009. crypt_path_t *layer_hint)
  2010. {
  2011. edge_connection_t *conn;
  2012. int n_packaging_streams, n_streams_left;
  2013. int packaged_this_round;
  2014. int cells_on_queue;
  2015. int cells_per_conn;
  2016. edge_connection_t *chosen_stream = NULL;
  2017. int max_to_package;
  2018. if (first_conn == NULL) {
  2019. /* Don't bother to try to do the rest of this if there are no connections
  2020. * to resume. */
  2021. return 0;
  2022. }
  2023. /* How many cells do we have space for? It will be the minimum of
  2024. * the number needed to exhaust the package window, and the minimum
  2025. * needed to fill the cell queue. */
  2026. max_to_package = circ->package_window;
  2027. if (CIRCUIT_IS_ORIGIN(circ)) {
  2028. cells_on_queue = circ->n_chan_cells.n;
  2029. } else {
  2030. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  2031. cells_on_queue = or_circ->p_chan_cells.n;
  2032. }
  2033. if (CELL_QUEUE_HIGHWATER_SIZE - cells_on_queue < max_to_package)
  2034. max_to_package = CELL_QUEUE_HIGHWATER_SIZE - cells_on_queue;
  2035. /* Once we used to start listening on the streams in the order they
  2036. * appeared in the linked list. That leads to starvation on the
  2037. * streams that appeared later on the list, since the first streams
  2038. * would always get to read first. Instead, we just pick a random
  2039. * stream on the list, and enable reading for streams starting at that
  2040. * point (and wrapping around as if the list were circular). It would
  2041. * probably be better to actually remember which streams we've
  2042. * serviced in the past, but this is simple and effective. */
  2043. /* Select a stream uniformly at random from the linked list. We
  2044. * don't need cryptographic randomness here. */
  2045. {
  2046. int num_streams = 0;
  2047. for (conn = first_conn; conn; conn = conn->next_stream) {
  2048. num_streams++;
  2049. if (tor_weak_random_one_in_n(&stream_choice_rng, num_streams)) {
  2050. chosen_stream = conn;
  2051. }
  2052. /* Invariant: chosen_stream has been chosen uniformly at random from
  2053. * among the first num_streams streams on first_conn.
  2054. *
  2055. * (Note that we iterate over every stream on the circuit, so that after
  2056. * we've considered the first stream, we've chosen it with P=1; and
  2057. * after we consider the second stream, we've switched to it with P=1/2
  2058. * and stayed with the first stream with P=1/2; and after we've
  2059. * considered the third stream, we've switched to it with P=1/3 and
  2060. * remained with one of the first two streams with P=(2/3), giving each
  2061. * one P=(1/2)(2/3) )=(1/3).) */
  2062. }
  2063. }
  2064. /* Count how many non-marked streams there are that have anything on
  2065. * their inbuf, and enable reading on all of the connections. */
  2066. n_packaging_streams = 0;
  2067. /* Activate reading starting from the chosen stream */
  2068. for (conn=chosen_stream; conn; conn = conn->next_stream) {
  2069. /* Start reading for the streams starting from here */
  2070. if (conn->base_.marked_for_close || conn->package_window <= 0)
  2071. continue;
  2072. if (!layer_hint || conn->cpath_layer == layer_hint) {
  2073. connection_start_reading(TO_CONN(conn));
  2074. if (connection_get_inbuf_len(TO_CONN(conn)) > 0)
  2075. ++n_packaging_streams;
  2076. }
  2077. }
  2078. /* Go back and do the ones we skipped, circular-style */
  2079. for (conn = first_conn; conn != chosen_stream; conn = conn->next_stream) {
  2080. if (conn->base_.marked_for_close || conn->package_window <= 0)
  2081. continue;
  2082. if (!layer_hint || conn->cpath_layer == layer_hint) {
  2083. connection_start_reading(TO_CONN(conn));
  2084. if (connection_get_inbuf_len(TO_CONN(conn)) > 0)
  2085. ++n_packaging_streams;
  2086. }
  2087. }
  2088. if (n_packaging_streams == 0) /* avoid divide-by-zero */
  2089. return 0;
  2090. again:
  2091. cells_per_conn = CEIL_DIV(max_to_package, n_packaging_streams);
  2092. packaged_this_round = 0;
  2093. n_streams_left = 0;
  2094. /* Iterate over all connections. Package up to cells_per_conn cells on
  2095. * each. Update packaged_this_round with the total number of cells
  2096. * packaged, and n_streams_left with the number that still have data to
  2097. * package.
  2098. */
  2099. for (conn=first_conn; conn; conn=conn->next_stream) {
  2100. if (conn->base_.marked_for_close || conn->package_window <= 0)
  2101. continue;
  2102. if (!layer_hint || conn->cpath_layer == layer_hint) {
  2103. int n = cells_per_conn, r;
  2104. /* handle whatever might still be on the inbuf */
  2105. r = connection_edge_package_raw_inbuf(conn, 1, &n);
  2106. /* Note how many we packaged */
  2107. packaged_this_round += (cells_per_conn-n);
  2108. if (r<0) {
  2109. /* Problem while packaging. (We already sent an end cell if
  2110. * possible) */
  2111. connection_mark_for_close(TO_CONN(conn));
  2112. continue;
  2113. }
  2114. /* If there's still data to read, we'll be coming back to this stream. */
  2115. if (connection_get_inbuf_len(TO_CONN(conn)))
  2116. ++n_streams_left;
  2117. /* If the circuit won't accept any more data, return without looking
  2118. * at any more of the streams. Any connections that should be stopped
  2119. * have already been stopped by connection_edge_package_raw_inbuf. */
  2120. if (circuit_consider_stop_edge_reading(circ, layer_hint))
  2121. return -1;
  2122. /* XXXX should we also stop immediately if we fill up the cell queue?
  2123. * Probably. */
  2124. }
  2125. }
  2126. /* If we made progress, and we are willing to package more, and there are
  2127. * any streams left that want to package stuff... try again!
  2128. */
  2129. if (packaged_this_round && packaged_this_round < max_to_package &&
  2130. n_streams_left) {
  2131. max_to_package -= packaged_this_round;
  2132. n_packaging_streams = n_streams_left;
  2133. goto again;
  2134. }
  2135. return 0;
  2136. }
  2137. /** Check if the package window for <b>circ</b> is empty (at
  2138. * hop <b>layer_hint</b> if it's defined).
  2139. *
  2140. * If yes, tell edge streams to stop reading and return 1.
  2141. * Else return 0.
  2142. */
  2143. static int
  2144. circuit_consider_stop_edge_reading(circuit_t *circ, crypt_path_t *layer_hint)
  2145. {
  2146. edge_connection_t *conn = NULL;
  2147. unsigned domain = layer_hint ? LD_APP : LD_EXIT;
  2148. if (!layer_hint) {
  2149. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  2150. log_debug(domain,"considering circ->package_window %d",
  2151. circ->package_window);
  2152. if (circ->package_window <= 0) {
  2153. log_debug(domain,"yes, not-at-origin. stopped.");
  2154. for (conn = or_circ->n_streams; conn; conn=conn->next_stream)
  2155. connection_stop_reading(TO_CONN(conn));
  2156. return 1;
  2157. }
  2158. return 0;
  2159. }
  2160. /* else, layer hint is defined, use it */
  2161. log_debug(domain,"considering layer_hint->package_window %d",
  2162. layer_hint->package_window);
  2163. if (layer_hint->package_window <= 0) {
  2164. log_debug(domain,"yes, at-origin. stopped.");
  2165. for (conn = TO_ORIGIN_CIRCUIT(circ)->p_streams; conn;
  2166. conn=conn->next_stream) {
  2167. if (conn->cpath_layer == layer_hint)
  2168. connection_stop_reading(TO_CONN(conn));
  2169. }
  2170. return 1;
  2171. }
  2172. return 0;
  2173. }
  2174. /** Check if the deliver_window for circuit <b>circ</b> (at hop
  2175. * <b>layer_hint</b> if it's defined) is low enough that we should
  2176. * send a circuit-level sendme back down the circuit. If so, send
  2177. * enough sendmes that the window would be overfull if we sent any
  2178. * more.
  2179. */
  2180. static void
  2181. circuit_consider_sending_sendme(circuit_t *circ, crypt_path_t *layer_hint)
  2182. {
  2183. // log_fn(LOG_INFO,"Considering: layer_hint is %s",
  2184. // layer_hint ? "defined" : "null");
  2185. while ((layer_hint ? layer_hint->deliver_window : circ->deliver_window) <=
  2186. CIRCWINDOW_START - CIRCWINDOW_INCREMENT) {
  2187. log_debug(LD_CIRC,"Queuing circuit sendme.");
  2188. if (layer_hint)
  2189. layer_hint->deliver_window += CIRCWINDOW_INCREMENT;
  2190. else
  2191. circ->deliver_window += CIRCWINDOW_INCREMENT;
  2192. if (relay_send_command_from_edge(0, circ, RELAY_COMMAND_SENDME,
  2193. NULL, 0, layer_hint) < 0) {
  2194. log_warn(LD_CIRC,
  2195. "relay_send_command_from_edge failed. Circuit's closed.");
  2196. return; /* the circuit's closed, don't continue */
  2197. }
  2198. }
  2199. }
  2200. #ifdef ACTIVE_CIRCUITS_PARANOIA
  2201. #define assert_cmux_ok_paranoid(chan) \
  2202. assert_circuit_mux_okay(chan)
  2203. #else
  2204. #define assert_cmux_ok_paranoid(chan)
  2205. #endif /* defined(ACTIVE_CIRCUITS_PARANOIA) */
  2206. /** The total number of cells we have allocated. */
  2207. static size_t total_cells_allocated = 0;
  2208. /** Release storage held by <b>cell</b>. */
  2209. static inline void
  2210. packed_cell_free_unchecked(packed_cell_t *cell)
  2211. {
  2212. --total_cells_allocated;
  2213. tor_free(cell);
  2214. }
  2215. /** Allocate and return a new packed_cell_t. */
  2216. STATIC packed_cell_t *
  2217. packed_cell_new(void)
  2218. {
  2219. ++total_cells_allocated;
  2220. return tor_malloc_zero(sizeof(packed_cell_t));
  2221. }
  2222. /** Return a packed cell used outside by channel_t lower layer */
  2223. void
  2224. packed_cell_free_(packed_cell_t *cell)
  2225. {
  2226. if (!cell)
  2227. return;
  2228. packed_cell_free_unchecked(cell);
  2229. }
  2230. /** Log current statistics for cell pool allocation at log level
  2231. * <b>severity</b>. */
  2232. void
  2233. dump_cell_pool_usage(int severity)
  2234. {
  2235. int n_circs = 0;
  2236. int n_cells = 0;
  2237. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, c) {
  2238. n_cells += c->n_chan_cells.n;
  2239. if (!CIRCUIT_IS_ORIGIN(c))
  2240. n_cells += TO_OR_CIRCUIT(c)->p_chan_cells.n;
  2241. ++n_circs;
  2242. }
  2243. SMARTLIST_FOREACH_END(c);
  2244. tor_log(severity, LD_MM,
  2245. "%d cells allocated on %d circuits. %d cells leaked.",
  2246. n_cells, n_circs, (int)total_cells_allocated - n_cells);
  2247. }
  2248. /** Allocate a new copy of packed <b>cell</b>. */
  2249. static inline packed_cell_t *
  2250. packed_cell_copy(const cell_t *cell, int wide_circ_ids)
  2251. {
  2252. packed_cell_t *c = packed_cell_new();
  2253. cell_pack(c, cell, wide_circ_ids);
  2254. return c;
  2255. }
  2256. /** Append <b>cell</b> to the end of <b>queue</b>. */
  2257. void
  2258. cell_queue_append(cell_queue_t *queue, packed_cell_t *cell)
  2259. {
  2260. TOR_SIMPLEQ_INSERT_TAIL(&queue->head, cell, next);
  2261. ++queue->n;
  2262. }
  2263. /** Append a newly allocated copy of <b>cell</b> to the end of the
  2264. * <b>exitward</b> (or app-ward) <b>queue</b> of <b>circ</b>. If
  2265. * <b>use_stats</b> is true, record statistics about the cell.
  2266. */
  2267. void
  2268. cell_queue_append_packed_copy(circuit_t *circ, cell_queue_t *queue,
  2269. int exitward, const cell_t *cell,
  2270. int wide_circ_ids, int use_stats)
  2271. {
  2272. packed_cell_t *copy = packed_cell_copy(cell, wide_circ_ids);
  2273. (void)circ;
  2274. (void)exitward;
  2275. (void)use_stats;
  2276. copy->inserted_timestamp = monotime_coarse_get_stamp();
  2277. cell_queue_append(queue, copy);
  2278. }
  2279. /** Initialize <b>queue</b> as an empty cell queue. */
  2280. void
  2281. cell_queue_init(cell_queue_t *queue)
  2282. {
  2283. memset(queue, 0, sizeof(cell_queue_t));
  2284. TOR_SIMPLEQ_INIT(&queue->head);
  2285. }
  2286. /** Remove and free every cell in <b>queue</b>. */
  2287. void
  2288. cell_queue_clear(cell_queue_t *queue)
  2289. {
  2290. packed_cell_t *cell;
  2291. while ((cell = TOR_SIMPLEQ_FIRST(&queue->head))) {
  2292. TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
  2293. packed_cell_free_unchecked(cell);
  2294. }
  2295. TOR_SIMPLEQ_INIT(&queue->head);
  2296. queue->n = 0;
  2297. }
  2298. /** Extract and return the cell at the head of <b>queue</b>; return NULL if
  2299. * <b>queue</b> is empty. */
  2300. STATIC packed_cell_t *
  2301. cell_queue_pop(cell_queue_t *queue)
  2302. {
  2303. packed_cell_t *cell = TOR_SIMPLEQ_FIRST(&queue->head);
  2304. if (!cell)
  2305. return NULL;
  2306. TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
  2307. --queue->n;
  2308. return cell;
  2309. }
  2310. /** Initialize <b>queue</b> as an empty cell queue. */
  2311. void
  2312. destroy_cell_queue_init(destroy_cell_queue_t *queue)
  2313. {
  2314. memset(queue, 0, sizeof(destroy_cell_queue_t));
  2315. TOR_SIMPLEQ_INIT(&queue->head);
  2316. }
  2317. /** Remove and free every cell in <b>queue</b>. */
  2318. void
  2319. destroy_cell_queue_clear(destroy_cell_queue_t *queue)
  2320. {
  2321. destroy_cell_t *cell;
  2322. while ((cell = TOR_SIMPLEQ_FIRST(&queue->head))) {
  2323. TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
  2324. tor_free(cell);
  2325. }
  2326. TOR_SIMPLEQ_INIT(&queue->head);
  2327. queue->n = 0;
  2328. }
  2329. /** Extract and return the cell at the head of <b>queue</b>; return NULL if
  2330. * <b>queue</b> is empty. */
  2331. STATIC destroy_cell_t *
  2332. destroy_cell_queue_pop(destroy_cell_queue_t *queue)
  2333. {
  2334. destroy_cell_t *cell = TOR_SIMPLEQ_FIRST(&queue->head);
  2335. if (!cell)
  2336. return NULL;
  2337. TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
  2338. --queue->n;
  2339. return cell;
  2340. }
  2341. /** Append a destroy cell for <b>circid</b> to <b>queue</b>. */
  2342. void
  2343. destroy_cell_queue_append(destroy_cell_queue_t *queue,
  2344. circid_t circid,
  2345. uint8_t reason)
  2346. {
  2347. destroy_cell_t *cell = tor_malloc_zero(sizeof(destroy_cell_t));
  2348. cell->circid = circid;
  2349. cell->reason = reason;
  2350. /* Not yet used, but will be required for OOM handling. */
  2351. cell->inserted_timestamp = monotime_coarse_get_stamp();
  2352. TOR_SIMPLEQ_INSERT_TAIL(&queue->head, cell, next);
  2353. ++queue->n;
  2354. }
  2355. /** Convert a destroy_cell_t to a newly allocated cell_t. Frees its input. */
  2356. static packed_cell_t *
  2357. destroy_cell_to_packed_cell(destroy_cell_t *inp, int wide_circ_ids)
  2358. {
  2359. packed_cell_t *packed = packed_cell_new();
  2360. cell_t cell;
  2361. memset(&cell, 0, sizeof(cell));
  2362. cell.circ_id = inp->circid;
  2363. cell.command = CELL_DESTROY;
  2364. cell.payload[0] = inp->reason;
  2365. cell_pack(packed, &cell, wide_circ_ids);
  2366. tor_free(inp);
  2367. return packed;
  2368. }
  2369. /** Return the total number of bytes used for each packed_cell in a queue.
  2370. * Approximate. */
  2371. size_t
  2372. packed_cell_mem_cost(void)
  2373. {
  2374. return sizeof(packed_cell_t);
  2375. }
  2376. /* DOCDOC */
  2377. size_t
  2378. cell_queues_get_total_allocation(void)
  2379. {
  2380. return total_cells_allocated * packed_cell_mem_cost();
  2381. }
  2382. /** How long after we've been low on memory should we try to conserve it? */
  2383. #define MEMORY_PRESSURE_INTERVAL (30*60)
  2384. /** The time at which we were last low on memory. */
  2385. static time_t last_time_under_memory_pressure = 0;
  2386. /** Check whether we've got too much space used for cells. If so,
  2387. * call the OOM handler and return 1. Otherwise, return 0. */
  2388. STATIC int
  2389. cell_queues_check_size(void)
  2390. {
  2391. time_t now = time(NULL);
  2392. size_t alloc = cell_queues_get_total_allocation();
  2393. alloc += buf_get_total_allocation();
  2394. alloc += tor_compress_get_total_allocation();
  2395. const size_t rend_cache_total = rend_cache_get_total_allocation();
  2396. alloc += rend_cache_total;
  2397. const size_t geoip_client_cache_total =
  2398. geoip_client_cache_total_allocation();
  2399. alloc += geoip_client_cache_total;
  2400. if (alloc >= get_options()->MaxMemInQueues_low_threshold) {
  2401. last_time_under_memory_pressure = approx_time();
  2402. if (alloc >= get_options()->MaxMemInQueues) {
  2403. /* If we're spending over 20% of the memory limit on hidden service
  2404. * descriptors, free them until we're down to 10%. Do the same for geoip
  2405. * client cache. */
  2406. if (rend_cache_total > get_options()->MaxMemInQueues / 5) {
  2407. const size_t bytes_to_remove =
  2408. rend_cache_total - (size_t)(get_options()->MaxMemInQueues / 10);
  2409. alloc -= hs_cache_handle_oom(now, bytes_to_remove);
  2410. }
  2411. if (geoip_client_cache_total > get_options()->MaxMemInQueues / 5) {
  2412. const size_t bytes_to_remove =
  2413. geoip_client_cache_total -
  2414. (size_t)(get_options()->MaxMemInQueues / 10);
  2415. alloc -= geoip_client_cache_handle_oom(now, bytes_to_remove);
  2416. }
  2417. circuits_handle_oom(alloc);
  2418. return 1;
  2419. }
  2420. }
  2421. return 0;
  2422. }
  2423. /** Return true if we've been under memory pressure in the last
  2424. * MEMORY_PRESSURE_INTERVAL seconds. */
  2425. int
  2426. have_been_under_memory_pressure(void)
  2427. {
  2428. return last_time_under_memory_pressure + MEMORY_PRESSURE_INTERVAL
  2429. < approx_time();
  2430. }
  2431. /**
  2432. * Update the number of cells available on the circuit's n_chan or p_chan's
  2433. * circuit mux.
  2434. */
  2435. void
  2436. update_circuit_on_cmux_(circuit_t *circ, cell_direction_t direction,
  2437. const char *file, int lineno)
  2438. {
  2439. channel_t *chan = NULL;
  2440. or_circuit_t *or_circ = NULL;
  2441. circuitmux_t *cmux = NULL;
  2442. tor_assert(circ);
  2443. /* Okay, get the channel */
  2444. if (direction == CELL_DIRECTION_OUT) {
  2445. chan = circ->n_chan;
  2446. } else {
  2447. or_circ = TO_OR_CIRCUIT(circ);
  2448. chan = or_circ->p_chan;
  2449. }
  2450. tor_assert(chan);
  2451. tor_assert(chan->cmux);
  2452. /* Now get the cmux */
  2453. cmux = chan->cmux;
  2454. /* Cmux sanity check */
  2455. if (! circuitmux_is_circuit_attached(cmux, circ)) {
  2456. log_warn(LD_BUG, "called on non-attached circuit from %s:%d",
  2457. file, lineno);
  2458. return;
  2459. }
  2460. tor_assert(circuitmux_attached_circuit_direction(cmux, circ) == direction);
  2461. assert_cmux_ok_paranoid(chan);
  2462. /* Update the number of cells we have for the circuit mux */
  2463. if (direction == CELL_DIRECTION_OUT) {
  2464. circuitmux_set_num_cells(cmux, circ, circ->n_chan_cells.n);
  2465. } else {
  2466. circuitmux_set_num_cells(cmux, circ, or_circ->p_chan_cells.n);
  2467. }
  2468. assert_cmux_ok_paranoid(chan);
  2469. }
  2470. /** Remove all circuits from the cmux on <b>chan</b>.
  2471. *
  2472. * If <b>circuits_out</b> is non-NULL, add all detached circuits to
  2473. * <b>circuits_out</b>.
  2474. **/
  2475. void
  2476. channel_unlink_all_circuits(channel_t *chan, smartlist_t *circuits_out)
  2477. {
  2478. tor_assert(chan);
  2479. tor_assert(chan->cmux);
  2480. circuitmux_detach_all_circuits(chan->cmux, circuits_out);
  2481. chan->num_n_circuits = 0;
  2482. chan->num_p_circuits = 0;
  2483. }
  2484. /** Block (if <b>block</b> is true) or unblock (if <b>block</b> is false)
  2485. * every edge connection that is using <b>circ</b> to write to <b>chan</b>,
  2486. * and start or stop reading as appropriate.
  2487. *
  2488. * If <b>stream_id</b> is nonzero, block only the edge connection whose
  2489. * stream_id matches it.
  2490. *
  2491. * Returns the number of streams whose status we changed.
  2492. */
  2493. static int
  2494. set_streams_blocked_on_circ(circuit_t *circ, channel_t *chan,
  2495. int block, streamid_t stream_id)
  2496. {
  2497. edge_connection_t *edge = NULL;
  2498. int n = 0;
  2499. if (circ->n_chan == chan) {
  2500. circ->streams_blocked_on_n_chan = block;
  2501. if (CIRCUIT_IS_ORIGIN(circ))
  2502. edge = TO_ORIGIN_CIRCUIT(circ)->p_streams;
  2503. } else {
  2504. circ->streams_blocked_on_p_chan = block;
  2505. tor_assert(!CIRCUIT_IS_ORIGIN(circ));
  2506. edge = TO_OR_CIRCUIT(circ)->n_streams;
  2507. }
  2508. for (; edge; edge = edge->next_stream) {
  2509. connection_t *conn = TO_CONN(edge);
  2510. if (stream_id && edge->stream_id != stream_id)
  2511. continue;
  2512. if (edge->edge_blocked_on_circ != block) {
  2513. ++n;
  2514. edge->edge_blocked_on_circ = block;
  2515. }
  2516. if (!conn->read_event) {
  2517. /* This connection is a placeholder for something; probably a DNS
  2518. * request. It can't actually stop or start reading.*/
  2519. continue;
  2520. }
  2521. if (block) {
  2522. if (connection_is_reading(conn))
  2523. connection_stop_reading(conn);
  2524. } else {
  2525. /* Is this right? */
  2526. if (!connection_is_reading(conn))
  2527. connection_start_reading(conn);
  2528. }
  2529. }
  2530. return n;
  2531. }
  2532. /** Extract the command from a packed cell. */
  2533. static uint8_t
  2534. packed_cell_get_command(const packed_cell_t *cell, int wide_circ_ids)
  2535. {
  2536. if (wide_circ_ids) {
  2537. return get_uint8(cell->body+4);
  2538. } else {
  2539. return get_uint8(cell->body+2);
  2540. }
  2541. }
  2542. /** Extract the circuit ID from a packed cell. */
  2543. circid_t
  2544. packed_cell_get_circid(const packed_cell_t *cell, int wide_circ_ids)
  2545. {
  2546. if (wide_circ_ids) {
  2547. return ntohl(get_uint32(cell->body));
  2548. } else {
  2549. return ntohs(get_uint16(cell->body));
  2550. }
  2551. }
  2552. /** Pull as many cells as possible (but no more than <b>max</b>) from the
  2553. * queue of the first active circuit on <b>chan</b>, and write them to
  2554. * <b>chan</b>-&gt;outbuf. Return the number of cells written. Advance
  2555. * the active circuit pointer to the next active circuit in the ring. */
  2556. MOCK_IMPL(int,
  2557. channel_flush_from_first_active_circuit, (channel_t *chan, int max))
  2558. {
  2559. circuitmux_t *cmux = NULL;
  2560. int n_flushed = 0;
  2561. cell_queue_t *queue;
  2562. destroy_cell_queue_t *destroy_queue=NULL;
  2563. circuit_t *circ;
  2564. or_circuit_t *or_circ;
  2565. int streams_blocked;
  2566. packed_cell_t *cell;
  2567. /* Get the cmux */
  2568. tor_assert(chan);
  2569. tor_assert(chan->cmux);
  2570. cmux = chan->cmux;
  2571. /* Main loop: pick a circuit, send a cell, update the cmux */
  2572. while (n_flushed < max) {
  2573. circ = circuitmux_get_first_active_circuit(cmux, &destroy_queue);
  2574. if (destroy_queue) {
  2575. destroy_cell_t *dcell;
  2576. /* this code is duplicated from some of the logic below. Ugly! XXXX */
  2577. /* If we are given a destroy_queue here, then it is required to be
  2578. * nonempty... */
  2579. tor_assert(destroy_queue->n > 0);
  2580. dcell = destroy_cell_queue_pop(destroy_queue);
  2581. /* ...and pop() will always yield a cell from a nonempty queue. */
  2582. tor_assert(dcell);
  2583. /* frees dcell */
  2584. cell = destroy_cell_to_packed_cell(dcell, chan->wide_circ_ids);
  2585. /* Send the DESTROY cell. It is very unlikely that this fails but just
  2586. * in case, get rid of the channel. */
  2587. if (channel_write_packed_cell(chan, cell) < 0) {
  2588. /* The cell has been freed. */
  2589. channel_mark_for_close(chan);
  2590. continue;
  2591. }
  2592. /* Update the cmux destroy counter */
  2593. circuitmux_notify_xmit_destroy(cmux);
  2594. cell = NULL;
  2595. ++n_flushed;
  2596. continue;
  2597. }
  2598. /* If it returns NULL, no cells left to send */
  2599. if (!circ) break;
  2600. assert_cmux_ok_paranoid(chan);
  2601. if (circ->n_chan == chan) {
  2602. queue = &circ->n_chan_cells;
  2603. streams_blocked = circ->streams_blocked_on_n_chan;
  2604. } else {
  2605. or_circ = TO_OR_CIRCUIT(circ);
  2606. tor_assert(or_circ->p_chan == chan);
  2607. queue = &TO_OR_CIRCUIT(circ)->p_chan_cells;
  2608. streams_blocked = circ->streams_blocked_on_p_chan;
  2609. }
  2610. /* Circuitmux told us this was active, so it should have cells */
  2611. if (/*BUG(*/ queue->n == 0 /*)*/) {
  2612. log_warn(LD_BUG, "Found a supposedly active circuit with no cells "
  2613. "to send. Trying to recover.");
  2614. circuitmux_set_num_cells(cmux, circ, 0);
  2615. if (! circ->marked_for_close)
  2616. circuit_mark_for_close(circ, END_CIRC_REASON_INTERNAL);
  2617. continue;
  2618. }
  2619. tor_assert(queue->n > 0);
  2620. /*
  2621. * Get just one cell here; once we've sent it, that can change the circuit
  2622. * selection, so we have to loop around for another even if this circuit
  2623. * has more than one.
  2624. */
  2625. cell = cell_queue_pop(queue);
  2626. /* Calculate the exact time that this cell has spent in the queue. */
  2627. if (get_options()->CellStatistics ||
  2628. get_options()->TestingEnableCellStatsEvent) {
  2629. uint32_t timestamp_now = monotime_coarse_get_stamp();
  2630. uint32_t msec_waiting =
  2631. (uint32_t) monotime_coarse_stamp_units_to_approx_msec(
  2632. timestamp_now - cell->inserted_timestamp);
  2633. if (get_options()->CellStatistics && !CIRCUIT_IS_ORIGIN(circ)) {
  2634. or_circ = TO_OR_CIRCUIT(circ);
  2635. or_circ->total_cell_waiting_time += msec_waiting;
  2636. or_circ->processed_cells++;
  2637. }
  2638. if (get_options()->TestingEnableCellStatsEvent) {
  2639. uint8_t command = packed_cell_get_command(cell, chan->wide_circ_ids);
  2640. testing_cell_stats_entry_t *ent =
  2641. tor_malloc_zero(sizeof(testing_cell_stats_entry_t));
  2642. ent->command = command;
  2643. ent->waiting_time = msec_waiting / 10;
  2644. ent->removed = 1;
  2645. if (circ->n_chan == chan)
  2646. ent->exitward = 1;
  2647. if (!circ->testing_cell_stats)
  2648. circ->testing_cell_stats = smartlist_new();
  2649. smartlist_add(circ->testing_cell_stats, ent);
  2650. }
  2651. }
  2652. /* If we just flushed our queue and this circuit is used for a
  2653. * tunneled directory request, possibly advance its state. */
  2654. if (queue->n == 0 && chan->dirreq_id)
  2655. geoip_change_dirreq_state(chan->dirreq_id,
  2656. DIRREQ_TUNNELED,
  2657. DIRREQ_CIRC_QUEUE_FLUSHED);
  2658. /* Now send the cell. It is very unlikely that this fails but just in
  2659. * case, get rid of the channel. */
  2660. if (channel_write_packed_cell(chan, cell) < 0) {
  2661. /* The cell has been freed at this point. */
  2662. channel_mark_for_close(chan);
  2663. continue;
  2664. }
  2665. cell = NULL;
  2666. /*
  2667. * Don't packed_cell_free_unchecked(cell) here because the channel will
  2668. * do so when it gets out of the channel queue (probably already did, in
  2669. * which case that was an immediate double-free bug).
  2670. */
  2671. /* Update the counter */
  2672. ++n_flushed;
  2673. /*
  2674. * Now update the cmux; tell it we've just sent a cell, and how many
  2675. * we have left.
  2676. */
  2677. circuitmux_notify_xmit_cells(cmux, circ, 1);
  2678. circuitmux_set_num_cells(cmux, circ, queue->n);
  2679. if (queue->n == 0)
  2680. log_debug(LD_GENERAL, "Made a circuit inactive.");
  2681. /* Is the cell queue low enough to unblock all the streams that are waiting
  2682. * to write to this circuit? */
  2683. if (streams_blocked && queue->n <= CELL_QUEUE_LOWWATER_SIZE)
  2684. set_streams_blocked_on_circ(circ, chan, 0, 0); /* unblock streams */
  2685. /* If n_flushed < max still, loop around and pick another circuit */
  2686. }
  2687. /* Okay, we're done sending now */
  2688. assert_cmux_ok_paranoid(chan);
  2689. return n_flushed;
  2690. }
  2691. /** Add <b>cell</b> to the queue of <b>circ</b> writing to <b>chan</b>
  2692. * transmitting in <b>direction</b>.
  2693. *
  2694. * The given <b>cell</b> is copied over the circuit queue so the caller must
  2695. * cleanup the memory.
  2696. *
  2697. * This function is part of the fast path. */
  2698. void
  2699. append_cell_to_circuit_queue(circuit_t *circ, channel_t *chan,
  2700. cell_t *cell, cell_direction_t direction,
  2701. streamid_t fromstream)
  2702. {
  2703. or_circuit_t *orcirc = NULL;
  2704. cell_queue_t *queue;
  2705. int streams_blocked;
  2706. int exitward;
  2707. if (circ->marked_for_close)
  2708. return;
  2709. exitward = (direction == CELL_DIRECTION_OUT);
  2710. if (exitward) {
  2711. queue = &circ->n_chan_cells;
  2712. streams_blocked = circ->streams_blocked_on_n_chan;
  2713. } else {
  2714. orcirc = TO_OR_CIRCUIT(circ);
  2715. queue = &orcirc->p_chan_cells;
  2716. streams_blocked = circ->streams_blocked_on_p_chan;
  2717. }
  2718. /* Very important that we copy to the circuit queue because all calls to
  2719. * this function use the stack for the cell memory. */
  2720. cell_queue_append_packed_copy(circ, queue, exitward, cell,
  2721. chan->wide_circ_ids, 1);
  2722. /* Check and run the OOM if needed. */
  2723. if (PREDICT_UNLIKELY(cell_queues_check_size())) {
  2724. /* We ran the OOM handler which might have closed this circuit. */
  2725. if (circ->marked_for_close)
  2726. return;
  2727. }
  2728. /* If we have too many cells on the circuit, we should stop reading from
  2729. * the edge streams for a while. */
  2730. if (!streams_blocked && queue->n >= CELL_QUEUE_HIGHWATER_SIZE)
  2731. set_streams_blocked_on_circ(circ, chan, 1, 0); /* block streams */
  2732. if (streams_blocked && fromstream) {
  2733. /* This edge connection is apparently not blocked; block it. */
  2734. set_streams_blocked_on_circ(circ, chan, 1, fromstream);
  2735. }
  2736. update_circuit_on_cmux(circ, direction);
  2737. if (queue->n == 1) {
  2738. /* This was the first cell added to the queue. We just made this
  2739. * circuit active. */
  2740. log_debug(LD_GENERAL, "Made a circuit active.");
  2741. }
  2742. /* New way: mark this as having waiting cells for the scheduler */
  2743. scheduler_channel_has_waiting_cells(chan);
  2744. }
  2745. /** Append an encoded value of <b>addr</b> to <b>payload_out</b>, which must
  2746. * have at least 18 bytes of free space. The encoding is, as specified in
  2747. * tor-spec.txt:
  2748. * RESOLVED_TYPE_IPV4 or RESOLVED_TYPE_IPV6 [1 byte]
  2749. * LENGTH [1 byte]
  2750. * ADDRESS [length bytes]
  2751. * Return the number of bytes added, or -1 on error */
  2752. int
  2753. append_address_to_payload(uint8_t *payload_out, const tor_addr_t *addr)
  2754. {
  2755. uint32_t a;
  2756. switch (tor_addr_family(addr)) {
  2757. case AF_INET:
  2758. payload_out[0] = RESOLVED_TYPE_IPV4;
  2759. payload_out[1] = 4;
  2760. a = tor_addr_to_ipv4n(addr);
  2761. memcpy(payload_out+2, &a, 4);
  2762. return 6;
  2763. case AF_INET6:
  2764. payload_out[0] = RESOLVED_TYPE_IPV6;
  2765. payload_out[1] = 16;
  2766. memcpy(payload_out+2, tor_addr_to_in6_addr8(addr), 16);
  2767. return 18;
  2768. case AF_UNSPEC:
  2769. default:
  2770. return -1;
  2771. }
  2772. }
  2773. /** Given <b>payload_len</b> bytes at <b>payload</b>, starting with an address
  2774. * encoded as by append_address_to_payload(), try to decode the address into
  2775. * *<b>addr_out</b>. Return the next byte in the payload after the address on
  2776. * success, or NULL on failure. */
  2777. const uint8_t *
  2778. decode_address_from_payload(tor_addr_t *addr_out, const uint8_t *payload,
  2779. int payload_len)
  2780. {
  2781. if (payload_len < 2)
  2782. return NULL;
  2783. if (payload_len < 2+payload[1])
  2784. return NULL;
  2785. switch (payload[0]) {
  2786. case RESOLVED_TYPE_IPV4:
  2787. if (payload[1] != 4)
  2788. return NULL;
  2789. tor_addr_from_ipv4n(addr_out, get_uint32(payload+2));
  2790. break;
  2791. case RESOLVED_TYPE_IPV6:
  2792. if (payload[1] != 16)
  2793. return NULL;
  2794. tor_addr_from_ipv6_bytes(addr_out, (char*)(payload+2));
  2795. break;
  2796. default:
  2797. tor_addr_make_unspec(addr_out);
  2798. break;
  2799. }
  2800. return payload + 2 + payload[1];
  2801. }
  2802. /** Remove all the cells queued on <b>circ</b> for <b>chan</b>. */
  2803. void
  2804. circuit_clear_cell_queue(circuit_t *circ, channel_t *chan)
  2805. {
  2806. cell_queue_t *queue;
  2807. cell_direction_t direction;
  2808. if (circ->n_chan == chan) {
  2809. queue = &circ->n_chan_cells;
  2810. direction = CELL_DIRECTION_OUT;
  2811. } else {
  2812. or_circuit_t *orcirc = TO_OR_CIRCUIT(circ);
  2813. tor_assert(orcirc->p_chan == chan);
  2814. queue = &orcirc->p_chan_cells;
  2815. direction = CELL_DIRECTION_IN;
  2816. }
  2817. /* Clear the queue */
  2818. cell_queue_clear(queue);
  2819. /* Update the cell counter in the cmux */
  2820. if (chan->cmux && circuitmux_is_circuit_attached(chan->cmux, circ))
  2821. update_circuit_on_cmux(circ, direction);
  2822. }
  2823. /** Fail with an assert if the circuit mux on chan is corrupt
  2824. */
  2825. void
  2826. assert_circuit_mux_okay(channel_t *chan)
  2827. {
  2828. tor_assert(chan);
  2829. tor_assert(chan->cmux);
  2830. circuitmux_assert_okay(chan->cmux);
  2831. }
  2832. /** Return 1 if we shouldn't restart reading on this circuit, even if
  2833. * we get a SENDME. Else return 0.
  2834. */
  2835. static int
  2836. circuit_queue_streams_are_blocked(circuit_t *circ)
  2837. {
  2838. if (CIRCUIT_IS_ORIGIN(circ)) {
  2839. return circ->streams_blocked_on_n_chan;
  2840. } else {
  2841. return circ->streams_blocked_on_p_chan;
  2842. }
  2843. }