relay.c 104 KB

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