relay.c 96 KB

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