relay.c 110 KB

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