relay.c 110 KB

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