relay.c 113 KB

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