channel.c 113 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078
  1. /* * Copyright (c) 2012, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. /**
  4. * \file channel.c
  5. * \brief OR-to-OR channel abstraction layer
  6. **/
  7. /*
  8. * Define this so channel.h gives us things only channel_t subclasses
  9. * should touch.
  10. */
  11. #define _TOR_CHANNEL_INTERNAL
  12. #include "or.h"
  13. #include "channel.h"
  14. #include "channeltls.h"
  15. #include "circuitbuild.h"
  16. #include "circuitlist.h"
  17. #include "connection_or.h" /* For var_cell_free() */
  18. #include "circuitmux.h"
  19. #include "geoip.h"
  20. #include "nodelist.h"
  21. #include "relay.h"
  22. #include "rephist.h"
  23. #include "router.h"
  24. #include "routerlist.h"
  25. /* Cell queue structure */
  26. typedef struct cell_queue_entry_s cell_queue_entry_t;
  27. struct cell_queue_entry_s {
  28. enum {
  29. CELL_QUEUE_FIXED,
  30. CELL_QUEUE_VAR,
  31. CELL_QUEUE_PACKED
  32. } type;
  33. union {
  34. struct {
  35. cell_t *cell;
  36. } fixed;
  37. struct {
  38. var_cell_t *var_cell;
  39. } var;
  40. struct {
  41. packed_cell_t *packed_cell;
  42. } packed;
  43. } u;
  44. };
  45. /* Global lists of channels */
  46. /* All channel_t instances */
  47. static smartlist_t *all_channels = NULL;
  48. /* All channel_t instances not in ERROR or CLOSED states */
  49. static smartlist_t *active_channels = NULL;
  50. /* All channel_t instances in ERROR or CLOSED states */
  51. static smartlist_t *finished_channels = NULL;
  52. /* All channel_listener_t instances */
  53. static smartlist_t *all_listeners = NULL;
  54. /* All channel_listener_t instances in LISTENING state */
  55. static smartlist_t *active_listeners = NULL;
  56. /* All channel_listener_t instances in LISTENING state */
  57. static smartlist_t *finished_listeners = NULL;
  58. /* Counter for ID numbers */
  59. static uint64_t n_channels_allocated = 0;
  60. /* Digest->channel map
  61. *
  62. * Similar to the one used in connection_or.c, this maps from the identity
  63. * digest of a remote endpoint to a channel_t to that endpoint. Channels
  64. * should be placed here when registered and removed when they close or error.
  65. * If more than one channel exists, follow the next_with_same_id pointer
  66. * as a linked list.
  67. */
  68. static digestmap_t *channel_identity_map = NULL;
  69. static cell_queue_entry_t * cell_queue_entry_dup(cell_queue_entry_t *q);
  70. static void cell_queue_entry_free(cell_queue_entry_t *q, int handed_off);
  71. static int cell_queue_entry_is_padding(cell_queue_entry_t *q);
  72. static cell_queue_entry_t *
  73. cell_queue_entry_new_fixed(cell_t *cell);
  74. static cell_queue_entry_t *
  75. cell_queue_entry_new_var(var_cell_t *var_cell);
  76. /* Functions to maintain the digest map */
  77. static void channel_add_to_digest_map(channel_t *chan);
  78. static void channel_remove_from_digest_map(channel_t *chan);
  79. /*
  80. * Flush cells from just the outgoing queue without trying to get them
  81. * from circuits; used internall by channel_flush_some_cells().
  82. */
  83. static ssize_t
  84. channel_flush_some_cells_from_outgoing_queue(channel_t *chan,
  85. ssize_t num_cells);
  86. static void channel_force_free(channel_t *chan);
  87. static void
  88. channel_free_list(smartlist_t *channels, int mark_for_close);
  89. static void
  90. channel_listener_free_list(smartlist_t *channels, int mark_for_close);
  91. static void channel_listener_force_free(channel_listener_t *chan_l);
  92. static void
  93. channel_write_cell_queue_entry(channel_t *chan, cell_queue_entry_t *q);
  94. /***********************************
  95. * Channel state utility functions *
  96. **********************************/
  97. /**
  98. * Indicate whether a given channel state is valid
  99. */
  100. int
  101. channel_state_is_valid(channel_state_t state)
  102. {
  103. int is_valid;
  104. switch (state) {
  105. case CHANNEL_STATE_CLOSED:
  106. case CHANNEL_STATE_CLOSING:
  107. case CHANNEL_STATE_ERROR:
  108. case CHANNEL_STATE_MAINT:
  109. case CHANNEL_STATE_OPENING:
  110. case CHANNEL_STATE_OPEN:
  111. is_valid = 1;
  112. break;
  113. case CHANNEL_STATE_LAST:
  114. default:
  115. is_valid = 0;
  116. }
  117. return is_valid;
  118. }
  119. /**
  120. * Indicate whether a given channel listener state is valid
  121. */
  122. int
  123. channel_listener_state_is_valid(channel_listener_state_t state)
  124. {
  125. int is_valid;
  126. switch (state) {
  127. case CHANNEL_LISTENER_STATE_CLOSED:
  128. case CHANNEL_LISTENER_STATE_LISTENING:
  129. case CHANNEL_LISTENER_STATE_CLOSING:
  130. case CHANNEL_LISTENER_STATE_ERROR:
  131. is_valid = 1;
  132. break;
  133. case CHANNEL_LISTENER_STATE_LAST:
  134. default:
  135. is_valid = 0;
  136. }
  137. return is_valid;
  138. }
  139. /**
  140. * Indicate whether a channel state transition is valid
  141. *
  142. * This function takes two channel states and indicates whether a
  143. * transition between them is permitted (see the state definitions and
  144. * transition table in or.h at the channel_state_t typedef).
  145. */
  146. int
  147. channel_state_can_transition(channel_state_t from, channel_state_t to)
  148. {
  149. int is_valid;
  150. switch (from) {
  151. case CHANNEL_STATE_CLOSED:
  152. is_valid = (to == CHANNEL_STATE_OPENING);
  153. break;
  154. case CHANNEL_STATE_CLOSING:
  155. is_valid = (to == CHANNEL_STATE_CLOSED ||
  156. to == CHANNEL_STATE_ERROR);
  157. break;
  158. case CHANNEL_STATE_ERROR:
  159. is_valid = 0;
  160. break;
  161. case CHANNEL_STATE_MAINT:
  162. is_valid = (to == CHANNEL_STATE_CLOSING ||
  163. to == CHANNEL_STATE_ERROR ||
  164. to == CHANNEL_STATE_OPEN);
  165. break;
  166. case CHANNEL_STATE_OPENING:
  167. is_valid = (to == CHANNEL_STATE_CLOSING ||
  168. to == CHANNEL_STATE_ERROR ||
  169. to == CHANNEL_STATE_OPEN);
  170. break;
  171. case CHANNEL_STATE_OPEN:
  172. is_valid = (to == CHANNEL_STATE_CLOSING ||
  173. to == CHANNEL_STATE_ERROR ||
  174. to == CHANNEL_STATE_MAINT);
  175. break;
  176. case CHANNEL_STATE_LAST:
  177. default:
  178. is_valid = 0;
  179. }
  180. return is_valid;
  181. }
  182. /**
  183. * Indicate whether a channel listener state transition is valid
  184. *
  185. * This function takes two channel listener states and indicates whether a
  186. * transition between them is permitted (see the state definitions and
  187. * transition table in or.h at the channel_listener_state_t typedef).
  188. */
  189. int
  190. channel_listener_state_can_transition(channel_listener_state_t from,
  191. channel_listener_state_t to)
  192. {
  193. int is_valid;
  194. switch (from) {
  195. case CHANNEL_LISTENER_STATE_CLOSED:
  196. is_valid = (to == CHANNEL_LISTENER_STATE_LISTENING);
  197. break;
  198. case CHANNEL_LISTENER_STATE_CLOSING:
  199. is_valid = (to == CHANNEL_LISTENER_STATE_CLOSED ||
  200. to == CHANNEL_LISTENER_STATE_ERROR);
  201. break;
  202. case CHANNEL_LISTENER_STATE_ERROR:
  203. is_valid = 0;
  204. break;
  205. case CHANNEL_LISTENER_STATE_LISTENING:
  206. is_valid = (to == CHANNEL_LISTENER_STATE_CLOSING ||
  207. to == CHANNEL_LISTENER_STATE_ERROR);
  208. break;
  209. case CHANNEL_LISTENER_STATE_LAST:
  210. default:
  211. is_valid = 0;
  212. }
  213. return is_valid;
  214. }
  215. /**
  216. * Return a human-readable description for a channel state
  217. */
  218. const char *
  219. channel_state_to_string(channel_state_t state)
  220. {
  221. const char *descr;
  222. switch (state) {
  223. case CHANNEL_STATE_CLOSED:
  224. descr = "closed";
  225. break;
  226. case CHANNEL_STATE_CLOSING:
  227. descr = "closing";
  228. break;
  229. case CHANNEL_STATE_ERROR:
  230. descr = "channel error";
  231. break;
  232. case CHANNEL_STATE_MAINT:
  233. descr = "temporarily suspended for maintenance";
  234. break;
  235. case CHANNEL_STATE_OPENING:
  236. descr = "opening";
  237. break;
  238. case CHANNEL_STATE_OPEN:
  239. descr = "open";
  240. break;
  241. case CHANNEL_STATE_LAST:
  242. default:
  243. descr = "unknown or invalid channel state";
  244. }
  245. return descr;
  246. }
  247. /**
  248. * Return a human-readable description for a channel listenier state
  249. */
  250. const char *
  251. channel_listener_state_to_string(channel_listener_state_t state)
  252. {
  253. const char *descr;
  254. switch (state) {
  255. case CHANNEL_LISTENER_STATE_CLOSED:
  256. descr = "closed";
  257. break;
  258. case CHANNEL_LISTENER_STATE_CLOSING:
  259. descr = "closing";
  260. break;
  261. case CHANNEL_LISTENER_STATE_ERROR:
  262. descr = "channel listener error";
  263. break;
  264. case CHANNEL_LISTENER_STATE_LISTENING:
  265. descr = "listening";
  266. break;
  267. case CHANNEL_LISTENER_STATE_LAST:
  268. default:
  269. descr = "unknown or invalid channel listener state";
  270. }
  271. return descr;
  272. }
  273. /***************************************
  274. * Channel registration/unregistration *
  275. ***************************************/
  276. /**
  277. * Register a channel
  278. *
  279. * This function registers a newly created channel in the global lists/maps
  280. * of active channels.
  281. */
  282. void
  283. channel_register(channel_t *chan)
  284. {
  285. tor_assert(chan);
  286. /* No-op if already registered */
  287. if (chan->registered) return;
  288. log_debug(LD_CHANNEL,
  289. "Registering channel %p (ID " U64_FORMAT ") "
  290. "in state %s (%d) with digest %s",
  291. chan, U64_PRINTF_ARG(chan->global_identifier),
  292. channel_state_to_string(chan->state), chan->state,
  293. hex_str(chan->identity_digest, DIGEST_LEN));
  294. /* Make sure we have all_channels, then add it */
  295. if (!all_channels) all_channels = smartlist_new();
  296. smartlist_add(all_channels, chan);
  297. /* Is it finished? */
  298. if (chan->state == CHANNEL_STATE_CLOSED ||
  299. chan->state == CHANNEL_STATE_ERROR) {
  300. /* Put it in the finished list, creating it if necessary */
  301. if (!finished_channels) finished_channels = smartlist_new();
  302. smartlist_add(finished_channels, chan);
  303. } else {
  304. /* Put it in the active list, creating it if necessary */
  305. if (!active_channels) active_channels = smartlist_new();
  306. smartlist_add(active_channels, chan);
  307. if (chan->state != CHANNEL_STATE_CLOSING) {
  308. /* It should have a digest set */
  309. if (!tor_digest_is_zero(chan->identity_digest)) {
  310. /* Yeah, we're good, add it to the map */
  311. channel_add_to_digest_map(chan);
  312. } else {
  313. log_info(LD_CHANNEL,
  314. "Channel %p (global ID " U64_FORMAT ") "
  315. "in state %s (%d) registered with no identity digest",
  316. chan, U64_PRINTF_ARG(chan->global_identifier),
  317. channel_state_to_string(chan->state), chan->state);
  318. }
  319. }
  320. }
  321. /* Mark it as registered */
  322. chan->registered = 1;
  323. }
  324. /**
  325. * Unregister a channel
  326. *
  327. * This function removes a channel from the global lists and maps and is used
  328. * when freeing a closed/errored channel.
  329. */
  330. void
  331. channel_unregister(channel_t *chan)
  332. {
  333. tor_assert(chan);
  334. /* No-op if not registered */
  335. if (!(chan->registered)) return;
  336. /* Is it finished? */
  337. if (chan->state == CHANNEL_STATE_CLOSED ||
  338. chan->state == CHANNEL_STATE_ERROR) {
  339. /* Get it out of the finished list */
  340. if (finished_channels) smartlist_remove(finished_channels, chan);
  341. } else {
  342. /* Get it out of the active list */
  343. if (active_channels) smartlist_remove(active_channels, chan);
  344. }
  345. /* Get it out of all_channels */
  346. if (all_channels) smartlist_remove(all_channels, chan);
  347. /* Mark it as unregistered */
  348. chan->registered = 0;
  349. /* Should it be in the digest map? */
  350. if (!tor_digest_is_zero(chan->identity_digest) &&
  351. !(chan->state == CHANNEL_STATE_CLOSING ||
  352. chan->state == CHANNEL_STATE_CLOSED ||
  353. chan->state == CHANNEL_STATE_ERROR)) {
  354. /* Remove it */
  355. channel_remove_from_digest_map(chan);
  356. }
  357. }
  358. /**
  359. * Register a channel listener
  360. *
  361. * This function registers a newly created channel listner in the global
  362. * lists/maps of active channel listeners.
  363. */
  364. void
  365. channel_listener_register(channel_listener_t *chan_l)
  366. {
  367. tor_assert(chan_l);
  368. /* No-op if already registered */
  369. if (chan_l->registered) return;
  370. log_debug(LD_CHANNEL,
  371. "Registering channel listener %p (ID " U64_FORMAT ") "
  372. "in state %s (%d)",
  373. chan_l, U64_PRINTF_ARG(chan_l->global_identifier),
  374. channel_listener_state_to_string(chan_l->state),
  375. chan_l->state);
  376. /* Make sure we have all_channels, then add it */
  377. if (!all_listeners) all_listeners = smartlist_new();
  378. smartlist_add(all_listeners, chan_l);
  379. /* Is it finished? */
  380. if (chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
  381. chan_l->state == CHANNEL_LISTENER_STATE_ERROR) {
  382. /* Put it in the finished list, creating it if necessary */
  383. if (!finished_listeners) finished_listeners = smartlist_new();
  384. smartlist_add(finished_listeners, chan_l);
  385. } else {
  386. /* Put it in the active list, creating it if necessary */
  387. if (!active_listeners) active_listeners = smartlist_new();
  388. smartlist_add(active_listeners, chan_l);
  389. }
  390. /* Mark it as registered */
  391. chan_l->registered = 1;
  392. }
  393. /**
  394. * Unregister a channel listener
  395. *
  396. * This function removes a channel listener from the global lists and maps
  397. * and is used when freeing a closed/errored channel listener.
  398. */
  399. void
  400. channel_listener_unregister(channel_listener_t *chan_l)
  401. {
  402. tor_assert(chan_l);
  403. /* No-op if not registered */
  404. if (!(chan_l->registered)) return;
  405. /* Is it finished? */
  406. if (chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
  407. chan_l->state == CHANNEL_LISTENER_STATE_ERROR) {
  408. /* Get it out of the finished list */
  409. if (finished_listeners) smartlist_remove(finished_listeners, chan_l);
  410. } else {
  411. /* Get it out of the active list */
  412. if (active_listeners) smartlist_remove(active_listeners, chan_l);
  413. }
  414. /* Get it out of all_channels */
  415. if (all_listeners) smartlist_remove(all_listeners, chan_l);
  416. /* Mark it as unregistered */
  417. chan_l->registered = 0;
  418. }
  419. /*********************************
  420. * Channel digest map maintenance
  421. *********************************/
  422. /**
  423. * Add a channel to the digest map
  424. *
  425. * This function adds a channel to the digest map and inserts it into the
  426. * correct linked list if channels with that remote endpoint identity digest
  427. * already exist.
  428. */
  429. static void
  430. channel_add_to_digest_map(channel_t *chan)
  431. {
  432. channel_t *tmp;
  433. tor_assert(chan);
  434. /* Assert that the state makes sense */
  435. tor_assert(!(chan->state == CHANNEL_STATE_CLOSING ||
  436. chan->state == CHANNEL_STATE_CLOSED ||
  437. chan->state == CHANNEL_STATE_ERROR));
  438. /* Assert that there is a digest */
  439. tor_assert(!tor_digest_is_zero(chan->identity_digest));
  440. /* Allocate the identity map if we have to */
  441. if (!channel_identity_map) channel_identity_map = digestmap_new();
  442. /* Insert it */
  443. tmp = digestmap_set(channel_identity_map,
  444. chan->identity_digest,
  445. chan);
  446. if (tmp) {
  447. /* There already was one, this goes at the head of the list */
  448. chan->next_with_same_id = tmp;
  449. chan->prev_with_same_id = NULL;
  450. tmp->prev_with_same_id = chan;
  451. } else {
  452. /* First with this digest */
  453. chan->next_with_same_id = NULL;
  454. chan->prev_with_same_id = NULL;
  455. }
  456. log_debug(LD_CHANNEL,
  457. "Added channel %p (global ID " U64_FORMAT ") "
  458. "to identity map in state %s (%d) with digest %s",
  459. chan, U64_PRINTF_ARG(chan->global_identifier),
  460. channel_state_to_string(chan->state), chan->state,
  461. hex_str(chan->identity_digest, DIGEST_LEN));
  462. }
  463. /**
  464. * Remove a channel from the digest map
  465. *
  466. * This function removes a channel from the digest map and the linked list of
  467. * channels for that digest if more than one exists.
  468. */
  469. static void
  470. channel_remove_from_digest_map(channel_t *chan)
  471. {
  472. channel_t *tmp, *head;
  473. tor_assert(chan);
  474. /* Assert that there is a digest */
  475. tor_assert(!tor_digest_is_zero(chan->identity_digest));
  476. /* Make sure we have a map */
  477. if (!channel_identity_map) {
  478. /*
  479. * No identity map, so we can't find it by definition. This
  480. * case is similar to digestmap_get() failing below.
  481. */
  482. log_warn(LD_BUG,
  483. "Trying to remove channel %p (global ID " U64_FORMAT ") "
  484. "with digest %s from identity map, but didn't have any identity "
  485. "map",
  486. chan, U64_PRINTF_ARG(chan->global_identifier),
  487. hex_str(chan->identity_digest, DIGEST_LEN));
  488. /* Clear out its next/prev pointers */
  489. if (chan->next_with_same_id) {
  490. chan->next_with_same_id->prev_with_same_id = chan->prev_with_same_id;
  491. }
  492. if (chan->prev_with_same_id) {
  493. chan->prev_with_same_id->next_with_same_id = chan->next_with_same_id;
  494. }
  495. chan->next_with_same_id = NULL;
  496. chan->prev_with_same_id = NULL;
  497. return;
  498. }
  499. /* Look for it in the map */
  500. tmp = digestmap_get(channel_identity_map, chan->identity_digest);
  501. if (tmp) {
  502. /* Okay, it's here */
  503. head = tmp; /* Keep track of list head */
  504. /* Look for this channel */
  505. while (tmp && tmp != chan) {
  506. tmp = tmp->next_with_same_id;
  507. }
  508. if (tmp == chan) {
  509. /* Found it, good */
  510. if (chan->next_with_same_id) {
  511. chan->next_with_same_id->prev_with_same_id = chan->prev_with_same_id;
  512. }
  513. /* else we're the tail of the list */
  514. if (chan->prev_with_same_id) {
  515. /* We're not the head of the list, so we can *just* unlink */
  516. chan->prev_with_same_id->next_with_same_id = chan->next_with_same_id;
  517. } else {
  518. /* We're the head, so we have to point the digest map entry at our
  519. * next if we have one, or remove it if we're also the tail */
  520. if (chan->next_with_same_id) {
  521. digestmap_set(channel_identity_map,
  522. chan->identity_digest,
  523. chan->next_with_same_id);
  524. } else {
  525. digestmap_remove(channel_identity_map,
  526. chan->identity_digest);
  527. }
  528. }
  529. /* NULL out its next/prev pointers, and we're finished */
  530. chan->next_with_same_id = NULL;
  531. chan->prev_with_same_id = NULL;
  532. log_debug(LD_CHANNEL,
  533. "Removed channel %p (global ID " U64_FORMAT ") from "
  534. "identity map in state %s (%d) with digest %s",
  535. chan, U64_PRINTF_ARG(chan->global_identifier),
  536. channel_state_to_string(chan->state), chan->state,
  537. hex_str(chan->identity_digest, DIGEST_LEN));
  538. } else {
  539. /* This is not good */
  540. log_warn(LD_BUG,
  541. "Trying to remove channel %p (global ID " U64_FORMAT ") "
  542. "with digest %s from identity map, but couldn't find it in "
  543. "the list for that digest",
  544. chan, U64_PRINTF_ARG(chan->global_identifier),
  545. hex_str(chan->identity_digest, DIGEST_LEN));
  546. /* Unlink it and hope for the best */
  547. if (chan->next_with_same_id) {
  548. chan->next_with_same_id->prev_with_same_id = chan->prev_with_same_id;
  549. }
  550. if (chan->prev_with_same_id) {
  551. chan->prev_with_same_id->next_with_same_id = chan->next_with_same_id;
  552. }
  553. chan->next_with_same_id = NULL;
  554. chan->prev_with_same_id = NULL;
  555. }
  556. } else {
  557. /* Shouldn't happen */
  558. log_warn(LD_BUG,
  559. "Trying to remove channel %p (global ID " U64_FORMAT ") with "
  560. "digest %s from identity map, but couldn't find any with "
  561. "that digest",
  562. chan, U64_PRINTF_ARG(chan->global_identifier),
  563. hex_str(chan->identity_digest, DIGEST_LEN));
  564. /* Clear out its next/prev pointers */
  565. if (chan->next_with_same_id) {
  566. chan->next_with_same_id->prev_with_same_id = chan->prev_with_same_id;
  567. }
  568. if (chan->prev_with_same_id) {
  569. chan->prev_with_same_id->next_with_same_id = chan->next_with_same_id;
  570. }
  571. chan->next_with_same_id = NULL;
  572. chan->prev_with_same_id = NULL;
  573. }
  574. }
  575. /****************************
  576. * Channel lookup functions *
  577. ***************************/
  578. /**
  579. * Find channel by global ID
  580. *
  581. * This function searches for a channel by the global_identifier assigned
  582. * at initialization time. This identifier is unique for the lifetime of the
  583. * Tor process.
  584. */
  585. channel_t *
  586. channel_find_by_global_id(uint64_t global_identifier)
  587. {
  588. channel_t *rv = NULL;
  589. if (all_channels && smartlist_len(all_channels) > 0) {
  590. SMARTLIST_FOREACH_BEGIN(all_channels, channel_t *, curr) {
  591. if (curr->global_identifier == global_identifier) {
  592. rv = curr;
  593. break;
  594. }
  595. } SMARTLIST_FOREACH_END(curr);
  596. }
  597. return rv;
  598. }
  599. /**
  600. * Find channel by digest of the remote endpoint
  601. *
  602. * This function looks up a channel by the digest of its remote endpoint in
  603. * the channel digest map. It's possible that more than one channel to a
  604. * given endpoint exists. Use channel_next_with_digest() and
  605. * channel_prev_with_digest() to walk the list.
  606. */
  607. channel_t *
  608. channel_find_by_remote_digest(const char *identity_digest)
  609. {
  610. channel_t *rv = NULL;
  611. tor_assert(identity_digest);
  612. /* Search for it in the identity map */
  613. if (channel_identity_map) {
  614. rv = digestmap_get(channel_identity_map, identity_digest);
  615. }
  616. return rv;
  617. }
  618. /**
  619. * Get next channel with digest
  620. *
  621. * This function takes a channel and finds the next channel in the list
  622. * with the same digest.
  623. */
  624. channel_t *
  625. channel_next_with_digest(channel_t *chan)
  626. {
  627. tor_assert(chan);
  628. return chan->next_with_same_id;
  629. }
  630. /**
  631. * Get previous channel with digest
  632. *
  633. * This function takes a channel and finds the previos channel in the list
  634. * with the same digest.
  635. */
  636. channel_t *
  637. channel_prev_with_digest(channel_t *chan)
  638. {
  639. tor_assert(chan);
  640. return chan->prev_with_same_id;
  641. }
  642. /**
  643. * Initialize a channel
  644. *
  645. * This function should be called by subclasses to set up some per-channel
  646. * variables. I.e., this is the superclass constructor. Before this, the
  647. * channel should be allocated with tor_malloc_zero().
  648. */
  649. void
  650. channel_init(channel_t *chan)
  651. {
  652. tor_assert(chan);
  653. /* Assign an ID and bump the counter */
  654. chan->global_identifier = n_channels_allocated++;
  655. /* Init timestamp */
  656. chan->timestamp_last_added_nonpadding = time(NULL);
  657. /* Init next_circ_id */
  658. chan->next_circ_id = crypto_rand_int(1 << 15);
  659. /* Timestamp it */
  660. channel_timestamp_created(chan);
  661. }
  662. /**
  663. * Initialize a channel listener
  664. *
  665. * This function should be called by subclasses to set up some per-channel
  666. * variables. I.e., this is the superclass constructor. Before this, the
  667. * channel listener should be allocated with tor_malloc_zero().
  668. */
  669. void
  670. channel_init_listener(channel_listener_t *chan_l)
  671. {
  672. tor_assert(chan_l);
  673. /* Assign an ID and bump the counter */
  674. chan_l->global_identifier = n_channels_allocated++;
  675. /* Timestamp it */
  676. channel_listener_timestamp_created(chan_l);
  677. }
  678. /**
  679. * Free a channel; nothing outside of channel.c and subclasses should call
  680. * this - it frees channels after they have closed and been unregistered.
  681. */
  682. void
  683. channel_free(channel_t *chan)
  684. {
  685. if (!chan) return;
  686. /* It must be closed or errored */
  687. tor_assert(chan->state == CHANNEL_STATE_CLOSED ||
  688. chan->state == CHANNEL_STATE_ERROR);
  689. /* It must be deregistered */
  690. tor_assert(!(chan->registered));
  691. /* Call a free method if there is one */
  692. if (chan->free) chan->free(chan);
  693. channel_clear_remote_end(chan);
  694. if (chan->cmux) {
  695. circuitmux_detach_all_circuits(chan->cmux);
  696. circuitmux_free(chan->cmux);
  697. chan->cmux = NULL;
  698. }
  699. /* We're in CLOSED or ERROR, so the cell queue is already empty */
  700. tor_free(chan);
  701. }
  702. /**
  703. * Free a channel listener; nothing outside of channel.c and subclasses
  704. * should call this - it frees channel listeners after they have closed and
  705. * been unregistered.
  706. */
  707. void
  708. channel_listener_free(channel_listener_t *chan_l)
  709. {
  710. if (!chan_l) return;
  711. /* It must be closed or errored */
  712. tor_assert(chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
  713. chan_l->state == CHANNEL_LISTENER_STATE_ERROR);
  714. /* It must be deregistered */
  715. tor_assert(!(chan_l->registered));
  716. /* Call a free method if there is one */
  717. if (chan_l->free) chan_l->free(chan_l);
  718. /*
  719. * We're in CLOSED or ERROR, so the incoming channel queue is already
  720. * empty.
  721. */
  722. tor_free(chan_l);
  723. }
  724. /**
  725. * Free a channel and skip the state/registration asserts; this internal-
  726. * use-only function should be called only from channel_free_all() when
  727. * shutting down the Tor process.
  728. */
  729. static void
  730. channel_force_free(channel_t *chan)
  731. {
  732. tor_assert(chan);
  733. /* Call a free method if there is one */
  734. if (chan->free) chan->free(chan);
  735. channel_clear_remote_end(chan);
  736. /* We might still have a cell queue; kill it */
  737. if (chan->incoming_queue) {
  738. SMARTLIST_FOREACH_BEGIN(chan->incoming_queue,
  739. cell_queue_entry_t *, q) {
  740. cell_queue_entry_free(q, 0);
  741. } SMARTLIST_FOREACH_END(q);
  742. smartlist_free(chan->incoming_queue);
  743. chan->incoming_queue = NULL;
  744. }
  745. /* Outgoing cell queue is similar, but we can have to free packed cells */
  746. if (chan->outgoing_queue) {
  747. SMARTLIST_FOREACH_BEGIN(chan->outgoing_queue,
  748. cell_queue_entry_t *, q) {
  749. cell_queue_entry_free(q, 0);
  750. } SMARTLIST_FOREACH_END(q);
  751. smartlist_free(chan->outgoing_queue);
  752. chan->outgoing_queue = NULL;
  753. }
  754. tor_free(chan);
  755. }
  756. /**
  757. * Free a channel listener and skip the state/reigstration asserts; this
  758. * internal-use-only function should be called only from channel_free_all()
  759. * when shutting down the Tor process.
  760. */
  761. static void
  762. channel_listener_force_free(channel_listener_t *chan_l)
  763. {
  764. tor_assert(chan_l);
  765. /* Call a free method if there is one */
  766. if (chan_l->free) chan_l->free(chan_l);
  767. /*
  768. * The incoming list just gets emptied and freed; we request close on
  769. * any channels we find there, but since we got called while shutting
  770. * down they will get deregistered and freed elsewhere anyway.
  771. */
  772. if (chan_l->incoming_list) {
  773. SMARTLIST_FOREACH_BEGIN(chan_l->incoming_list,
  774. channel_t *, qchan) {
  775. channel_mark_for_close(qchan);
  776. } SMARTLIST_FOREACH_END(qchan);
  777. smartlist_free(chan_l->incoming_list);
  778. chan_l->incoming_list = NULL;
  779. }
  780. tor_free(chan_l);
  781. }
  782. /**
  783. * Return the current registered listener for a channel listener
  784. *
  785. * This function returns a function pointer to the current registered
  786. * handler for new incoming channels on a channel listener.
  787. */
  788. channel_listener_fn_ptr
  789. channel_listener_get_listener_fn(channel_listener_t *chan_l)
  790. {
  791. tor_assert(chan_l);
  792. if (chan_l->state == CHANNEL_LISTENER_STATE_LISTENING)
  793. return chan_l->listener;
  794. return NULL;
  795. }
  796. /**
  797. * Set the listener for a channel listener
  798. *
  799. * This function sets the handler for new incoming channels on a channel
  800. * listener.
  801. */
  802. void
  803. channel_listener_set_listener_fn(channel_listener_t *chan_l,
  804. channel_listener_fn_ptr listener)
  805. {
  806. tor_assert(chan_l);
  807. tor_assert(chan_l->state == CHANNEL_LISTENER_STATE_LISTENING);
  808. log_debug(LD_CHANNEL,
  809. "Setting listener callback for channel listener %p "
  810. "(global ID " U64_FORMAT ") to %p",
  811. chan_l, U64_PRINTF_ARG(chan_l->global_identifier),
  812. listener);
  813. chan_l->listener = listener;
  814. if (chan_l->listener) channel_listener_process_incoming(chan_l);
  815. }
  816. /**
  817. * Return the fixed-length cell handler for a channel
  818. *
  819. * This function gets the handler for incoming fixed-length cells installed
  820. * on a channel.
  821. */
  822. channel_cell_handler_fn_ptr
  823. channel_get_cell_handler(channel_t *chan)
  824. {
  825. tor_assert(chan);
  826. if (chan->state == CHANNEL_STATE_OPENING ||
  827. chan->state == CHANNEL_STATE_OPEN ||
  828. chan->state == CHANNEL_STATE_MAINT)
  829. return chan->cell_handler;
  830. return NULL;
  831. }
  832. /**
  833. * Return the variable-length cell handler for a channel
  834. *
  835. * This function gets the handler for incoming variable-length cells
  836. * installed on a channel.
  837. */
  838. channel_var_cell_handler_fn_ptr
  839. channel_get_var_cell_handler(channel_t *chan)
  840. {
  841. tor_assert(chan);
  842. if (chan->state == CHANNEL_STATE_OPENING ||
  843. chan->state == CHANNEL_STATE_OPEN ||
  844. chan->state == CHANNEL_STATE_MAINT)
  845. return chan->var_cell_handler;
  846. return NULL;
  847. }
  848. /**
  849. * Set both cell handlers for a channel
  850. *
  851. * This function sets both the fixed-length and variable length cell handlers
  852. * for a channel and processes any incoming cells that had been blocked in the
  853. * queue because none were available.
  854. */
  855. void
  856. channel_set_cell_handlers(channel_t *chan,
  857. channel_cell_handler_fn_ptr cell_handler,
  858. channel_var_cell_handler_fn_ptr
  859. var_cell_handler)
  860. {
  861. int try_again = 0;
  862. tor_assert(chan);
  863. tor_assert(chan->state == CHANNEL_STATE_OPENING ||
  864. chan->state == CHANNEL_STATE_OPEN ||
  865. chan->state == CHANNEL_STATE_MAINT);
  866. log_debug(LD_CHANNEL,
  867. "Setting cell_handler callback for channel %p to %p",
  868. chan, cell_handler);
  869. log_debug(LD_CHANNEL,
  870. "Setting var_cell_handler callback for channel %p to %p",
  871. chan, var_cell_handler);
  872. /* Should we try the queue? */
  873. if (cell_handler &&
  874. cell_handler != chan->cell_handler) try_again = 1;
  875. if (var_cell_handler &&
  876. var_cell_handler != chan->var_cell_handler) try_again = 1;
  877. /* Change them */
  878. chan->cell_handler = cell_handler;
  879. chan->var_cell_handler = var_cell_handler;
  880. /* Re-run the queue if we have one and there's any reason to */
  881. if (chan->incoming_queue &&
  882. (smartlist_len(chan->incoming_queue) > 0) &&
  883. try_again &&
  884. (chan->cell_handler ||
  885. chan->var_cell_handler)) channel_process_cells(chan);
  886. }
  887. /**
  888. * Mark a channel for closure
  889. *
  890. * This function tries to close a channel_t; it will go into the CLOSING
  891. * state, and eventually the lower layer should put it into the CLOSED or
  892. * ERROR state. Then, channel_run_cleanup() will eventually free it.
  893. */
  894. void
  895. channel_mark_for_close(channel_t *chan)
  896. {
  897. tor_assert(chan != NULL);
  898. tor_assert(chan->close != NULL);
  899. /* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
  900. if (chan->state == CHANNEL_STATE_CLOSING ||
  901. chan->state == CHANNEL_STATE_CLOSED ||
  902. chan->state == CHANNEL_STATE_ERROR) return;
  903. log_debug(LD_CHANNEL,
  904. "Closing channel %p (global ID " U64_FORMAT ") "
  905. "by request",
  906. chan, U64_PRINTF_ARG(chan->global_identifier));
  907. /* Note closing by request from above */
  908. chan->reason_for_closing = CHANNEL_CLOSE_REQUESTED;
  909. /* Change state to CLOSING */
  910. channel_change_state(chan, CHANNEL_STATE_CLOSING);
  911. /* Tell the lower layer */
  912. chan->close(chan);
  913. /*
  914. * It's up to the lower layer to change state to CLOSED or ERROR when we're
  915. * ready; we'll try to free channels that are in the finished list from
  916. * channel_run_cleanup(). The lower layer should do this by calling
  917. * channel_closed().
  918. */
  919. }
  920. /**
  921. * Mark a channel listener for closure
  922. *
  923. * This function tries to close a channel_listener_t; it will go into the
  924. * CLOSING state, and eventually the lower layer should put it into the CLOSED
  925. * or ERROR state. Then, channel_run_cleanup() will eventually free it.
  926. */
  927. void
  928. channel_listener_mark_for_close(channel_listener_t *chan_l)
  929. {
  930. tor_assert(chan_l != NULL);
  931. tor_assert(chan_l->close != NULL);
  932. /* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
  933. if (chan_l->state == CHANNEL_LISTENER_STATE_CLOSING ||
  934. chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
  935. chan_l->state == CHANNEL_LISTENER_STATE_ERROR) return;
  936. log_debug(LD_CHANNEL,
  937. "Closing channel listener %p (global ID " U64_FORMAT ") "
  938. "by request",
  939. chan_l, U64_PRINTF_ARG(chan_l->global_identifier));
  940. /* Note closing by request from above */
  941. chan_l->reason_for_closing = CHANNEL_LISTENER_CLOSE_REQUESTED;
  942. /* Change state to CLOSING */
  943. channel_listener_change_state(chan_l, CHANNEL_LISTENER_STATE_CLOSING);
  944. /* Tell the lower layer */
  945. chan_l->close(chan_l);
  946. /*
  947. * It's up to the lower layer to change state to CLOSED or ERROR when we're
  948. * ready; we'll try to free channels that are in the finished list from
  949. * channel_run_cleanup(). The lower layer should do this by calling
  950. * channel_listener_closed().
  951. */
  952. }
  953. /**
  954. * Close a channel from the lower layer
  955. *
  956. * Notify the channel code that the channel is being closed due to a non-error
  957. * condition in the lower layer. This does not call the close() method, since
  958. * the lower layer already knows.
  959. */
  960. void
  961. channel_close_from_lower_layer(channel_t *chan)
  962. {
  963. tor_assert(chan != NULL);
  964. /* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
  965. if (chan->state == CHANNEL_STATE_CLOSING ||
  966. chan->state == CHANNEL_STATE_CLOSED ||
  967. chan->state == CHANNEL_STATE_ERROR) return;
  968. log_debug(LD_CHANNEL,
  969. "Closing channel %p (global ID " U64_FORMAT ") "
  970. "due to lower-layer event",
  971. chan, U64_PRINTF_ARG(chan->global_identifier));
  972. /* Note closing by event from below */
  973. chan->reason_for_closing = CHANNEL_CLOSE_FROM_BELOW;
  974. /* Change state to CLOSING */
  975. channel_change_state(chan, CHANNEL_STATE_CLOSING);
  976. }
  977. /**
  978. * Close a channel listener from the lower layer
  979. *
  980. * Notify the channel code that the channel listener is being closed due to a
  981. * non-error condition in the lower layer. This does not call the close()
  982. * method, since the lower layer already knows.
  983. */
  984. void
  985. channel_listener_close_from_lower_layer(channel_listener_t *chan_l)
  986. {
  987. tor_assert(chan_l != NULL);
  988. /* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
  989. if (chan_l->state == CHANNEL_LISTENER_STATE_CLOSING ||
  990. chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
  991. chan_l->state == CHANNEL_LISTENER_STATE_ERROR) return;
  992. log_debug(LD_CHANNEL,
  993. "Closing channel listener %p (global ID " U64_FORMAT ") "
  994. "due to lower-layer event",
  995. chan_l, U64_PRINTF_ARG(chan_l->global_identifier));
  996. /* Note closing by event from below */
  997. chan_l->reason_for_closing = CHANNEL_LISTENER_CLOSE_FROM_BELOW;
  998. /* Change state to CLOSING */
  999. channel_listener_change_state(chan_l, CHANNEL_LISTENER_STATE_CLOSING);
  1000. }
  1001. /**
  1002. * Notify that the channel is being closed due to an error condition
  1003. *
  1004. * This function is called by the lower layer implementing the transport
  1005. * when a channel must be closed due to an error condition. This does not
  1006. * call the channel's close method, since the lower layer already knows.
  1007. */
  1008. void
  1009. channel_close_for_error(channel_t *chan)
  1010. {
  1011. tor_assert(chan != NULL);
  1012. /* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
  1013. if (chan->state == CHANNEL_STATE_CLOSING ||
  1014. chan->state == CHANNEL_STATE_CLOSED ||
  1015. chan->state == CHANNEL_STATE_ERROR) return;
  1016. log_debug(LD_CHANNEL,
  1017. "Closing channel %p due to lower-layer error",
  1018. chan);
  1019. /* Note closing by event from below */
  1020. chan->reason_for_closing = CHANNEL_CLOSE_FOR_ERROR;
  1021. /* Change state to CLOSING */
  1022. channel_change_state(chan, CHANNEL_STATE_CLOSING);
  1023. }
  1024. /**
  1025. * Notify that the channel listener is being closed due to an error condition
  1026. *
  1027. * This function is called by the lower layer implementing the transport
  1028. * when a channel listener must be closed due to an error condition. This
  1029. * does not call the channel listener's close method, since the lower layer
  1030. * already knows.
  1031. */
  1032. void
  1033. channel_listener_close_for_error(channel_listener_t *chan_l)
  1034. {
  1035. tor_assert(chan_l != NULL);
  1036. /* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
  1037. if (chan_l->state == CHANNEL_LISTENER_STATE_CLOSING ||
  1038. chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
  1039. chan_l->state == CHANNEL_LISTENER_STATE_ERROR) return;
  1040. log_debug(LD_CHANNEL,
  1041. "Closing channel listener %p (global ID " U64_FORMAT ") "
  1042. "due to lower-layer error",
  1043. chan_l, U64_PRINTF_ARG(chan_l->global_identifier));
  1044. /* Note closing by event from below */
  1045. chan_l->reason_for_closing = CHANNEL_LISTENER_CLOSE_FOR_ERROR;
  1046. /* Change state to CLOSING */
  1047. channel_listener_change_state(chan_l, CHANNEL_LISTENER_STATE_CLOSING);
  1048. }
  1049. /**
  1050. * Notify that the lower layer is finished closing the channel
  1051. *
  1052. * This function should be called by the lower layer when a channel
  1053. * is finished closing and it should be regarded as inactive and
  1054. * freed by the channel code.
  1055. */
  1056. void
  1057. channel_closed(channel_t *chan)
  1058. {
  1059. tor_assert(chan);
  1060. tor_assert(chan->state == CHANNEL_STATE_CLOSING ||
  1061. chan->state == CHANNEL_STATE_CLOSED ||
  1062. chan->state == CHANNEL_STATE_ERROR);
  1063. /* No-op if already inactive */
  1064. if (chan->state == CHANNEL_STATE_CLOSED ||
  1065. chan->state == CHANNEL_STATE_ERROR) return;
  1066. if (chan->reason_for_closing == CHANNEL_CLOSE_FOR_ERROR) {
  1067. /* Inform any pending (not attached) circs that they should
  1068. * give up. */
  1069. circuit_n_chan_done(chan, 0);
  1070. }
  1071. /* Now close all the attached circuits on it. */
  1072. circuit_unlink_all_from_channel(chan, END_CIRC_REASON_CHANNEL_CLOSED);
  1073. if (chan->reason_for_closing != CHANNEL_CLOSE_FOR_ERROR) {
  1074. channel_change_state(chan, CHANNEL_STATE_CLOSED);
  1075. } else {
  1076. channel_change_state(chan, CHANNEL_STATE_ERROR);
  1077. }
  1078. }
  1079. /**
  1080. * Notify that the lower layer is finished closing the channel listener
  1081. *
  1082. * This function should be called by the lower layer when a channel listener
  1083. * is finished closing and it should be regarded as inactive and
  1084. * freed by the channel code.
  1085. */
  1086. void
  1087. channel_listener_closed(channel_listener_t *chan_l)
  1088. {
  1089. tor_assert(chan_l);
  1090. tor_assert(chan_l->state == CHANNEL_LISTENER_STATE_CLOSING ||
  1091. chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
  1092. chan_l->state == CHANNEL_LISTENER_STATE_ERROR);
  1093. /* No-op if already inactive */
  1094. if (chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
  1095. chan_l->state == CHANNEL_LISTENER_STATE_ERROR) return;
  1096. if (chan_l->reason_for_closing != CHANNEL_LISTENER_CLOSE_FOR_ERROR) {
  1097. channel_listener_change_state(chan_l, CHANNEL_LISTENER_STATE_CLOSED);
  1098. } else {
  1099. channel_listener_change_state(chan_l, CHANNEL_LISTENER_STATE_ERROR);
  1100. }
  1101. }
  1102. /**
  1103. * Clear the identity_digest of a channel
  1104. *
  1105. * This function clears the identity digest of the remote endpoint for a
  1106. * channel; this is intended for use by the lower layer.
  1107. */
  1108. void
  1109. channel_clear_identity_digest(channel_t *chan)
  1110. {
  1111. int state_not_in_map;
  1112. tor_assert(chan);
  1113. log_debug(LD_CHANNEL,
  1114. "Clearing remote endpoint digest on channel %p with "
  1115. "global ID " U64_FORMAT,
  1116. chan, U64_PRINTF_ARG(chan->global_identifier));
  1117. state_not_in_map =
  1118. (chan->state == CHANNEL_STATE_CLOSING ||
  1119. chan->state == CHANNEL_STATE_CLOSED ||
  1120. chan->state == CHANNEL_STATE_ERROR);
  1121. if (!state_not_in_map && chan->registered &&
  1122. !tor_digest_is_zero(chan->identity_digest))
  1123. /* if it's registered get it out of the digest map */
  1124. channel_remove_from_digest_map(chan);
  1125. memset(chan->identity_digest, 0,
  1126. sizeof(chan->identity_digest));
  1127. }
  1128. /**
  1129. * Set the identity_digest of a channel
  1130. *
  1131. * This function sets the identity digest of the remote endpoint for a
  1132. * channel; this is intended for use by the lower layer.
  1133. */
  1134. void
  1135. channel_set_identity_digest(channel_t *chan,
  1136. const char *identity_digest)
  1137. {
  1138. int was_in_digest_map, should_be_in_digest_map, state_not_in_map;
  1139. tor_assert(chan);
  1140. log_debug(LD_CHANNEL,
  1141. "Setting remote endpoint digest on channel %p with "
  1142. "global ID " U64_FORMAT " to digest %s",
  1143. chan, U64_PRINTF_ARG(chan->global_identifier),
  1144. identity_digest ?
  1145. hex_str(identity_digest, DIGEST_LEN) : "(null)");
  1146. state_not_in_map =
  1147. (chan->state == CHANNEL_STATE_CLOSING ||
  1148. chan->state == CHANNEL_STATE_CLOSED ||
  1149. chan->state == CHANNEL_STATE_ERROR);
  1150. was_in_digest_map =
  1151. !state_not_in_map &&
  1152. chan->registered &&
  1153. !tor_digest_is_zero(chan->identity_digest);
  1154. should_be_in_digest_map =
  1155. !state_not_in_map &&
  1156. chan->registered &&
  1157. (identity_digest &&
  1158. !tor_digest_is_zero(identity_digest));
  1159. if (was_in_digest_map)
  1160. /* We should always remove it; we'll add it back if we're writing
  1161. * in a new digest.
  1162. */
  1163. channel_remove_from_digest_map(chan);
  1164. if (identity_digest) {
  1165. memcpy(chan->identity_digest,
  1166. identity_digest,
  1167. sizeof(chan->identity_digest));
  1168. } else {
  1169. memset(chan->identity_digest, 0,
  1170. sizeof(chan->identity_digest));
  1171. }
  1172. /* Put it in the digest map if we should */
  1173. if (should_be_in_digest_map)
  1174. channel_add_to_digest_map(chan);
  1175. }
  1176. /**
  1177. * Clear the remote end metadata (identity_digest/nickname) of a channel
  1178. *
  1179. * This function clears all the remote end info from a channel; this is
  1180. * intended for use by the lower layer.
  1181. */
  1182. void
  1183. channel_clear_remote_end(channel_t *chan)
  1184. {
  1185. int state_not_in_map;
  1186. tor_assert(chan);
  1187. log_debug(LD_CHANNEL,
  1188. "Clearing remote endpoint identity on channel %p with "
  1189. "global ID " U64_FORMAT,
  1190. chan, U64_PRINTF_ARG(chan->global_identifier));
  1191. state_not_in_map =
  1192. (chan->state == CHANNEL_STATE_CLOSING ||
  1193. chan->state == CHANNEL_STATE_CLOSED ||
  1194. chan->state == CHANNEL_STATE_ERROR);
  1195. if (!state_not_in_map && chan->registered &&
  1196. !tor_digest_is_zero(chan->identity_digest))
  1197. /* if it's registered get it out of the digest map */
  1198. channel_remove_from_digest_map(chan);
  1199. memset(chan->identity_digest, 0,
  1200. sizeof(chan->identity_digest));
  1201. tor_free(chan->nickname);
  1202. }
  1203. /**
  1204. * Set the remote end metadata (identity_digest/nickname) of a channel
  1205. *
  1206. * This function sets new remote end info on a channel; this is intended
  1207. * for use by the lower layer.
  1208. */
  1209. void
  1210. channel_set_remote_end(channel_t *chan,
  1211. const char *identity_digest,
  1212. const char *nickname)
  1213. {
  1214. int was_in_digest_map, should_be_in_digest_map, state_not_in_map;
  1215. tor_assert(chan);
  1216. log_debug(LD_CHANNEL,
  1217. "Setting remote endpoint identity on channel %p with "
  1218. "global ID " U64_FORMAT " to nickname %s, digest %s",
  1219. chan, U64_PRINTF_ARG(chan->global_identifier),
  1220. nickname ? nickname : "(null)",
  1221. identity_digest ?
  1222. hex_str(identity_digest, DIGEST_LEN) : "(null)");
  1223. state_not_in_map =
  1224. (chan->state == CHANNEL_STATE_CLOSING ||
  1225. chan->state == CHANNEL_STATE_CLOSED ||
  1226. chan->state == CHANNEL_STATE_ERROR);
  1227. was_in_digest_map =
  1228. !state_not_in_map &&
  1229. chan->registered &&
  1230. !tor_digest_is_zero(chan->identity_digest);
  1231. should_be_in_digest_map =
  1232. !state_not_in_map &&
  1233. chan->registered &&
  1234. (identity_digest &&
  1235. !tor_digest_is_zero(identity_digest));
  1236. if (was_in_digest_map)
  1237. /* We should always remove it; we'll add it back if we're writing
  1238. * in a new digest.
  1239. */
  1240. channel_remove_from_digest_map(chan);
  1241. if (identity_digest) {
  1242. memcpy(chan->identity_digest,
  1243. identity_digest,
  1244. sizeof(chan->identity_digest));
  1245. } else {
  1246. memset(chan->identity_digest, 0,
  1247. sizeof(chan->identity_digest));
  1248. }
  1249. tor_free(chan->nickname);
  1250. if (nickname)
  1251. chan->nickname = tor_strdup(nickname);
  1252. /* Put it in the digest map if we should */
  1253. if (should_be_in_digest_map)
  1254. channel_add_to_digest_map(chan);
  1255. }
  1256. /**
  1257. * Duplicate a cell queue entry; this is a shallow copy intended for use
  1258. * in channel_write_cell_queue_entry().
  1259. */
  1260. static cell_queue_entry_t *
  1261. cell_queue_entry_dup(cell_queue_entry_t *q)
  1262. {
  1263. cell_queue_entry_t *rv = NULL;
  1264. tor_assert(q);
  1265. rv = tor_malloc(sizeof(*rv));
  1266. memcpy(rv, q, sizeof(*rv));
  1267. return rv;
  1268. }
  1269. /**
  1270. * Free a cell_queue_entry_t; the handed_off parameter indicates whether
  1271. * the contents were passed to the lower layer (it is responsible for
  1272. * them) or not (we should free).
  1273. */
  1274. static void
  1275. cell_queue_entry_free(cell_queue_entry_t *q, int handed_off) {
  1276. if (!q) return;
  1277. if (!handed_off) {
  1278. /*
  1279. * If we handed it off, the recipient becomes responsible (or
  1280. * with packed cells the channel_t subclass calls packed_cell
  1281. * free after writing out its contents; see, e.g.,
  1282. * channel_tls_write_packed_cell_method(). Otherwise, we have
  1283. * to take care of it here if possible.
  1284. */
  1285. switch (q->type) {
  1286. case CELL_QUEUE_FIXED:
  1287. if (q->u.fixed.cell) {
  1288. /*
  1289. * There doesn't seem to be a cell_free() function anywhere in the
  1290. * pre-channel code; just use tor_free()
  1291. */
  1292. tor_free(q->u.fixed.cell);
  1293. }
  1294. break;
  1295. case CELL_QUEUE_PACKED:
  1296. if (q->u.packed.packed_cell) {
  1297. packed_cell_free(q->u.packed.packed_cell);
  1298. }
  1299. break;
  1300. case CELL_QUEUE_VAR:
  1301. if (q->u.var.var_cell) {
  1302. /*
  1303. * This one's in connection_or.c; it'd be nice to figure out the
  1304. * whole flow of cells from one end to the other and factor the
  1305. * cell memory management functions like this out of the specific
  1306. * TLS lower layer.
  1307. */
  1308. var_cell_free(q->u.var.var_cell);
  1309. }
  1310. break;
  1311. default:
  1312. /*
  1313. * Nothing we can do if we don't know the type; this will
  1314. * have been warned about elsewhere.
  1315. */
  1316. break;
  1317. }
  1318. }
  1319. tor_free(q);
  1320. }
  1321. /**
  1322. * Check whether a cell queue entry is padding; this is a helper function
  1323. * for channel_write_cell_queue_entry()
  1324. */
  1325. static int
  1326. cell_queue_entry_is_padding(cell_queue_entry_t *q)
  1327. {
  1328. tor_assert(q);
  1329. if (q->type == CELL_QUEUE_FIXED) {
  1330. if (q->u.fixed.cell) {
  1331. if (q->u.fixed.cell->command == CELL_PADDING ||
  1332. q->u.fixed.cell->command == CELL_VPADDING) {
  1333. return 1;
  1334. }
  1335. }
  1336. } else if (q->type == CELL_QUEUE_VAR) {
  1337. if (q->u.var.var_cell) {
  1338. if (q->u.var.var_cell->command == CELL_PADDING ||
  1339. q->u.var.var_cell->command == CELL_VPADDING) {
  1340. return 1;
  1341. }
  1342. }
  1343. }
  1344. return 0;
  1345. }
  1346. /**
  1347. * Allocate a new cell queue entry for a fixed-size cell
  1348. */
  1349. static cell_queue_entry_t *
  1350. cell_queue_entry_new_fixed(cell_t *cell)
  1351. {
  1352. cell_queue_entry_t *q = NULL;
  1353. tor_assert(cell);
  1354. q = tor_malloc(sizeof(*q));
  1355. q->type = CELL_QUEUE_FIXED;
  1356. q->u.fixed.cell = cell;
  1357. return q;
  1358. }
  1359. /**
  1360. * Allocate a new cell queue entry for a variable-size cell
  1361. */
  1362. static cell_queue_entry_t *
  1363. cell_queue_entry_new_var(var_cell_t *var_cell)
  1364. {
  1365. cell_queue_entry_t *q = NULL;
  1366. tor_assert(var_cell);
  1367. q = tor_malloc(sizeof(*q));
  1368. q->type = CELL_QUEUE_VAR;
  1369. q->u.var.var_cell = var_cell;
  1370. return q;
  1371. }
  1372. /**
  1373. * Write to a channel based on a cell_queue_entry_t
  1374. *
  1375. * Given a cell_queue_entry_t filled out by the caller, try to send the cell
  1376. * and queue it if we can't.
  1377. */
  1378. static void
  1379. channel_write_cell_queue_entry(channel_t *chan, cell_queue_entry_t *q)
  1380. {
  1381. int result = 0, sent = 0;
  1382. cell_queue_entry_t *tmp = NULL;
  1383. tor_assert(chan);
  1384. tor_assert(q);
  1385. /* Assert that the state makes sense for a cell write */
  1386. tor_assert(chan->state == CHANNEL_STATE_OPENING ||
  1387. chan->state == CHANNEL_STATE_OPEN ||
  1388. chan->state == CHANNEL_STATE_MAINT);
  1389. /* Increment the timestamp unless it's padding */
  1390. if (!cell_queue_entry_is_padding(q)) {
  1391. chan->timestamp_last_added_nonpadding = approx_time();
  1392. }
  1393. /* Can we send it right out? If so, try */
  1394. if (!(chan->outgoing_queue &&
  1395. (smartlist_len(chan->outgoing_queue) > 0)) &&
  1396. chan->state == CHANNEL_STATE_OPEN) {
  1397. /* Pick the right write function for this cell type and save the result */
  1398. switch (q->type) {
  1399. case CELL_QUEUE_FIXED:
  1400. tor_assert(chan->write_cell);
  1401. tor_assert(q->u.fixed.cell);
  1402. result = chan->write_cell(chan, q->u.fixed.cell);
  1403. break;
  1404. case CELL_QUEUE_PACKED:
  1405. tor_assert(chan->write_packed_cell);
  1406. tor_assert(q->u.packed.packed_cell);
  1407. result = chan->write_packed_cell(chan, q->u.packed.packed_cell);
  1408. break;
  1409. case CELL_QUEUE_VAR:
  1410. tor_assert(chan->write_var_cell);
  1411. tor_assert(q->u.var.var_cell);
  1412. result = chan->write_var_cell(chan, q->u.var.var_cell);
  1413. break;
  1414. default:
  1415. tor_assert(1);
  1416. }
  1417. /* Check if we got it out */
  1418. if (result > 0) {
  1419. sent = 1;
  1420. /* Timestamp for transmission */
  1421. channel_timestamp_xmit(chan);
  1422. /* If we're here the queue is empty, so it's drained too */
  1423. channel_timestamp_drained(chan);
  1424. /* Update the counter */
  1425. ++(chan->n_cells_xmitted);
  1426. }
  1427. }
  1428. if (!sent) {
  1429. /* Not sent, queue it */
  1430. if (!(chan->outgoing_queue))
  1431. chan->outgoing_queue = smartlist_new();
  1432. /*
  1433. * We have to copy the queue entry passed in, since the caller probably
  1434. * used the stack.
  1435. */
  1436. tmp = cell_queue_entry_dup(q);
  1437. smartlist_add(chan->outgoing_queue, tmp);
  1438. /* Try to process the queue? */
  1439. if (chan->state == CHANNEL_STATE_OPEN) channel_flush_cells(chan);
  1440. }
  1441. }
  1442. /**
  1443. * Write a cell to a channel
  1444. *
  1445. * Write a fixed-length cell to a channel using the write_cell() method.
  1446. * This is equivalent to the pre-channels connection_or_write_cell_to_buf();
  1447. * it is called by the transport-independent code to deliver a cell to a
  1448. * channel for transmission.
  1449. */
  1450. void
  1451. channel_write_cell(channel_t *chan, cell_t *cell)
  1452. {
  1453. cell_queue_entry_t q;
  1454. tor_assert(chan);
  1455. tor_assert(cell);
  1456. log_debug(LD_CHANNEL,
  1457. "Writing cell_t %p to channel %p with global ID "
  1458. U64_FORMAT,
  1459. cell, chan, U64_PRINTF_ARG(chan->global_identifier));
  1460. q.type = CELL_QUEUE_FIXED;
  1461. q.u.fixed.cell = cell;
  1462. channel_write_cell_queue_entry(chan, &q);
  1463. }
  1464. /**
  1465. * Write a packed cell to a channel
  1466. *
  1467. * Write a packed cell to a channel using the write_cell() method. This is
  1468. * called by the transport-independent code to deliver a packed cell to a
  1469. * channel for transmission.
  1470. */
  1471. void
  1472. channel_write_packed_cell(channel_t *chan, packed_cell_t *packed_cell)
  1473. {
  1474. cell_queue_entry_t q;
  1475. tor_assert(chan);
  1476. tor_assert(packed_cell);
  1477. log_debug(LD_CHANNEL,
  1478. "Writing packed_cell_t %p to channel %p with global ID "
  1479. U64_FORMAT,
  1480. packed_cell, chan,
  1481. U64_PRINTF_ARG(chan->global_identifier));
  1482. q.type = CELL_QUEUE_PACKED;
  1483. q.u.packed.packed_cell = packed_cell;
  1484. channel_write_cell_queue_entry(chan, &q);
  1485. }
  1486. /**
  1487. * Write a variable-length cell to a channel
  1488. *
  1489. * Write a variable-length cell to a channel using the write_cell() method.
  1490. * This is equivalent to the pre-channels
  1491. * connection_or_write_var_cell_to_buf(); it's called by the transport-
  1492. * independent code to deliver a var_cell to a channel for transmission.
  1493. */
  1494. void
  1495. channel_write_var_cell(channel_t *chan, var_cell_t *var_cell)
  1496. {
  1497. cell_queue_entry_t q;
  1498. tor_assert(chan);
  1499. tor_assert(var_cell);
  1500. log_debug(LD_CHANNEL,
  1501. "Writing var_cell_t %p to channel %p with global ID "
  1502. U64_FORMAT,
  1503. var_cell, chan,
  1504. U64_PRINTF_ARG(chan->global_identifier));
  1505. q.type = CELL_QUEUE_VAR;
  1506. q.u.var.var_cell = var_cell;
  1507. channel_write_cell_queue_entry(chan, &q);
  1508. }
  1509. /**
  1510. * Change channel state
  1511. *
  1512. * This internal and subclass use only function is used to change channel
  1513. * state, performing all transition validity checks and whatever actions
  1514. * are appropriate to the state transition in question.
  1515. */
  1516. void
  1517. channel_change_state(channel_t *chan, channel_state_t to_state)
  1518. {
  1519. channel_state_t from_state;
  1520. unsigned char was_active, is_active;
  1521. unsigned char was_in_id_map, is_in_id_map;
  1522. tor_assert(chan);
  1523. from_state = chan->state;
  1524. tor_assert(channel_state_is_valid(from_state));
  1525. tor_assert(channel_state_is_valid(to_state));
  1526. tor_assert(channel_state_can_transition(chan->state, to_state));
  1527. /* Check for no-op transitions */
  1528. if (from_state == to_state) {
  1529. log_debug(LD_CHANNEL,
  1530. "Got no-op transition from \"%s\" to itself on channel %p"
  1531. "(global ID " U64_FORMAT ")",
  1532. channel_state_to_string(to_state),
  1533. chan, U64_PRINTF_ARG(chan->global_identifier));
  1534. return;
  1535. }
  1536. /* If we're going to a closing or closed state, we must have a reason set */
  1537. if (to_state == CHANNEL_STATE_CLOSING ||
  1538. to_state == CHANNEL_STATE_CLOSED ||
  1539. to_state == CHANNEL_STATE_ERROR) {
  1540. tor_assert(chan->reason_for_closing != CHANNEL_NOT_CLOSING);
  1541. }
  1542. /*
  1543. * We need to maintain the queues here for some transitions:
  1544. * when we enter CHANNEL_STATE_OPEN (especially from CHANNEL_STATE_MAINT)
  1545. * we may have a backlog of cells to transmit, so drain the queues in
  1546. * that case, and when going to CHANNEL_STATE_CLOSED the subclass
  1547. * should have made sure to finish sending things (or gone to
  1548. * CHANNEL_STATE_ERROR if not possible), so we assert for that here.
  1549. */
  1550. log_debug(LD_CHANNEL,
  1551. "Changing state of channel %p (global ID " U64_FORMAT
  1552. ") from \"%s\" to \"%s\"",
  1553. chan,
  1554. U64_PRINTF_ARG(chan->global_identifier),
  1555. channel_state_to_string(chan->state),
  1556. channel_state_to_string(to_state));
  1557. chan->state = to_state;
  1558. /* Need to add to the right lists if the channel is registered */
  1559. if (chan->registered) {
  1560. was_active = !(from_state == CHANNEL_STATE_CLOSED ||
  1561. from_state == CHANNEL_STATE_ERROR);
  1562. is_active = !(to_state == CHANNEL_STATE_CLOSED ||
  1563. to_state == CHANNEL_STATE_ERROR);
  1564. /* Need to take off active list and put on finished list? */
  1565. if (was_active && !is_active) {
  1566. if (active_channels) smartlist_remove(active_channels, chan);
  1567. if (!finished_channels) finished_channels = smartlist_new();
  1568. smartlist_add(finished_channels, chan);
  1569. }
  1570. /* Need to put on active list? */
  1571. else if (!was_active && is_active) {
  1572. if (finished_channels) smartlist_remove(finished_channels, chan);
  1573. if (!active_channels) active_channels = smartlist_new();
  1574. smartlist_add(active_channels, chan);
  1575. }
  1576. if (!tor_digest_is_zero(chan->identity_digest)) {
  1577. /* Now we need to handle the identity map */
  1578. was_in_id_map = !(from_state == CHANNEL_STATE_CLOSING ||
  1579. from_state == CHANNEL_STATE_CLOSED ||
  1580. from_state == CHANNEL_STATE_ERROR);
  1581. is_in_id_map = !(to_state == CHANNEL_STATE_CLOSING ||
  1582. to_state == CHANNEL_STATE_CLOSED ||
  1583. to_state == CHANNEL_STATE_ERROR);
  1584. if (!was_in_id_map && is_in_id_map) channel_add_to_digest_map(chan);
  1585. else if (was_in_id_map && !is_in_id_map)
  1586. channel_remove_from_digest_map(chan);
  1587. }
  1588. }
  1589. /* Tell circuits if we opened and stuff */
  1590. if (to_state == CHANNEL_STATE_OPEN) {
  1591. channel_do_open_actions(chan);
  1592. /* Check for queued cells to process */
  1593. if (chan->incoming_queue &&
  1594. smartlist_len(chan->incoming_queue) > 0)
  1595. channel_process_cells(chan);
  1596. if (chan->outgoing_queue &&
  1597. smartlist_len(chan->outgoing_queue) > 0)
  1598. channel_flush_cells(chan);
  1599. } else if (to_state == CHANNEL_STATE_CLOSED ||
  1600. to_state == CHANNEL_STATE_ERROR) {
  1601. /* Assert that all queues are empty */
  1602. tor_assert(!(chan->incoming_queue) ||
  1603. smartlist_len(chan->incoming_queue) == 0);
  1604. tor_assert(!(chan->outgoing_queue) ||
  1605. smartlist_len(chan->outgoing_queue) == 0);
  1606. }
  1607. }
  1608. /**
  1609. * Change channel listener state
  1610. *
  1611. * This internal and subclass use only function is used to change channel
  1612. * listener state, performing all transition validity checks and whatever
  1613. * actions are appropriate to the state transition in question.
  1614. */
  1615. void
  1616. channel_listener_change_state(channel_listener_t *chan_l,
  1617. channel_listener_state_t to_state)
  1618. {
  1619. channel_listener_state_t from_state;
  1620. unsigned char was_active, is_active;
  1621. tor_assert(chan_l);
  1622. from_state = chan_l->state;
  1623. tor_assert(channel_listener_state_is_valid(from_state));
  1624. tor_assert(channel_listener_state_is_valid(to_state));
  1625. tor_assert(channel_listener_state_can_transition(chan_l->state, to_state));
  1626. /* Check for no-op transitions */
  1627. if (from_state == to_state) {
  1628. log_debug(LD_CHANNEL,
  1629. "Got no-op transition from \"%s\" to itself on channel "
  1630. "listener %p (global ID " U64_FORMAT ")",
  1631. channel_listener_state_to_string(to_state),
  1632. chan_l, U64_PRINTF_ARG(chan_l->global_identifier));
  1633. return;
  1634. }
  1635. /* If we're going to a closing or closed state, we must have a reason set */
  1636. if (to_state == CHANNEL_LISTENER_STATE_CLOSING ||
  1637. to_state == CHANNEL_LISTENER_STATE_CLOSED ||
  1638. to_state == CHANNEL_LISTENER_STATE_ERROR) {
  1639. tor_assert(chan_l->reason_for_closing != CHANNEL_LISTENER_NOT_CLOSING);
  1640. }
  1641. /*
  1642. * We need to maintain the queues here for some transitions:
  1643. * when we enter CHANNEL_STATE_OPEN (especially from CHANNEL_STATE_MAINT)
  1644. * we may have a backlog of cells to transmit, so drain the queues in
  1645. * that case, and when going to CHANNEL_STATE_CLOSED the subclass
  1646. * should have made sure to finish sending things (or gone to
  1647. * CHANNEL_STATE_ERROR if not possible), so we assert for that here.
  1648. */
  1649. log_debug(LD_CHANNEL,
  1650. "Changing state of channel listener %p (global ID " U64_FORMAT
  1651. "from \"%s\" to \"%s\"",
  1652. chan_l, U64_PRINTF_ARG(chan_l->global_identifier),
  1653. channel_listener_state_to_string(chan_l->state),
  1654. channel_listener_state_to_string(to_state));
  1655. chan_l->state = to_state;
  1656. /* Need to add to the right lists if the channel listener is registered */
  1657. if (chan_l->registered) {
  1658. was_active = !(from_state == CHANNEL_LISTENER_STATE_CLOSED ||
  1659. from_state == CHANNEL_LISTENER_STATE_ERROR);
  1660. is_active = !(to_state == CHANNEL_LISTENER_STATE_CLOSED ||
  1661. to_state == CHANNEL_LISTENER_STATE_ERROR);
  1662. /* Need to take off active list and put on finished list? */
  1663. if (was_active && !is_active) {
  1664. if (active_listeners) smartlist_remove(active_listeners, chan_l);
  1665. if (!finished_listeners) finished_listeners = smartlist_new();
  1666. smartlist_add(finished_listeners, chan_l);
  1667. }
  1668. /* Need to put on active list? */
  1669. else if (!was_active && is_active) {
  1670. if (finished_listeners) smartlist_remove(finished_listeners, chan_l);
  1671. if (!active_listeners) active_listeners = smartlist_new();
  1672. smartlist_add(active_listeners, chan_l);
  1673. }
  1674. }
  1675. if (to_state == CHANNEL_LISTENER_STATE_CLOSED ||
  1676. to_state == CHANNEL_LISTENER_STATE_ERROR) {
  1677. /* Assert that the queue is empty */
  1678. tor_assert(!(chan_l->incoming_list) ||
  1679. smartlist_len(chan_l->incoming_list) == 0);
  1680. }
  1681. }
  1682. /**
  1683. * Try to flush cells to the lower layer
  1684. *
  1685. * this is called by the lower layer to indicate that it wants more cells;
  1686. * it will try to write up to num_cells cells from the channel's cell queue or
  1687. * from circuits active on that channel, or as many as it has available if
  1688. * num_cells == -1.
  1689. */
  1690. #define MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED 256
  1691. ssize_t
  1692. channel_flush_some_cells(channel_t *chan, ssize_t num_cells)
  1693. {
  1694. unsigned int unlimited = 0;
  1695. ssize_t flushed = 0;
  1696. int num_cells_from_circs;
  1697. tor_assert(chan);
  1698. if (num_cells < 0) unlimited = 1;
  1699. if (!unlimited && num_cells <= flushed) goto done;
  1700. /* If we aren't in CHANNEL_STATE_OPEN, nothing goes through */
  1701. if (chan->state == CHANNEL_STATE_OPEN) {
  1702. /* Try to flush as much as we can that's already queued */
  1703. flushed += channel_flush_some_cells_from_outgoing_queue(chan,
  1704. (unlimited ? -1 : num_cells - flushed));
  1705. if (!unlimited && num_cells <= flushed) goto done;
  1706. if (circuitmux_num_cells(chan->cmux) > 0) {
  1707. /* Try to get more cells from any active circuits */
  1708. num_cells_from_circs = channel_flush_from_first_active_circuit(
  1709. chan,
  1710. (unlimited ?
  1711. MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED :
  1712. (num_cells - flushed)));
  1713. /* If it claims we got some, process the queue again */
  1714. if (num_cells_from_circs > 0) {
  1715. flushed += channel_flush_some_cells_from_outgoing_queue(chan,
  1716. (unlimited ? -1 : num_cells - flushed));
  1717. }
  1718. }
  1719. }
  1720. done:
  1721. return flushed;
  1722. }
  1723. /**
  1724. * Flush cells from just the channel's outgoing cell queue
  1725. *
  1726. * This gets called from channel_flush_some_cells() above to flush cells
  1727. * just from the queue without trying for active_circuits.
  1728. */
  1729. static ssize_t
  1730. channel_flush_some_cells_from_outgoing_queue(channel_t *chan,
  1731. ssize_t num_cells)
  1732. {
  1733. unsigned int unlimited = 0;
  1734. ssize_t flushed = 0;
  1735. cell_queue_entry_t *q = NULL;
  1736. tor_assert(chan);
  1737. tor_assert(chan->write_cell);
  1738. tor_assert(chan->write_packed_cell);
  1739. tor_assert(chan->write_var_cell);
  1740. if (num_cells < 0) unlimited = 1;
  1741. if (!unlimited && num_cells <= flushed) return 0;
  1742. /* If we aren't in CHANNEL_STATE_OPEN, nothing goes through */
  1743. if (chan->state == CHANNEL_STATE_OPEN) {
  1744. while ((unlimited || num_cells > flushed) &&
  1745. (chan->outgoing_queue &&
  1746. (smartlist_len(chan->outgoing_queue) > 0))) {
  1747. /*
  1748. * Ewww, smartlist_del_keeporder() is O(n) in list length; maybe a
  1749. * a linked list would make more sense for the queue.
  1750. */
  1751. /* Get the head of the queue */
  1752. q = smartlist_get(chan->outgoing_queue, 0);
  1753. if (q) {
  1754. /*
  1755. * Okay, we have a good queue entry, try to give it to the lower
  1756. * layer.
  1757. */
  1758. switch (q->type) {
  1759. case CELL_QUEUE_FIXED:
  1760. if (q->u.fixed.cell) {
  1761. if (chan->write_cell(chan,
  1762. q->u.fixed.cell)) {
  1763. ++flushed;
  1764. channel_timestamp_xmit(chan);
  1765. ++(chan->n_cells_xmitted);
  1766. cell_queue_entry_free(q, 1);
  1767. q = NULL;
  1768. }
  1769. /* Else couldn't write it; leave it on the queue */
  1770. } else {
  1771. /* This shouldn't happen */
  1772. log_info(LD_CHANNEL,
  1773. "Saw broken cell queue entry of type CELL_QUEUE_FIXED "
  1774. "with no cell on channel %p "
  1775. "(global ID " U64_FORMAT ").",
  1776. chan, U64_PRINTF_ARG(chan->global_identifier));
  1777. /* Throw it away */
  1778. cell_queue_entry_free(q, 0);
  1779. q = NULL;
  1780. }
  1781. break;
  1782. case CELL_QUEUE_PACKED:
  1783. if (q->u.packed.packed_cell) {
  1784. if (chan->write_packed_cell(chan,
  1785. q->u.packed.packed_cell)) {
  1786. ++flushed;
  1787. channel_timestamp_xmit(chan);
  1788. ++(chan->n_cells_xmitted);
  1789. cell_queue_entry_free(q, 1);
  1790. q = NULL;
  1791. }
  1792. /* Else couldn't write it; leave it on the queue */
  1793. } else {
  1794. /* This shouldn't happen */
  1795. log_info(LD_CHANNEL,
  1796. "Saw broken cell queue entry of type CELL_QUEUE_PACKED "
  1797. "with no cell on channel %p "
  1798. "(global ID " U64_FORMAT ").",
  1799. chan, U64_PRINTF_ARG(chan->global_identifier));
  1800. /* Throw it away */
  1801. cell_queue_entry_free(q, 0);
  1802. q = NULL;
  1803. }
  1804. break;
  1805. case CELL_QUEUE_VAR:
  1806. if (q->u.var.var_cell) {
  1807. if (chan->write_var_cell(chan,
  1808. q->u.var.var_cell)) {
  1809. ++flushed;
  1810. channel_timestamp_xmit(chan);
  1811. ++(chan->n_cells_xmitted);
  1812. cell_queue_entry_free(q, 1);
  1813. q = NULL;
  1814. }
  1815. /* Else couldn't write it; leave it on the queue */
  1816. } else {
  1817. /* This shouldn't happen */
  1818. log_info(LD_CHANNEL,
  1819. "Saw broken cell queue entry of type CELL_QUEUE_VAR "
  1820. "with no cell on channel %p "
  1821. "(global ID " U64_FORMAT ").",
  1822. chan, U64_PRINTF_ARG(chan->global_identifier));
  1823. /* Throw it away */
  1824. cell_queue_entry_free(q, 0);
  1825. q = NULL;
  1826. }
  1827. break;
  1828. default:
  1829. /* Unknown type, log and free it */
  1830. log_info(LD_CHANNEL,
  1831. "Saw an unknown cell queue entry type %d on channel %p "
  1832. "(global ID " U64_FORMAT "; ignoring it."
  1833. " Someone should fix this.",
  1834. q->type, chan, U64_PRINTF_ARG(chan->global_identifier));
  1835. cell_queue_entry_free(q, 0);
  1836. q = NULL;
  1837. }
  1838. } else {
  1839. /* This shouldn't happen; log and throw it away */
  1840. log_info(LD_CHANNEL,
  1841. "Saw a NULL entry in the outgoing cell queue on channel %p "
  1842. "(global ID " U64_FORMAT "); this is definitely a bug.",
  1843. chan, U64_PRINTF_ARG(chan->global_identifier));
  1844. /* q is already NULL, so we know to delete that queue entry */
  1845. }
  1846. /* if q got NULLed out, we used it and should remove the queue entry */
  1847. if (!q) smartlist_del_keeporder(chan->outgoing_queue, 0);
  1848. /* No cell removed from list, so we can't go on any further */
  1849. else break;
  1850. }
  1851. }
  1852. /* Did we drain the queue? */
  1853. if (!(chan->outgoing_queue) ||
  1854. smartlist_len(chan->outgoing_queue) == 0) {
  1855. /* Timestamp it */
  1856. channel_timestamp_drained(chan);
  1857. }
  1858. return flushed;
  1859. }
  1860. /**
  1861. * Flush as many cells as we possibly can from the queue
  1862. *
  1863. * This tries to flush as many cells from the queue as the lower layer
  1864. * will take. It just calls channel_flush_some_cells_from_outgoing_queue()
  1865. * in unlimited mode.
  1866. */
  1867. void
  1868. channel_flush_cells(channel_t *chan)
  1869. {
  1870. channel_flush_some_cells_from_outgoing_queue(chan, -1);
  1871. }
  1872. /**
  1873. * Check if any cells are available
  1874. *
  1875. * This gets used from the lower layer to check if any more cells are
  1876. * available.
  1877. */
  1878. int
  1879. channel_more_to_flush(channel_t *chan)
  1880. {
  1881. tor_assert(chan);
  1882. /* Check if we have any queued */
  1883. if (chan->incoming_queue &&
  1884. smartlist_len(chan->incoming_queue) > 0) return 1;
  1885. /* Check if any circuits would like to queue some */
  1886. if (circuitmux_num_cells(chan->cmux) > 0) return 1;
  1887. /* Else no */
  1888. return 0;
  1889. }
  1890. /**
  1891. * Notify the channel we're done flushing the output in the lower layer
  1892. *
  1893. * Connection.c will call this when we've flushed the output; there's some
  1894. * dirreq-related maintenance to do.
  1895. */
  1896. void
  1897. channel_notify_flushed(channel_t *chan)
  1898. {
  1899. tor_assert(chan);
  1900. if (chan->dirreq_id != 0)
  1901. geoip_change_dirreq_state(chan->dirreq_id,
  1902. DIRREQ_TUNNELED,
  1903. DIRREQ_CHANNEL_BUFFER_FLUSHED);
  1904. }
  1905. /**
  1906. * Process the queue of incoming channels on a listener
  1907. *
  1908. * Use a listener's registered callback to process as many entries in the
  1909. * queue of incoming channels as possible.
  1910. */
  1911. void
  1912. channel_listener_process_incoming(channel_listener_t *listener)
  1913. {
  1914. tor_assert(listener);
  1915. /*
  1916. * CHANNEL_LISTENER_STATE_CLOSING permitted because we drain the queue
  1917. * while closing a listener.
  1918. */
  1919. tor_assert(listener->state == CHANNEL_LISTENER_STATE_LISTENING ||
  1920. listener->state == CHANNEL_LISTENER_STATE_CLOSING);
  1921. tor_assert(listener->listener);
  1922. log_debug(LD_CHANNEL,
  1923. "Processing queue of incoming connections for channel "
  1924. "listener %p (global ID " U64_FORMAT ")",
  1925. listener, U64_PRINTF_ARG(listener->global_identifier));
  1926. if (!(listener->incoming_list)) return;
  1927. SMARTLIST_FOREACH_BEGIN(listener->incoming_list,
  1928. channel_t *, chan) {
  1929. tor_assert(chan);
  1930. log_debug(LD_CHANNEL,
  1931. "Handling incoming channel %p (" U64_FORMAT ") "
  1932. "for listener %p (" U64_FORMAT ")",
  1933. chan,
  1934. U64_PRINTF_ARG(chan->global_identifier),
  1935. listener,
  1936. U64_PRINTF_ARG(listener->global_identifier));
  1937. /* Make sure this is set correctly */
  1938. channel_mark_incoming(chan);
  1939. listener->listener(listener, chan);
  1940. } SMARTLIST_FOREACH_END(chan);
  1941. smartlist_free(listener->incoming_list);
  1942. listener->incoming_list = NULL;
  1943. }
  1944. /**
  1945. * Take actions required when a channel becomes open
  1946. *
  1947. * Handle actions we should do when we know a channel is open; a lot of
  1948. * this comes from the old connection_or_set_state_open() of connection_or.c.
  1949. *
  1950. * Because of this mechanism, future channel_t subclasses should take care
  1951. * not to change a channel to from CHANNEL_STATE_OPENING to CHANNEL_STATE_OPEN
  1952. * until there is positive confirmation that the network is operational.
  1953. * In particular, anything UDP-based should not make this transition until a
  1954. * packet is received from the other side.
  1955. */
  1956. void
  1957. channel_do_open_actions(channel_t *chan)
  1958. {
  1959. tor_addr_t remote_addr;
  1960. int started_here, not_using = 0;
  1961. time_t now = time(NULL);
  1962. tor_assert(chan);
  1963. started_here = channel_is_outgoing(chan);
  1964. if (started_here) {
  1965. circuit_build_times_network_is_live(&circ_times);
  1966. rep_hist_note_connect_succeeded(chan->identity_digest, now);
  1967. if (entry_guard_register_connect_status(
  1968. chan->identity_digest, 1, 0, now) < 0) {
  1969. /* Close any circuits pending on this channel. We leave it in state
  1970. * 'open' though, because it didn't actually *fail* -- we just
  1971. * chose not to use it. */
  1972. log_debug(LD_OR,
  1973. "New entry guard was reachable, but closing this "
  1974. "connection so we can retry the earlier entry guards.");
  1975. circuit_n_chan_done(chan, 0);
  1976. not_using = 1;
  1977. }
  1978. router_set_status(chan->identity_digest, 1);
  1979. } else {
  1980. /* only report it to the geoip module if it's not a known router */
  1981. if (!router_get_by_id_digest(chan->identity_digest)) {
  1982. if (channel_get_addr_if_possible(chan, &remote_addr)) {
  1983. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &remote_addr,
  1984. now);
  1985. }
  1986. /* Otherwise the underlying transport can't tell us this, so skip it */
  1987. }
  1988. }
  1989. if (!not_using) circuit_n_chan_done(chan, 1);
  1990. }
  1991. /**
  1992. * Queue an incoming channel on a listener
  1993. *
  1994. * Internal and subclass use only function to queue an incoming channel from
  1995. * a listener. A subclass of channel_listener_t should call this when a new
  1996. * incoming channel is created.
  1997. */
  1998. void
  1999. channel_listener_queue_incoming(channel_listener_t *listener,
  2000. channel_t *incoming)
  2001. {
  2002. int need_to_queue = 0;
  2003. tor_assert(listener);
  2004. tor_assert(listener->state == CHANNEL_LISTENER_STATE_LISTENING);
  2005. tor_assert(incoming);
  2006. log_debug(LD_CHANNEL,
  2007. "Queueing incoming channel %p (global ID " U64_FORMAT ") on "
  2008. "channel listener %p (global ID " U64_FORMAT ")",
  2009. incoming, U64_PRINTF_ARG(incoming->global_identifier),
  2010. listener, U64_PRINTF_ARG(listener->global_identifier));
  2011. /* Do we need to queue it, or can we just call the listener right away? */
  2012. if (!(listener->listener)) need_to_queue = 1;
  2013. if (listener->incoming_list &&
  2014. (smartlist_len(listener->incoming_list) > 0))
  2015. need_to_queue = 1;
  2016. /* If we need to queue and have no queue, create one */
  2017. if (need_to_queue && !(listener->incoming_list)) {
  2018. listener->incoming_list = smartlist_new();
  2019. }
  2020. /* Bump the counter and timestamp it */
  2021. channel_listener_timestamp_active(listener);
  2022. channel_listener_timestamp_accepted(listener);
  2023. ++(listener->n_accepted);
  2024. /* If we don't need to queue, process it right away */
  2025. if (!need_to_queue) {
  2026. tor_assert(listener->listener);
  2027. listener->listener(listener, incoming);
  2028. }
  2029. /*
  2030. * Otherwise, we need to queue; queue and then process the queue if
  2031. * we can.
  2032. */
  2033. else {
  2034. tor_assert(listener->incoming_list);
  2035. smartlist_add(listener->incoming_list, incoming);
  2036. if (listener->listener) channel_listener_process_incoming(listener);
  2037. }
  2038. }
  2039. /**
  2040. * Process queued incoming cells
  2041. *
  2042. * Process as many queued cells as we can from the incoming
  2043. * cell queue.
  2044. */
  2045. void
  2046. channel_process_cells(channel_t *chan)
  2047. {
  2048. tor_assert(chan);
  2049. tor_assert(chan->state == CHANNEL_STATE_CLOSING ||
  2050. chan->state == CHANNEL_STATE_MAINT ||
  2051. chan->state == CHANNEL_STATE_OPEN);
  2052. log_debug(LD_CHANNEL,
  2053. "Processing as many incoming cells as we can for channel %p",
  2054. chan);
  2055. /* Nothing we can do if we have no registered cell handlers */
  2056. if (!(chan->cell_handler ||
  2057. chan->var_cell_handler)) return;
  2058. /* Nothing we can do if we have no cells */
  2059. if (!(chan->incoming_queue)) return;
  2060. /*
  2061. * Process cells until we're done or find one we have no current handler
  2062. * for.
  2063. */
  2064. SMARTLIST_FOREACH_BEGIN(chan->incoming_queue,
  2065. cell_queue_entry_t *, q) {
  2066. tor_assert(q);
  2067. tor_assert(q->type == CELL_QUEUE_FIXED ||
  2068. q->type == CELL_QUEUE_VAR);
  2069. if (q->type == CELL_QUEUE_FIXED &&
  2070. chan->cell_handler) {
  2071. /* Handle a fixed-length cell */
  2072. tor_assert(q->u.fixed.cell);
  2073. log_debug(LD_CHANNEL,
  2074. "Processing incoming cell_t %p for channel %p (global ID "
  2075. U64_FORMAT ")",
  2076. q->u.fixed.cell, chan,
  2077. U64_PRINTF_ARG(chan->global_identifier));
  2078. chan->cell_handler(chan, q->u.fixed.cell);
  2079. SMARTLIST_DEL_CURRENT(chan->incoming_queue, q);
  2080. tor_free(q);
  2081. } else if (q->type == CELL_QUEUE_VAR &&
  2082. chan->var_cell_handler) {
  2083. /* Handle a variable-length cell */
  2084. tor_assert(q->u.var.var_cell);
  2085. log_debug(LD_CHANNEL,
  2086. "Processing incoming var_cell_t %p for channel %p (global ID "
  2087. U64_FORMAT ")",
  2088. q->u.var.var_cell, chan,
  2089. U64_PRINTF_ARG(chan->global_identifier));
  2090. chan->var_cell_handler(chan, q->u.var.var_cell);
  2091. SMARTLIST_DEL_CURRENT(chan->incoming_queue, q);
  2092. tor_free(q);
  2093. } else {
  2094. /* Can't handle this one */
  2095. break;
  2096. }
  2097. } SMARTLIST_FOREACH_END(q);
  2098. /* If the list is empty, free it */
  2099. if (smartlist_len(chan->incoming_queue) == 0 ) {
  2100. smartlist_free(chan->incoming_queue);
  2101. chan->incoming_queue = NULL;
  2102. }
  2103. }
  2104. /**
  2105. * Queue incoming cell
  2106. *
  2107. * This should be called by a channel_t subclass to queue an incoming fixed-
  2108. * length cell for processing, and process it if possible.
  2109. */
  2110. void
  2111. channel_queue_cell(channel_t *chan, cell_t *cell)
  2112. {
  2113. int need_to_queue = 0;
  2114. cell_queue_entry_t *q;
  2115. tor_assert(chan);
  2116. tor_assert(cell);
  2117. tor_assert(chan->state == CHANNEL_STATE_OPEN);
  2118. /* Do we need to queue it, or can we just call the handler right away? */
  2119. if (!(chan->cell_handler)) need_to_queue = 1;
  2120. if (chan->incoming_queue &&
  2121. (smartlist_len(chan->incoming_queue) > 0))
  2122. need_to_queue = 1;
  2123. /* If we need to queue and have no queue, create one */
  2124. if (need_to_queue && !(chan->incoming_queue)) {
  2125. chan->incoming_queue = smartlist_new();
  2126. }
  2127. /* Timestamp for receiving */
  2128. channel_timestamp_recv(chan);
  2129. /* Update the counter */
  2130. ++(chan->n_cells_recved);
  2131. /* If we don't need to queue we can just call cell_handler */
  2132. if (!need_to_queue) {
  2133. tor_assert(chan->cell_handler);
  2134. log_debug(LD_CHANNEL,
  2135. "Directly handling incoming cell_t %p for channel %p "
  2136. "(global ID " U64_FORMAT ")",
  2137. cell, chan,
  2138. U64_PRINTF_ARG(chan->global_identifier));
  2139. chan->cell_handler(chan, cell);
  2140. } else {
  2141. /* Otherwise queue it and then process the queue if possible. */
  2142. tor_assert(chan->incoming_queue);
  2143. q = cell_queue_entry_new_fixed(cell);
  2144. log_debug(LD_CHANNEL,
  2145. "Queueing incoming cell_t %p for channel %p "
  2146. "(global ID " U64_FORMAT ")",
  2147. cell, chan,
  2148. U64_PRINTF_ARG(chan->global_identifier));
  2149. smartlist_add(chan->incoming_queue, q);
  2150. if (chan->cell_handler ||
  2151. chan->var_cell_handler) {
  2152. channel_process_cells(chan);
  2153. }
  2154. }
  2155. }
  2156. /**
  2157. * Queue incoming variable-length cell
  2158. *
  2159. * This should be called by a channel_t subclass to queue an incoming
  2160. * variable-length cell for processing, and process it if possible.
  2161. */
  2162. void
  2163. channel_queue_var_cell(channel_t *chan, var_cell_t *var_cell)
  2164. {
  2165. int need_to_queue = 0;
  2166. cell_queue_entry_t *q;
  2167. tor_assert(chan);
  2168. tor_assert(var_cell);
  2169. tor_assert(chan->state == CHANNEL_STATE_OPEN);
  2170. /* Do we need to queue it, or can we just call the handler right away? */
  2171. if (!(chan->var_cell_handler)) need_to_queue = 1;
  2172. if (chan->incoming_queue &&
  2173. (smartlist_len(chan->incoming_queue) > 0))
  2174. need_to_queue = 1;
  2175. /* If we need to queue and have no queue, create one */
  2176. if (need_to_queue && !(chan->incoming_queue)) {
  2177. chan->incoming_queue = smartlist_new();
  2178. }
  2179. /* Timestamp for receiving */
  2180. channel_timestamp_recv(chan);
  2181. /* Update the counter */
  2182. ++(chan->n_cells_recved);
  2183. /* If we don't need to queue we can just call cell_handler */
  2184. if (!need_to_queue) {
  2185. tor_assert(chan->var_cell_handler);
  2186. log_debug(LD_CHANNEL,
  2187. "Directly handling incoming var_cell_t %p for channel %p "
  2188. "(global ID " U64_FORMAT ")",
  2189. var_cell, chan,
  2190. U64_PRINTF_ARG(chan->global_identifier));
  2191. chan->var_cell_handler(chan, var_cell);
  2192. } else {
  2193. /* Otherwise queue it and then process the queue if possible. */
  2194. tor_assert(chan->incoming_queue);
  2195. q = cell_queue_entry_new_var(var_cell);
  2196. log_debug(LD_CHANNEL,
  2197. "Queueing incoming var_cell_t %p for channel %p "
  2198. "(global ID " U64_FORMAT ")",
  2199. var_cell, chan,
  2200. U64_PRINTF_ARG(chan->global_identifier));
  2201. smartlist_add(chan->incoming_queue, q);
  2202. if (chan->cell_handler ||
  2203. chan->var_cell_handler) {
  2204. channel_process_cells(chan);
  2205. }
  2206. }
  2207. }
  2208. /**
  2209. * Send destroy cell on a channel
  2210. *
  2211. * Write a destroy cell with circ ID <b>circ_id</b> and reason <b>reason</b>
  2212. * onto channel <b>chan</b>. Don't perform range-checking on reason:
  2213. * we may want to propagate reasons from other cells.
  2214. */
  2215. int
  2216. channel_send_destroy(circid_t circ_id, channel_t *chan, int reason)
  2217. {
  2218. cell_t cell;
  2219. tor_assert(chan);
  2220. memset(&cell, 0, sizeof(cell_t));
  2221. cell.circ_id = circ_id;
  2222. cell.command = CELL_DESTROY;
  2223. cell.payload[0] = (uint8_t) reason;
  2224. log_debug(LD_OR,
  2225. "Sending destroy (circID %d) on channel %p "
  2226. "(global ID " U64_FORMAT ")",
  2227. circ_id, chan,
  2228. U64_PRINTF_ARG(chan->global_identifier));
  2229. channel_write_cell(chan, &cell);
  2230. return 0;
  2231. }
  2232. /**
  2233. * Dump channel statistics to the log
  2234. *
  2235. * This is called from dumpstats() in main.c and spams the log with
  2236. * statistics on channels.
  2237. */
  2238. void
  2239. channel_dumpstats(int severity)
  2240. {
  2241. if (all_channels && smartlist_len(all_channels) > 0) {
  2242. log(severity, LD_GENERAL,
  2243. "Dumping statistics about %d channels:",
  2244. smartlist_len(all_channels));
  2245. log(severity, LD_GENERAL,
  2246. "%d are active, and %d are done and waiting for cleanup",
  2247. (active_channels != NULL) ?
  2248. smartlist_len(active_channels) : 0,
  2249. (finished_channels != NULL) ?
  2250. smartlist_len(finished_channels) : 0);
  2251. SMARTLIST_FOREACH(all_channels, channel_t *, chan,
  2252. channel_dump_statistics(chan, severity));
  2253. log(severity, LD_GENERAL,
  2254. "Done spamming about channels now");
  2255. } else {
  2256. log(severity, LD_GENERAL,
  2257. "No channels to dump");
  2258. }
  2259. }
  2260. /**
  2261. * Dump channel listener statistics to the log
  2262. *
  2263. * This is called from dumpstats() in main.c and spams the log with
  2264. * statistics on channel listeners.
  2265. */
  2266. void
  2267. channel_listener_dumpstats(int severity)
  2268. {
  2269. if (all_listeners && smartlist_len(all_listeners) > 0) {
  2270. log(severity, LD_GENERAL,
  2271. "Dumping statistics about %d channel listeners:",
  2272. smartlist_len(all_listeners));
  2273. log(severity, LD_GENERAL,
  2274. "%d are active and %d are done and waiting for cleanup",
  2275. (active_listeners != NULL) ?
  2276. smartlist_len(active_listeners) : 0,
  2277. (finished_listeners != NULL) ?
  2278. smartlist_len(finished_listeners) : 0);
  2279. SMARTLIST_FOREACH(all_listeners, channel_listener_t *, chan_l,
  2280. channel_listener_dump_statistics(chan_l, severity));
  2281. log(severity, LD_GENERAL,
  2282. "Done spamming about channel listeners now");
  2283. } else {
  2284. log(severity, LD_GENERAL,
  2285. "No channel listeners to dump");
  2286. }
  2287. }
  2288. /**
  2289. * Set the cmux policy on all active channels
  2290. */
  2291. void
  2292. channel_set_cmux_policy_everywhere(circuitmux_policy_t *pol)
  2293. {
  2294. if (!active_channels) return;
  2295. SMARTLIST_FOREACH_BEGIN(active_channels, channel_t *, curr) {
  2296. if (curr->cmux) {
  2297. circuitmux_set_policy(curr->cmux, pol);
  2298. }
  2299. } SMARTLIST_FOREACH_END(curr);
  2300. }
  2301. /**
  2302. * Clean up channels
  2303. *
  2304. * This gets called periodically from run_scheduled_events() in main.c;
  2305. * it cleans up after closed channels.
  2306. */
  2307. void
  2308. channel_run_cleanup(void)
  2309. {
  2310. channel_t *tmp = NULL;
  2311. /* Check if we need to do anything */
  2312. if (!finished_channels || smartlist_len(finished_channels) == 0) return;
  2313. /* Iterate through finished_channels and get rid of them */
  2314. SMARTLIST_FOREACH_BEGIN(finished_channels, channel_t *, curr) {
  2315. tmp = curr;
  2316. /* Remove it from the list */
  2317. SMARTLIST_DEL_CURRENT(finished_channels, curr);
  2318. /* Also unregister it */
  2319. channel_unregister(tmp);
  2320. /* ... and free it */
  2321. channel_free(tmp);
  2322. } SMARTLIST_FOREACH_END(curr);
  2323. }
  2324. /**
  2325. * Clean up channel listeners
  2326. *
  2327. * This gets called periodically from run_scheduled_events() in main.c;
  2328. * it cleans up after closed channel listeners.
  2329. */
  2330. void
  2331. channel_listener_run_cleanup(void)
  2332. {
  2333. channel_listener_t *tmp = NULL;
  2334. /* Check if we need to do anything */
  2335. if (!finished_listeners || smartlist_len(finished_listeners) == 0) return;
  2336. /* Iterate through finished_channels and get rid of them */
  2337. SMARTLIST_FOREACH_BEGIN(finished_listeners, channel_listener_t *, curr) {
  2338. tmp = curr;
  2339. /* Remove it from the list */
  2340. SMARTLIST_DEL_CURRENT(finished_listeners, curr);
  2341. /* Also unregister it */
  2342. channel_listener_unregister(tmp);
  2343. /* ... and free it */
  2344. channel_listener_free(tmp);
  2345. } SMARTLIST_FOREACH_END(curr);
  2346. }
  2347. /**
  2348. * Free a list of channels for channel_free_all()
  2349. */
  2350. static void
  2351. channel_free_list(smartlist_t *channels, int mark_for_close)
  2352. {
  2353. if (!channels) return;
  2354. SMARTLIST_FOREACH_BEGIN(channels, channel_t *, curr) {
  2355. /* Deregister and free it */
  2356. tor_assert(curr);
  2357. log_debug(LD_CHANNEL,
  2358. "Cleaning up channel %p (global ID " U64_FORMAT ") "
  2359. "in state %s (%d)",
  2360. curr, U64_PRINTF_ARG(curr->global_identifier),
  2361. channel_state_to_string(curr->state), curr->state);
  2362. /* Detach circuits early so they can find the channel */
  2363. if (curr->cmux) {
  2364. circuitmux_detach_all_circuits(curr->cmux);
  2365. }
  2366. channel_unregister(curr);
  2367. if (mark_for_close) {
  2368. if (!(curr->state == CHANNEL_STATE_CLOSING ||
  2369. curr->state == CHANNEL_STATE_CLOSED ||
  2370. curr->state == CHANNEL_STATE_ERROR)) {
  2371. channel_mark_for_close(curr);
  2372. }
  2373. channel_force_free(curr);
  2374. } else channel_free(curr);
  2375. } SMARTLIST_FOREACH_END(curr);
  2376. }
  2377. /**
  2378. * Free a list of channel listeners for channel_free_all()
  2379. */
  2380. static void
  2381. channel_listener_free_list(smartlist_t *listeners, int mark_for_close)
  2382. {
  2383. if (!listeners) return;
  2384. SMARTLIST_FOREACH_BEGIN(listeners, channel_listener_t *, curr) {
  2385. /* Deregister and free it */
  2386. tor_assert(curr);
  2387. log_debug(LD_CHANNEL,
  2388. "Cleaning up channel listener %p (global ID " U64_FORMAT ") "
  2389. "in state %s (%d)",
  2390. curr, U64_PRINTF_ARG(curr->global_identifier),
  2391. channel_listener_state_to_string(curr->state), curr->state);
  2392. channel_listener_unregister(curr);
  2393. if (mark_for_close) {
  2394. if (!(curr->state == CHANNEL_LISTENER_STATE_CLOSING ||
  2395. curr->state == CHANNEL_LISTENER_STATE_CLOSED ||
  2396. curr->state == CHANNEL_LISTENER_STATE_ERROR)) {
  2397. channel_listener_mark_for_close(curr);
  2398. }
  2399. channel_listener_force_free(curr);
  2400. } else channel_listener_free(curr);
  2401. } SMARTLIST_FOREACH_END(curr);
  2402. }
  2403. /**
  2404. * Close all channels and free everything
  2405. *
  2406. * This gets called from tor_free_all() in main.c to clean up on exit.
  2407. * It will close all registered channels and free associated storage,
  2408. * then free the all_channels, active_channels, listening_channels and
  2409. * finished_channels lists and also channel_identity_map.
  2410. */
  2411. void
  2412. channel_free_all(void)
  2413. {
  2414. log_debug(LD_CHANNEL,
  2415. "Shutting down channels...");
  2416. /* First, let's go for finished channels */
  2417. if (finished_channels) {
  2418. channel_free_list(finished_channels, 0);
  2419. smartlist_free(finished_channels);
  2420. finished_channels = NULL;
  2421. }
  2422. /* Now the finished listeners */
  2423. if (finished_listeners) {
  2424. channel_listener_free_list(finished_listeners, 0);
  2425. smartlist_free(finished_listeners);
  2426. finished_listeners = NULL;
  2427. }
  2428. /* Now all active channels */
  2429. if (active_channels) {
  2430. channel_free_list(active_channels, 1);
  2431. smartlist_free(active_channels);
  2432. active_channels = NULL;
  2433. }
  2434. /* Now all active listeners */
  2435. if (active_listeners) {
  2436. channel_listener_free_list(active_listeners, 1);
  2437. smartlist_free(active_listeners);
  2438. active_listeners = NULL;
  2439. }
  2440. /* Now all channels, in case any are left over */
  2441. if (all_channels) {
  2442. channel_free_list(all_channels, 1);
  2443. smartlist_free(all_channels);
  2444. all_channels = NULL;
  2445. }
  2446. /* Now all listeners, in case any are left over */
  2447. if (all_listeners) {
  2448. channel_listener_free_list(all_listeners, 1);
  2449. smartlist_free(all_listeners);
  2450. all_listeners = NULL;
  2451. }
  2452. /* Now free channel_identity_map */
  2453. if (channel_identity_map) {
  2454. log_debug(LD_CHANNEL,
  2455. "Freeing channel_identity_map");
  2456. /* Geez, anything still left over just won't die ... let it leak then */
  2457. digestmap_free(channel_identity_map, NULL);
  2458. channel_identity_map = NULL;
  2459. }
  2460. log_debug(LD_CHANNEL,
  2461. "Done cleaning up after channels");
  2462. }
  2463. /**
  2464. * Connect to a given addr/port/digest
  2465. *
  2466. * This sets up a new outgoing channel; in the future if multiple
  2467. * channel_t subclasses are available, this is where the selection policy
  2468. * should go. It may also be desirable to fold port into tor_addr_t
  2469. * or make a new type including a tor_addr_t and port, so we have a
  2470. * single abstract object encapsulating all the protocol details of
  2471. * how to contact an OR.
  2472. */
  2473. channel_t *
  2474. channel_connect(const tor_addr_t *addr, uint16_t port,
  2475. const char *id_digest)
  2476. {
  2477. return channel_tls_connect(addr, port, id_digest);
  2478. }
  2479. /**
  2480. * Decide which of two channels to prefer for extending a circuit
  2481. *
  2482. * This function is called while extending a circuit and returns true iff
  2483. * a is 'better' than b. The most important criterion here is that a
  2484. * canonical channel is always better than a non-canonical one, but the
  2485. * number of circuits and the age are used as tie-breakers.
  2486. *
  2487. * This is based on the former connection_or_is_better() of connection_or.c
  2488. */
  2489. int
  2490. channel_is_better(time_t now, channel_t *a, channel_t *b,
  2491. int forgive_new_connections)
  2492. {
  2493. int a_grace, b_grace;
  2494. int a_is_canonical, b_is_canonical;
  2495. int a_has_circs, b_has_circs;
  2496. /*
  2497. * Do not definitively deprecate a new channel with no circuits on it
  2498. * until this much time has passed.
  2499. */
  2500. #define NEW_CHAN_GRACE_PERIOD (15*60)
  2501. tor_assert(a);
  2502. tor_assert(b);
  2503. /* Check if one is canonical and the other isn't first */
  2504. a_is_canonical = channel_is_canonical(a);
  2505. b_is_canonical = channel_is_canonical(b);
  2506. if (a_is_canonical && !b_is_canonical) return 1;
  2507. if (!a_is_canonical && b_is_canonical) return 0;
  2508. /*
  2509. * Okay, if we're here they tied on canonicity. Next we check if
  2510. * they have any circuits, and if one does and the other doesn't,
  2511. * we prefer the one that does, unless we are forgiving and the
  2512. * one that has no circuits is in its grace period.
  2513. */
  2514. a_has_circs = (channel_num_circuits(a) > 0);
  2515. b_has_circs = (channel_num_circuits(b) > 0);
  2516. a_grace = (forgive_new_connections &&
  2517. (now < channel_when_created(a) + NEW_CHAN_GRACE_PERIOD));
  2518. b_grace = (forgive_new_connections &&
  2519. (now < channel_when_created(b) + NEW_CHAN_GRACE_PERIOD));
  2520. if (a_has_circs && !b_has_circs && !b_grace) return 1;
  2521. if (!a_has_circs && b_has_circs && !a_grace) return 0;
  2522. /* They tied on circuits too; just prefer whichever is newer */
  2523. if (channel_when_created(a) > channel_when_created(b)) return 1;
  2524. else return 0;
  2525. }
  2526. /**
  2527. * Get a channel to extend a circuit
  2528. *
  2529. * Pick a suitable channel to extend a circuit to given the desired digest
  2530. * the address we believe is correct for that digest; this tries to see
  2531. * if we already have one for the requested endpoint, but if there is no good
  2532. * channel, set *msg_out to a message describing the channel's state
  2533. * and our next action, and set *launch_out to a boolean indicated whether
  2534. * the caller should try to launch a new channel with channel_connect().
  2535. */
  2536. channel_t *
  2537. channel_get_for_extend(const char *digest,
  2538. const tor_addr_t *target_addr,
  2539. const char **msg_out,
  2540. int *launch_out)
  2541. {
  2542. channel_t *chan, *best = NULL;
  2543. int n_inprogress_goodaddr = 0, n_old = 0;
  2544. int n_noncanonical = 0, n_possible = 0;
  2545. time_t now = approx_time();
  2546. tor_assert(msg_out);
  2547. tor_assert(launch_out);
  2548. if (!channel_identity_map) {
  2549. *msg_out = "Router not connected (nothing is). Connecting.";
  2550. *launch_out = 1;
  2551. return NULL;
  2552. }
  2553. chan = channel_find_by_remote_digest(digest);
  2554. /* Walk the list, unrefing the old one and refing the new at each
  2555. * iteration.
  2556. */
  2557. for (; chan; chan = channel_next_with_digest(chan)) {
  2558. tor_assert(tor_memeq(chan->identity_digest,
  2559. digest, DIGEST_LEN));
  2560. if (chan->state == CHANNEL_STATE_CLOSING ||
  2561. chan->state == CHANNEL_STATE_CLOSED ||
  2562. chan->state == CHANNEL_STATE_ERROR)
  2563. continue;
  2564. /* Never return a channel on which the other end appears to be
  2565. * a client. */
  2566. if (channel_is_client(chan)) {
  2567. continue;
  2568. }
  2569. /* Never return a non-open connection. */
  2570. if (chan->state != CHANNEL_STATE_OPEN) {
  2571. /* If the address matches, don't launch a new connection for this
  2572. * circuit. */
  2573. if (!channel_matches_target_addr_for_extend(chan, target_addr))
  2574. ++n_inprogress_goodaddr;
  2575. continue;
  2576. }
  2577. /* Never return a connection that shouldn't be used for circs. */
  2578. if (channel_is_bad_for_new_circs(chan)) {
  2579. ++n_old;
  2580. continue;
  2581. }
  2582. /* Never return a non-canonical connection using a recent link protocol
  2583. * if the address is not what we wanted.
  2584. *
  2585. * The channel_is_canonical_is_reliable() function asks the lower layer
  2586. * if we should trust channel_is_canonical(). The below is from the
  2587. * comments of the old circuit_or_get_for_extend() and applies when
  2588. * the lower-layer transport is channel_tls_t.
  2589. *
  2590. * (For old link protocols, we can't rely on is_canonical getting
  2591. * set properly if we're talking to the right address, since we might
  2592. * have an out-of-date descriptor, and we will get no NETINFO cell to
  2593. * tell us about the right address.)
  2594. */
  2595. if (!channel_is_canonical(chan) &&
  2596. channel_is_canonical_is_reliable(chan) &&
  2597. !channel_matches_target_addr_for_extend(chan, target_addr)) {
  2598. ++n_noncanonical;
  2599. continue;
  2600. }
  2601. ++n_possible;
  2602. if (!best) {
  2603. best = chan; /* If we have no 'best' so far, this one is good enough. */
  2604. continue;
  2605. }
  2606. if (channel_is_better(now, chan, best, 0))
  2607. best = chan;
  2608. }
  2609. if (best) {
  2610. *msg_out = "Connection is fine; using it.";
  2611. *launch_out = 0;
  2612. return best;
  2613. } else if (n_inprogress_goodaddr) {
  2614. *msg_out = "Connection in progress; waiting.";
  2615. *launch_out = 0;
  2616. return NULL;
  2617. } else if (n_old || n_noncanonical) {
  2618. *msg_out = "Connections all too old, or too non-canonical. "
  2619. " Launching a new one.";
  2620. *launch_out = 1;
  2621. return NULL;
  2622. } else {
  2623. *msg_out = "Not connected. Connecting.";
  2624. *launch_out = 1;
  2625. return NULL;
  2626. }
  2627. }
  2628. /**
  2629. * Describe the transport subclass for a channel
  2630. *
  2631. * Invoke a method to get a string description of the lower-layer
  2632. * transport for this channel.
  2633. */
  2634. const char *
  2635. channel_describe_transport(channel_t *chan)
  2636. {
  2637. tor_assert(chan);
  2638. tor_assert(chan->describe_transport);
  2639. return chan->describe_transport(chan);
  2640. }
  2641. /**
  2642. * Describe the transport subclass for a channel listener
  2643. *
  2644. * Invoke a method to get a string description of the lower-layer
  2645. * transport for this channel listener.
  2646. */
  2647. const char *
  2648. channel_listener_describe_transport(channel_listener_t *chan_l)
  2649. {
  2650. tor_assert(chan_l);
  2651. tor_assert(chan_l->describe_transport);
  2652. return chan_l->describe_transport(chan_l);
  2653. }
  2654. /**
  2655. * Dump channel statistics
  2656. *
  2657. * Dump statistics for one channel to the log
  2658. */
  2659. void
  2660. channel_dump_statistics(channel_t *chan, int severity)
  2661. {
  2662. double avg, interval, age;
  2663. time_t now = time(NULL);
  2664. tor_addr_t remote_addr;
  2665. int have_remote_addr;
  2666. char *remote_addr_str;
  2667. tor_assert(chan);
  2668. age = (double)(now - chan->timestamp_created);
  2669. log(severity, LD_GENERAL,
  2670. "Channel " U64_FORMAT " (at %p) with transport %s is in state "
  2671. "%s (%d)",
  2672. U64_PRINTF_ARG(chan->global_identifier), chan,
  2673. channel_describe_transport(chan),
  2674. channel_state_to_string(chan->state), chan->state);
  2675. log(severity, LD_GENERAL,
  2676. " * Channel " U64_FORMAT " was created at " U64_FORMAT
  2677. " (" U64_FORMAT " seconds ago) "
  2678. "and last active at " U64_FORMAT " (" U64_FORMAT " seconds ago)",
  2679. U64_PRINTF_ARG(chan->global_identifier),
  2680. U64_PRINTF_ARG(chan->timestamp_created),
  2681. U64_PRINTF_ARG(now - chan->timestamp_created),
  2682. U64_PRINTF_ARG(chan->timestamp_active),
  2683. U64_PRINTF_ARG(now - chan->timestamp_active));
  2684. /* Handle digest and nickname */
  2685. if (!tor_digest_is_zero(chan->identity_digest)) {
  2686. if (chan->nickname) {
  2687. log(severity, LD_GENERAL,
  2688. " * Channel " U64_FORMAT " says it is connected "
  2689. "to an OR with digest %s and nickname %s",
  2690. U64_PRINTF_ARG(chan->global_identifier),
  2691. hex_str(chan->identity_digest, DIGEST_LEN),
  2692. chan->nickname);
  2693. } else {
  2694. log(severity, LD_GENERAL,
  2695. " * Channel " U64_FORMAT " says it is connected "
  2696. "to an OR with digest %s and no known nickname",
  2697. U64_PRINTF_ARG(chan->global_identifier),
  2698. hex_str(chan->identity_digest, DIGEST_LEN));
  2699. }
  2700. } else {
  2701. if (chan->nickname) {
  2702. log(severity, LD_GENERAL,
  2703. " * Channel " U64_FORMAT " does not know the digest"
  2704. " of the OR it is connected to, but reports its nickname is %s",
  2705. U64_PRINTF_ARG(chan->global_identifier),
  2706. chan->nickname);
  2707. } else {
  2708. log(severity, LD_GENERAL,
  2709. " * Channel " U64_FORMAT " does not know the digest"
  2710. " or the nickname of the OR it is connected to",
  2711. U64_PRINTF_ARG(chan->global_identifier));
  2712. }
  2713. }
  2714. /* Handle remote address and descriptions */
  2715. have_remote_addr = channel_get_addr_if_possible(chan, &remote_addr);
  2716. if (have_remote_addr) {
  2717. remote_addr_str = tor_dup_addr(&remote_addr);
  2718. log(severity, LD_GENERAL,
  2719. " * Channel " U64_FORMAT " says its remote address"
  2720. " is %s, and gives a canonical description of \"%s\" and an "
  2721. "actual description of \"%s\"",
  2722. U64_PRINTF_ARG(chan->global_identifier),
  2723. remote_addr_str,
  2724. channel_get_canonical_remote_descr(chan),
  2725. channel_get_actual_remote_descr(chan));
  2726. tor_free(remote_addr_str);
  2727. } else {
  2728. log(severity, LD_GENERAL,
  2729. " * Channel " U64_FORMAT " does not know its remote "
  2730. "address, but gives a canonical description of \"%s\" and an "
  2731. "actual description of \"%s\"",
  2732. U64_PRINTF_ARG(chan->global_identifier),
  2733. channel_get_canonical_remote_descr(chan),
  2734. channel_get_actual_remote_descr(chan));
  2735. }
  2736. /* Handle marks */
  2737. log(severity, LD_GENERAL,
  2738. " * Channel " U64_FORMAT " has these marks: %s %s %s "
  2739. "%s %s %s",
  2740. U64_PRINTF_ARG(chan->global_identifier),
  2741. channel_is_bad_for_new_circs(chan) ?
  2742. "bad_for_new_circs" : "!bad_for_new_circs",
  2743. channel_is_canonical(chan) ?
  2744. "canonical" : "!canonical",
  2745. channel_is_canonical_is_reliable(chan) ?
  2746. "is_canonical_is_reliable" :
  2747. "!is_canonical_is_reliable",
  2748. channel_is_client(chan) ?
  2749. "client" : "!client",
  2750. channel_is_local(chan) ?
  2751. "local" : "!local",
  2752. channel_is_incoming(chan) ?
  2753. "incoming" : "outgoing");
  2754. /* Describe queues */
  2755. log(severity, LD_GENERAL,
  2756. " * Channel " U64_FORMAT " has %d queued incoming cells"
  2757. " and %d queued outgoing cells",
  2758. U64_PRINTF_ARG(chan->global_identifier),
  2759. (chan->incoming_queue != NULL) ?
  2760. smartlist_len(chan->incoming_queue) : 0,
  2761. (chan->outgoing_queue != NULL) ?
  2762. smartlist_len(chan->outgoing_queue) : 0);
  2763. /* Describe circuits */
  2764. log(severity, LD_GENERAL,
  2765. " * Channel " U64_FORMAT " has %d active circuits out of"
  2766. " %d in total",
  2767. U64_PRINTF_ARG(chan->global_identifier),
  2768. (chan->cmux != NULL) ?
  2769. circuitmux_num_active_circuits(chan->cmux) : 0,
  2770. (chan->cmux != NULL) ?
  2771. circuitmux_num_circuits(chan->cmux) : 0);
  2772. /* Describe timestamps */
  2773. log(severity, LD_GENERAL,
  2774. " * Channel " U64_FORMAT " was last used by a "
  2775. "client at " U64_FORMAT " (" U64_FORMAT " seconds ago)",
  2776. U64_PRINTF_ARG(chan->global_identifier),
  2777. U64_PRINTF_ARG(chan->timestamp_client),
  2778. U64_PRINTF_ARG(now - chan->timestamp_client));
  2779. log(severity, LD_GENERAL,
  2780. " * Channel " U64_FORMAT " was last drained at "
  2781. U64_FORMAT " (" U64_FORMAT " seconds ago)",
  2782. U64_PRINTF_ARG(chan->global_identifier),
  2783. U64_PRINTF_ARG(chan->timestamp_drained),
  2784. U64_PRINTF_ARG(now - chan->timestamp_drained));
  2785. log(severity, LD_GENERAL,
  2786. " * Channel " U64_FORMAT " last received a cell "
  2787. "at " U64_FORMAT " (" U64_FORMAT " seconds ago)",
  2788. U64_PRINTF_ARG(chan->global_identifier),
  2789. U64_PRINTF_ARG(chan->timestamp_recv),
  2790. U64_PRINTF_ARG(now - chan->timestamp_recv));
  2791. log(severity, LD_GENERAL,
  2792. " * Channel " U64_FORMAT " last trasmitted a cell "
  2793. "at " U64_FORMAT " (" U64_FORMAT " seconds ago)",
  2794. U64_PRINTF_ARG(chan->global_identifier),
  2795. U64_PRINTF_ARG(chan->timestamp_xmit),
  2796. U64_PRINTF_ARG(now - chan->timestamp_xmit));
  2797. /* Describe counters and rates */
  2798. log(severity, LD_GENERAL,
  2799. " * Channel " U64_FORMAT " has received "
  2800. U64_FORMAT " cells and transmitted " U64_FORMAT,
  2801. U64_PRINTF_ARG(chan->global_identifier),
  2802. U64_PRINTF_ARG(chan->n_cells_recved),
  2803. U64_PRINTF_ARG(chan->n_cells_xmitted));
  2804. if (now > chan->timestamp_created &&
  2805. chan->timestamp_created > 0) {
  2806. if (chan->n_cells_recved > 0) {
  2807. avg = (double)(chan->n_cells_recved) / age;
  2808. if (avg >= 1.0) {
  2809. log(severity, LD_GENERAL,
  2810. " * Channel " U64_FORMAT " has averaged %f "
  2811. "cells received per second",
  2812. U64_PRINTF_ARG(chan->global_identifier), avg);
  2813. } else if (avg >= 0.0) {
  2814. interval = 1.0 / avg;
  2815. log(severity, LD_GENERAL,
  2816. " * Channel " U64_FORMAT " has averaged %f "
  2817. "seconds between received cells",
  2818. U64_PRINTF_ARG(chan->global_identifier), interval);
  2819. }
  2820. }
  2821. if (chan->n_cells_xmitted > 0) {
  2822. avg = (double)(chan->n_cells_xmitted) / age;
  2823. if (avg >= 1.0) {
  2824. log(severity, LD_GENERAL,
  2825. " * Channel " U64_FORMAT " has averaged %f "
  2826. "cells transmitted per second",
  2827. U64_PRINTF_ARG(chan->global_identifier), avg);
  2828. } else if (avg >= 0.0) {
  2829. interval = 1.0 / avg;
  2830. log(severity, LD_GENERAL,
  2831. " * Channel " U64_FORMAT " has averaged %f "
  2832. "seconds between transmitted cells",
  2833. U64_PRINTF_ARG(chan->global_identifier), interval);
  2834. }
  2835. }
  2836. }
  2837. /* Dump anything the lower layer has to say */
  2838. channel_dump_transport_statistics(chan, severity);
  2839. }
  2840. /**
  2841. * Dump channel listener statistics
  2842. *
  2843. * Dump statistics for one channel listener to the log
  2844. */
  2845. void
  2846. channel_listener_dump_statistics(channel_listener_t *chan_l, int severity)
  2847. {
  2848. double avg, interval, age;
  2849. time_t now = time(NULL);
  2850. tor_assert(chan_l);
  2851. age = (double)(now - chan_l->timestamp_created);
  2852. log(severity, LD_GENERAL,
  2853. "Channel listener " U64_FORMAT " (at %p) with transport %s is in "
  2854. "state %s (%d)",
  2855. U64_PRINTF_ARG(chan_l->global_identifier), chan_l,
  2856. channel_listener_describe_transport(chan_l),
  2857. channel_listener_state_to_string(chan_l->state), chan_l->state);
  2858. log(severity, LD_GENERAL,
  2859. " * Channel listener " U64_FORMAT " was created at " U64_FORMAT
  2860. " (" U64_FORMAT " seconds ago) "
  2861. "and last active at " U64_FORMAT " (" U64_FORMAT " seconds ago)",
  2862. U64_PRINTF_ARG(chan_l->global_identifier),
  2863. U64_PRINTF_ARG(chan_l->timestamp_created),
  2864. U64_PRINTF_ARG(now - chan_l->timestamp_created),
  2865. U64_PRINTF_ARG(chan_l->timestamp_active),
  2866. U64_PRINTF_ARG(now - chan_l->timestamp_active));
  2867. log(severity, LD_GENERAL,
  2868. " * Channel listener " U64_FORMAT " last accepted an incoming "
  2869. "channel at " U64_FORMAT " (" U64_FORMAT " seconds ago) "
  2870. "and has accepted " U64_FORMAT " channels in total",
  2871. U64_PRINTF_ARG(chan_l->global_identifier),
  2872. U64_PRINTF_ARG(chan_l->timestamp_accepted),
  2873. U64_PRINTF_ARG(now - chan_l->timestamp_accepted),
  2874. U64_PRINTF_ARG(chan_l->n_accepted));
  2875. /*
  2876. * If it's sensible to do so, get the rate of incoming channels on this
  2877. * listener
  2878. */
  2879. if (now > chan_l->timestamp_created &&
  2880. chan_l->timestamp_created > 0 &&
  2881. chan_l->n_accepted > 0) {
  2882. avg = (double)(chan_l->n_accepted) / age;
  2883. if (avg >= 1.0) {
  2884. log(severity, LD_GENERAL,
  2885. " * Channel listener " U64_FORMAT " has averaged %f incoming "
  2886. "channels per second",
  2887. U64_PRINTF_ARG(chan_l->global_identifier), avg);
  2888. } else if (avg >= 0.0) {
  2889. interval = 1.0 / avg;
  2890. log(severity, LD_GENERAL,
  2891. " * Channel listener " U64_FORMAT " has averaged %f seconds "
  2892. "between incoming channels",
  2893. U64_PRINTF_ARG(chan_l->global_identifier), interval);
  2894. }
  2895. }
  2896. /* Dump anything the lower layer has to say */
  2897. channel_listener_dump_transport_statistics(chan_l, severity);
  2898. }
  2899. /**
  2900. * Invoke transport-specific stats dump for channel
  2901. *
  2902. * If there is a lower-layer statistics dump method, invoke it
  2903. */
  2904. void
  2905. channel_dump_transport_statistics(channel_t *chan, int severity)
  2906. {
  2907. tor_assert(chan);
  2908. if (chan->dumpstats) chan->dumpstats(chan, severity);
  2909. }
  2910. /**
  2911. * Invoke transport-specific stats dump for channel listener
  2912. *
  2913. * If there is a lower-layer statistics dump method, invoke it
  2914. */
  2915. void
  2916. channel_listener_dump_transport_statistics(channel_listener_t *chan_l,
  2917. int severity)
  2918. {
  2919. tor_assert(chan_l);
  2920. if (chan_l->dumpstats) chan_l->dumpstats(chan_l, severity);
  2921. }
  2922. /**
  2923. * Return text description of the remote endpoint
  2924. *
  2925. * This function return a test provided by the lower layer of the remote
  2926. * endpoint for this channel; it should specify the actual address connected
  2927. * to/from.
  2928. */
  2929. const char *
  2930. channel_get_actual_remote_descr(channel_t *chan)
  2931. {
  2932. tor_assert(chan);
  2933. tor_assert(chan->get_remote_descr);
  2934. /* Param 1 indicates the actual description */
  2935. return chan->get_remote_descr(chan, 1);
  2936. }
  2937. /**
  2938. * Return text description of the remote endpoint canonical address
  2939. *
  2940. * This function return a test provided by the lower layer of the remote
  2941. * endpoint for this channel; it should use the known canonical address for
  2942. * this OR's identity digest if possible.
  2943. */
  2944. const char *
  2945. channel_get_canonical_remote_descr(channel_t *chan)
  2946. {
  2947. tor_assert(chan);
  2948. tor_assert(chan->get_remote_descr);
  2949. /* Param 0 indicates the canonicalized description */
  2950. return chan->get_remote_descr(chan, 0);
  2951. }
  2952. /**
  2953. * Get remote address if possible
  2954. *
  2955. * Write the remote address out to a tor_addr_t if the underlying transport
  2956. * supports this operation.
  2957. */
  2958. int
  2959. channel_get_addr_if_possible(channel_t *chan, tor_addr_t *addr_out)
  2960. {
  2961. tor_assert(chan);
  2962. tor_assert(addr_out);
  2963. if (chan->get_remote_addr)
  2964. return chan->get_remote_addr(chan, addr_out);
  2965. /* Else no support, method not implemented */
  2966. else return 0;
  2967. }
  2968. /**
  2969. * Check if there are outgoing queue writes on this channel
  2970. *
  2971. * Indicate if either we have queued cells, or if not, whether the underlying
  2972. * lower-layer transport thinks it has an output queue.
  2973. */
  2974. int
  2975. channel_has_queued_writes(channel_t *chan)
  2976. {
  2977. int has_writes = 0;
  2978. tor_assert(chan);
  2979. tor_assert(chan->has_queued_writes);
  2980. if (chan->outgoing_queue &&
  2981. smartlist_len(chan->outgoing_queue) > 0) {
  2982. has_writes = 1;
  2983. } else {
  2984. /* Check with the lower layer */
  2985. has_writes = chan->has_queued_writes(chan);
  2986. }
  2987. return has_writes;
  2988. }
  2989. /**
  2990. * Check the is_bad_for_new_circs flag
  2991. *
  2992. * This function returns the is_bad_for_new_circs flag of the specified
  2993. * channel.
  2994. */
  2995. int
  2996. channel_is_bad_for_new_circs(channel_t *chan)
  2997. {
  2998. tor_assert(chan);
  2999. return chan->is_bad_for_new_circs;
  3000. }
  3001. /**
  3002. * Mark a channel as bad for new circuits
  3003. *
  3004. * Set the is_bad_for_new_circs_flag on chan.
  3005. */
  3006. void
  3007. channel_mark_bad_for_new_circs(channel_t *chan)
  3008. {
  3009. tor_assert(chan);
  3010. chan->is_bad_for_new_circs = 1;
  3011. }
  3012. /**
  3013. * Get the client flag
  3014. *
  3015. * This returns the client flag of a channel, which will be set if
  3016. * command_process_create_cell() in command.c thinks this is a connection
  3017. * from a client.
  3018. */
  3019. int
  3020. channel_is_client(channel_t *chan)
  3021. {
  3022. tor_assert(chan);
  3023. return chan->is_client;
  3024. }
  3025. /**
  3026. * Set the client flag
  3027. *
  3028. * Mark a channel as being from a client
  3029. */
  3030. void
  3031. channel_mark_client(channel_t *chan)
  3032. {
  3033. tor_assert(chan);
  3034. chan->is_client = 1;
  3035. }
  3036. /**
  3037. * Get the canonical flag for a channel
  3038. *
  3039. * This returns the is_canonical for a channel; this flag is determined by
  3040. * the lower layer and can't be set in a transport-independent way.
  3041. */
  3042. int
  3043. channel_is_canonical(channel_t *chan)
  3044. {
  3045. tor_assert(chan);
  3046. tor_assert(chan->is_canonical);
  3047. return chan->is_canonical(chan, 0);
  3048. }
  3049. /**
  3050. * Test if the canonical flag is reliable
  3051. *
  3052. * This function asks if the lower layer thinks it's safe to trust the
  3053. * result of channel_is_canonical()
  3054. */
  3055. int
  3056. channel_is_canonical_is_reliable(channel_t *chan)
  3057. {
  3058. tor_assert(chan);
  3059. tor_assert(chan->is_canonical);
  3060. return chan->is_canonical(chan, 1);
  3061. }
  3062. /**
  3063. * Test incoming flag
  3064. *
  3065. * This function gets the incoming flag; this is set when a listener spawns
  3066. * a channel. If this returns true the channel was remotely initiated.
  3067. */
  3068. int
  3069. channel_is_incoming(channel_t *chan)
  3070. {
  3071. tor_assert(chan);
  3072. return chan->is_incoming;
  3073. }
  3074. /**
  3075. * Set the incoming flag
  3076. *
  3077. * This function is called when a channel arrives on a listening channel
  3078. * to mark it as incoming.
  3079. */
  3080. void
  3081. channel_mark_incoming(channel_t *chan)
  3082. {
  3083. tor_assert(chan);
  3084. chan->is_incoming = 1;
  3085. }
  3086. /**
  3087. * Test local flag
  3088. *
  3089. * This function gets the local flag; the lower layer should set this when
  3090. * setting up the channel if is_local_addr() is true for all of the
  3091. * destinations it will communicate with on behalf of this channel. It's
  3092. * used to decide whether to declare the network reachable when seeing incoming
  3093. * traffic on the channel.
  3094. */
  3095. int
  3096. channel_is_local(channel_t *chan)
  3097. {
  3098. tor_assert(chan);
  3099. return chan->is_local;
  3100. }
  3101. /**
  3102. * Set the local flag
  3103. *
  3104. * This internal-only function should be called by the lower layer if the
  3105. * channel is to a local address. See channel_is_local() above or the
  3106. * description of the is_local bit in channel.h
  3107. */
  3108. void
  3109. channel_mark_local(channel_t *chan)
  3110. {
  3111. tor_assert(chan);
  3112. chan->is_local = 1;
  3113. }
  3114. /**
  3115. * Test outgoing flag
  3116. *
  3117. * This function gets the outgoing flag; this is the inverse of the incoming
  3118. * bit set when a listener spawns a channel. If this returns true the channel
  3119. * was locally initiated.
  3120. */
  3121. int
  3122. channel_is_outgoing(channel_t *chan)
  3123. {
  3124. tor_assert(chan);
  3125. return !(chan->is_incoming);
  3126. }
  3127. /**
  3128. * Mark a channel as outgoing
  3129. *
  3130. * This function clears the incoming flag and thus marks a channel as
  3131. * outgoing.
  3132. */
  3133. void
  3134. channel_mark_outgoing(channel_t *chan)
  3135. {
  3136. tor_assert(chan);
  3137. chan->is_incoming = 0;
  3138. }
  3139. /*********************
  3140. * Timestamp updates *
  3141. ********************/
  3142. /**
  3143. * Update the created timestamp for a channel
  3144. *
  3145. * This updates the channel's created timestamp and should only be called
  3146. * from channel_init().
  3147. */
  3148. void
  3149. channel_timestamp_created(channel_t *chan)
  3150. {
  3151. time_t now = time(NULL);
  3152. tor_assert(chan);
  3153. chan->timestamp_created = now;
  3154. }
  3155. /**
  3156. * Update the created timestamp for a channel listener
  3157. *
  3158. * This updates the channel listener's created timestamp and should only be
  3159. * called from channel_init_listener().
  3160. */
  3161. void
  3162. channel_listener_timestamp_created(channel_listener_t *chan_l)
  3163. {
  3164. time_t now = time(NULL);
  3165. tor_assert(chan_l);
  3166. chan_l->timestamp_created = now;
  3167. }
  3168. /**
  3169. * Update the last active timestamp for a channel
  3170. *
  3171. * This function updates the channel's last active timestamp; it should be
  3172. * called by the lower layer whenever there is activity on the channel which
  3173. * does not lead to a cell being transmitted or received; the active timestamp
  3174. * is also updated from channel_timestamp_recv() and channel_timestamp_xmit(),
  3175. * but it should be updated for things like the v3 handshake and stuff that
  3176. * produce activity only visible to the lower layer.
  3177. */
  3178. void
  3179. channel_timestamp_active(channel_t *chan)
  3180. {
  3181. time_t now = time(NULL);
  3182. tor_assert(chan);
  3183. chan->timestamp_active = now;
  3184. }
  3185. /**
  3186. * Update the last active timestamp for a channel listener
  3187. */
  3188. void
  3189. channel_listener_timestamp_active(channel_listener_t *chan_l)
  3190. {
  3191. time_t now = time(NULL);
  3192. tor_assert(chan_l);
  3193. chan_l->timestamp_active = now;
  3194. }
  3195. /**
  3196. * Update the last accepted timestamp.
  3197. *
  3198. * This function updates the channel listener's last accepted timestamp; it
  3199. * should be called whenever a new incoming channel is accepted on a
  3200. * listener.
  3201. */
  3202. void
  3203. channel_listener_timestamp_accepted(channel_listener_t *chan_l)
  3204. {
  3205. time_t now = time(NULL);
  3206. tor_assert(chan_l);
  3207. chan_l->timestamp_active = now;
  3208. chan_l->timestamp_accepted = now;
  3209. }
  3210. /**
  3211. * Update client timestamp
  3212. *
  3213. * This function is called by relay.c to timestamp a channel that appears to
  3214. * be used as a client.
  3215. */
  3216. void
  3217. channel_timestamp_client(channel_t *chan)
  3218. {
  3219. time_t now = time(NULL);
  3220. tor_assert(chan);
  3221. chan->timestamp_client = now;
  3222. }
  3223. /**
  3224. * Update the last drained timestamp
  3225. *
  3226. * This is called whenever we transmit a cell which leaves the outgoing cell
  3227. * queue completely empty. It also updates the xmit time and the active time.
  3228. */
  3229. void
  3230. channel_timestamp_drained(channel_t *chan)
  3231. {
  3232. time_t now = time(NULL);
  3233. tor_assert(chan);
  3234. chan->timestamp_active = now;
  3235. chan->timestamp_drained = now;
  3236. chan->timestamp_xmit = now;
  3237. }
  3238. /**
  3239. * Update the recv timestamp
  3240. *
  3241. * This is called whenever we get an incoming cell from the lower layer.
  3242. * This also updates the active timestamp.
  3243. */
  3244. void
  3245. channel_timestamp_recv(channel_t *chan)
  3246. {
  3247. time_t now = time(NULL);
  3248. tor_assert(chan);
  3249. chan->timestamp_active = now;
  3250. chan->timestamp_recv = now;
  3251. }
  3252. /**
  3253. * Update the xmit timestamp
  3254. * This is called whenever we pass an outgoing cell to the lower layer. This
  3255. * also updates the active timestamp.
  3256. */
  3257. void
  3258. channel_timestamp_xmit(channel_t *chan)
  3259. {
  3260. time_t now = time(NULL);
  3261. tor_assert(chan);
  3262. chan->timestamp_active = now;
  3263. chan->timestamp_xmit = now;
  3264. }
  3265. /***************************************************************
  3266. * Timestamp queries - see above for definitions of timestamps *
  3267. **************************************************************/
  3268. /**
  3269. * Query created timestamp for a channel
  3270. */
  3271. time_t
  3272. channel_when_created(channel_t *chan)
  3273. {
  3274. tor_assert(chan);
  3275. return chan->timestamp_created;
  3276. }
  3277. /**
  3278. * Query created timestamp for a channel listener
  3279. */
  3280. time_t
  3281. channel_listener_when_created(channel_listener_t *chan_l)
  3282. {
  3283. tor_assert(chan_l);
  3284. return chan_l->timestamp_created;
  3285. }
  3286. /**
  3287. * Query last active timestamp for a channel
  3288. */
  3289. time_t
  3290. channel_when_last_active(channel_t *chan)
  3291. {
  3292. tor_assert(chan);
  3293. return chan->timestamp_active;
  3294. }
  3295. /**
  3296. * Query last active timestamp for a channel listener
  3297. */
  3298. time_t
  3299. channel_listener_when_last_active(channel_listener_t *chan_l)
  3300. {
  3301. tor_assert(chan_l);
  3302. return chan_l->timestamp_active;
  3303. }
  3304. /**
  3305. * Query last accepted timestamp for a channel listener
  3306. */
  3307. time_t
  3308. channel_listener_when_last_accepted(channel_listener_t *chan_l)
  3309. {
  3310. tor_assert(chan_l);
  3311. return chan_l->timestamp_accepted;
  3312. }
  3313. /**
  3314. * Query client timestamp
  3315. */
  3316. time_t
  3317. channel_when_last_client(channel_t *chan)
  3318. {
  3319. tor_assert(chan);
  3320. return chan->timestamp_client;
  3321. }
  3322. /**
  3323. * Query drained timestamp
  3324. */
  3325. time_t
  3326. channel_when_last_drained(channel_t *chan)
  3327. {
  3328. tor_assert(chan);
  3329. return chan->timestamp_drained;
  3330. }
  3331. /**
  3332. * Query recv timestamp
  3333. */
  3334. time_t
  3335. channel_when_last_recv(channel_t *chan)
  3336. {
  3337. tor_assert(chan);
  3338. return chan->timestamp_recv;
  3339. }
  3340. /**
  3341. * Query xmit timestamp
  3342. */
  3343. time_t
  3344. channel_when_last_xmit(channel_t *chan)
  3345. {
  3346. tor_assert(chan);
  3347. return chan->timestamp_xmit;
  3348. }
  3349. /**
  3350. * Query accepted counter
  3351. */
  3352. uint64_t
  3353. channel_listener_count_accepted(channel_listener_t *chan_l)
  3354. {
  3355. tor_assert(chan_l);
  3356. return chan_l->n_accepted;
  3357. }
  3358. /**
  3359. * Query received cell counter
  3360. */
  3361. uint64_t
  3362. channel_count_recved(channel_t *chan)
  3363. {
  3364. tor_assert(chan);
  3365. return chan->n_cells_recved;
  3366. }
  3367. /**
  3368. * Query transmitted cell counter
  3369. */
  3370. uint64_t
  3371. channel_count_xmitted(channel_t *chan)
  3372. {
  3373. tor_assert(chan);
  3374. return chan->n_cells_xmitted;
  3375. }
  3376. /**
  3377. * Check if a channel matches an extend_info_t
  3378. *
  3379. * This function calls the lower layer and asks if this channel matches a
  3380. * given extend_info_t.
  3381. */
  3382. int
  3383. channel_matches_extend_info(channel_t *chan, extend_info_t *extend_info)
  3384. {
  3385. tor_assert(chan);
  3386. tor_assert(chan->matches_extend_info);
  3387. tor_assert(extend_info);
  3388. return chan->matches_extend_info(chan, extend_info);
  3389. }
  3390. /**
  3391. * Check if a channel matches a given target address
  3392. *
  3393. * This function calls into the lower layer and asks if this channel thinks
  3394. * it matches a given target address for circuit extension purposes.
  3395. */
  3396. int
  3397. channel_matches_target_addr_for_extend(channel_t *chan,
  3398. const tor_addr_t *target)
  3399. {
  3400. tor_assert(chan);
  3401. tor_assert(chan->matches_target);
  3402. tor_assert(target);
  3403. return chan->matches_target(chan, target);
  3404. }
  3405. /**
  3406. * Return the total number of circuits used by a channel
  3407. *
  3408. * @param chan Channel to query
  3409. * @return Number of circuits using this as n_chan or p_chan
  3410. */
  3411. unsigned int
  3412. channel_num_circuits(channel_t *chan)
  3413. {
  3414. tor_assert(chan);
  3415. return chan->num_n_circuits +
  3416. chan->num_p_circuits;
  3417. }
  3418. /**
  3419. * Set up circuit ID generation
  3420. *
  3421. * This is called when setting up a channel and replaces the old
  3422. * connection_or_set_circid_type()
  3423. */
  3424. void
  3425. channel_set_circid_type(channel_t *chan, crypto_pk_t *identity_rcvd)
  3426. {
  3427. int started_here;
  3428. crypto_pk_t *our_identity;
  3429. tor_assert(chan);
  3430. started_here = channel_is_outgoing(chan);
  3431. our_identity = started_here ?
  3432. get_tlsclient_identity_key() : get_server_identity_key();
  3433. if (identity_rcvd) {
  3434. if (crypto_pk_cmp_keys(our_identity, identity_rcvd) < 0) {
  3435. chan->circ_id_type = CIRC_ID_TYPE_LOWER;
  3436. } else {
  3437. chan->circ_id_type = CIRC_ID_TYPE_HIGHER;
  3438. }
  3439. } else {
  3440. chan->circ_id_type = CIRC_ID_TYPE_NEITHER;
  3441. }
  3442. }