control.c 122 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646
  1. /* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  2. * Copyright (c) 2007, The Tor Project, Inc. */
  3. /* See LICENSE for licensing information */
  4. /* $Id$ */
  5. const char control_c_id[] =
  6. "$Id$";
  7. /**
  8. * \file control.c
  9. * \brief Implementation for Tor's control-socket interface.
  10. * See doc/spec/control-spec.txt for full details on protocol.
  11. **/
  12. #define CONTROL_PRIVATE
  13. #include "or.h"
  14. /** Yield true iff <b>s</b> is the state of a control_connection_t that has
  15. * finished authentication and is accepting commands. */
  16. #define STATE_IS_OPEN(s) ((s) == CONTROL_CONN_STATE_OPEN)
  17. /* Recognized asynchronous event types. It's okay to expand this list
  18. * because it is used both as a list of v0 event types, and as indices
  19. * into the bitfield to determine which controllers want which events.
  20. */
  21. #define _EVENT_MIN 0x0001
  22. #define EVENT_CIRCUIT_STATUS 0x0001
  23. #define EVENT_STREAM_STATUS 0x0002
  24. #define EVENT_OR_CONN_STATUS 0x0003
  25. #define EVENT_BANDWIDTH_USED 0x0004
  26. #define EVENT_LOG_OBSOLETE 0x0005 /* Can reclaim this. */
  27. #define EVENT_NEW_DESC 0x0006
  28. #define EVENT_DEBUG_MSG 0x0007
  29. #define EVENT_INFO_MSG 0x0008
  30. #define EVENT_NOTICE_MSG 0x0009
  31. #define EVENT_WARN_MSG 0x000A
  32. #define EVENT_ERR_MSG 0x000B
  33. #define EVENT_ADDRMAP 0x000C
  34. // #define EVENT_AUTHDIR_NEWDESCS 0x000D
  35. #define EVENT_DESCCHANGED 0x000E
  36. #define EVENT_NS 0x000F
  37. #define EVENT_STATUS_CLIENT 0x0010
  38. #define EVENT_STATUS_SERVER 0x0011
  39. #define EVENT_STATUS_GENERAL 0x0012
  40. #define EVENT_GUARD 0x0013
  41. #define EVENT_STREAM_BANDWIDTH_USED 0x0014
  42. #define _EVENT_MAX 0x0014
  43. /* If _EVENT_MAX ever hits 0x0020, we need to make the mask wider. */
  44. /** Bitfield: The bit 1&lt;&lt;e is set if <b>any</b> open control
  45. * connection is interested in events of type <b>e</b>. We use this
  46. * so that we can decide to skip generating event messages that nobody
  47. * has interest in without having to walk over the global connection
  48. * list to find out.
  49. **/
  50. typedef uint32_t event_mask_t;
  51. static event_mask_t global_event_mask1long = 0;
  52. static event_mask_t global_event_mask1short = 0;
  53. /** True iff we have disabled log messages from being sent to the controller */
  54. static int disable_log_messages = 0;
  55. /** Macro: true if any control connection is interested in events of type
  56. * <b>e</b>. */
  57. #define EVENT_IS_INTERESTING(e) \
  58. ((global_event_mask1long|global_event_mask1short) & (1<<(e)))
  59. #define EVENT_IS_INTERESTING1L(e) (global_event_mask1long & (1<<(e)))
  60. #define EVENT_IS_INTERESTING1S(e) (global_event_mask1short & (1<<(e)))
  61. /** If we're using cookie-type authentication, how long should our cookies be?
  62. */
  63. #define AUTHENTICATION_COOKIE_LEN 32
  64. /** If true, we've set authentication_cookie to a secret code and
  65. * stored it to disk. */
  66. static int authentication_cookie_is_set = 0;
  67. static char authentication_cookie[AUTHENTICATION_COOKIE_LEN];
  68. #define SHORT_NAMES 1
  69. #define LONG_NAMES 2
  70. #define ALL_NAMES (SHORT_NAMES|LONG_NAMES)
  71. #define EXTENDED_FORMAT 4
  72. #define NONEXTENDED_FORMAT 8
  73. #define ALL_FORMATS (EXTENDED_FORMAT|NONEXTENDED_FORMAT)
  74. typedef int event_format_t;
  75. static void connection_printf_to_buf(control_connection_t *conn,
  76. const char *format, ...)
  77. CHECK_PRINTF(2,3);
  78. static void send_control_done(control_connection_t *conn);
  79. static void send_control_event(uint16_t event, event_format_t which,
  80. const char *format, ...)
  81. CHECK_PRINTF(3,4);
  82. static void send_control_event_extended(uint16_t event, event_format_t which,
  83. const char *format, ...)
  84. CHECK_PRINTF(3,4);
  85. static int handle_control_setconf(control_connection_t *conn, uint32_t len,
  86. char *body);
  87. static int handle_control_resetconf(control_connection_t *conn, uint32_t len,
  88. char *body);
  89. static int handle_control_getconf(control_connection_t *conn, uint32_t len,
  90. const char *body);
  91. static int handle_control_setevents(control_connection_t *conn, uint32_t len,
  92. const char *body);
  93. static int handle_control_authenticate(control_connection_t *conn,
  94. uint32_t len,
  95. const char *body);
  96. static int handle_control_saveconf(control_connection_t *conn, uint32_t len,
  97. const char *body);
  98. static int handle_control_signal(control_connection_t *conn, uint32_t len,
  99. const char *body);
  100. static int handle_control_mapaddress(control_connection_t *conn, uint32_t len,
  101. const char *body);
  102. static char *list_getinfo_options(void);
  103. static int handle_control_getinfo(control_connection_t *conn, uint32_t len,
  104. const char *body);
  105. static int handle_control_extendcircuit(control_connection_t *conn,
  106. uint32_t len,
  107. const char *body);
  108. static int handle_control_setcircuitpurpose(control_connection_t *conn,
  109. uint32_t len, const char *body);
  110. static int handle_control_attachstream(control_connection_t *conn,
  111. uint32_t len,
  112. const char *body);
  113. static int handle_control_postdescriptor(control_connection_t *conn,
  114. uint32_t len,
  115. const char *body);
  116. static int handle_control_redirectstream(control_connection_t *conn,
  117. uint32_t len,
  118. const char *body);
  119. static int handle_control_closestream(control_connection_t *conn, uint32_t len,
  120. const char *body);
  121. static int handle_control_closecircuit(control_connection_t *conn,
  122. uint32_t len,
  123. const char *body);
  124. static int handle_control_resolve(control_connection_t *conn, uint32_t len,
  125. const char *body);
  126. static int handle_control_usefeature(control_connection_t *conn,
  127. uint32_t len,
  128. const char *body);
  129. static int write_stream_target_to_buf(edge_connection_t *conn, char *buf,
  130. size_t len);
  131. static void orconn_target_get_name(int long_names, char *buf, size_t len,
  132. or_connection_t *conn);
  133. static char *get_cookie_file(void);
  134. /** Given a control event code for a message event, return the corresponding
  135. * log severity. */
  136. static INLINE int
  137. event_to_log_severity(int event)
  138. {
  139. switch (event) {
  140. case EVENT_DEBUG_MSG: return LOG_DEBUG;
  141. case EVENT_INFO_MSG: return LOG_INFO;
  142. case EVENT_NOTICE_MSG: return LOG_NOTICE;
  143. case EVENT_WARN_MSG: return LOG_WARN;
  144. case EVENT_ERR_MSG: return LOG_ERR;
  145. default: return -1;
  146. }
  147. }
  148. /** Given a log severity, return the corresponding control event code. */
  149. static INLINE int
  150. log_severity_to_event(int severity)
  151. {
  152. switch (severity) {
  153. case LOG_DEBUG: return EVENT_DEBUG_MSG;
  154. case LOG_INFO: return EVENT_INFO_MSG;
  155. case LOG_NOTICE: return EVENT_NOTICE_MSG;
  156. case LOG_WARN: return EVENT_WARN_MSG;
  157. case LOG_ERR: return EVENT_ERR_MSG;
  158. default: return -1;
  159. }
  160. }
  161. /** Set <b>global_event_mask*</b> to the bitwise OR of each live control
  162. * connection's event_mask field. */
  163. void
  164. control_update_global_event_mask(void)
  165. {
  166. smartlist_t *conns = get_connection_array();
  167. event_mask_t old_mask, new_mask;
  168. old_mask = global_event_mask1short;
  169. old_mask |= global_event_mask1long;
  170. global_event_mask1short = 0;
  171. global_event_mask1long = 0;
  172. SMARTLIST_FOREACH(conns, connection_t *, _conn,
  173. {
  174. if (_conn->type == CONN_TYPE_CONTROL &&
  175. STATE_IS_OPEN(_conn->state)) {
  176. control_connection_t *conn = TO_CONTROL_CONN(_conn);
  177. if (conn->use_long_names)
  178. global_event_mask1long |= conn->event_mask;
  179. else
  180. global_event_mask1short |= conn->event_mask;
  181. }
  182. });
  183. new_mask = global_event_mask1short;
  184. new_mask |= global_event_mask1long;
  185. /* Handle the aftermath. Set up the log callback to tell us only what
  186. * we want to hear...*/
  187. control_adjust_event_log_severity();
  188. /* ...then, if we've started logging stream bw, clear the appropriate
  189. * fields. */
  190. if (! (old_mask & EVENT_STREAM_BANDWIDTH_USED) &&
  191. (new_mask & EVENT_STREAM_BANDWIDTH_USED)) {
  192. SMARTLIST_FOREACH(conns, connection_t *, conn,
  193. {
  194. if (conn->type == CONN_TYPE_AP) {
  195. edge_connection_t *edge_conn = TO_EDGE_CONN(conn);
  196. edge_conn->n_written = edge_conn->n_read = 0;
  197. }
  198. });
  199. }
  200. }
  201. /** Adjust the log severities that result in control_event_logmsg being called
  202. * to match the severity of log messages that any controllers are interested
  203. * in. */
  204. void
  205. control_adjust_event_log_severity(void)
  206. {
  207. int i;
  208. int min_log_event=EVENT_ERR_MSG, max_log_event=EVENT_DEBUG_MSG;
  209. for (i = EVENT_DEBUG_MSG; i <= EVENT_ERR_MSG; ++i) {
  210. if (EVENT_IS_INTERESTING(i)) {
  211. min_log_event = i;
  212. break;
  213. }
  214. }
  215. for (i = EVENT_ERR_MSG; i >= EVENT_DEBUG_MSG; --i) {
  216. if (EVENT_IS_INTERESTING(i)) {
  217. max_log_event = i;
  218. break;
  219. }
  220. }
  221. if (EVENT_IS_INTERESTING(EVENT_LOG_OBSOLETE) ||
  222. EVENT_IS_INTERESTING(EVENT_STATUS_GENERAL)) {
  223. if (min_log_event > EVENT_NOTICE_MSG)
  224. min_log_event = EVENT_NOTICE_MSG;
  225. if (max_log_event < EVENT_ERR_MSG)
  226. max_log_event = EVENT_ERR_MSG;
  227. }
  228. change_callback_log_severity(event_to_log_severity(min_log_event),
  229. event_to_log_severity(max_log_event),
  230. control_event_logmsg);
  231. }
  232. /** Return true iff the event with code <b>c</b> is being sent to any current
  233. * control connection. This is useful if the amount of work needed to prepare
  234. * to call the appropriate control_event_...() function is high.
  235. */
  236. int
  237. control_event_is_interesting(int event)
  238. {
  239. return EVENT_IS_INTERESTING(event);
  240. }
  241. /** Append a NUL-terminated string <b>s</b> to the end of
  242. * <b>conn</b>-\>outbuf.
  243. */
  244. static INLINE void
  245. connection_write_str_to_buf(const char *s, control_connection_t *conn)
  246. {
  247. size_t len = strlen(s);
  248. connection_write_to_buf(s, len, TO_CONN(conn));
  249. }
  250. /** Given a <b>len</b>-character string in <b>data</b>, made of lines
  251. * terminated by CRLF, allocate a new string in *<b>out</b>, and copy the
  252. * contents of <b>data</b> into *<b>out</b>, adding a period before any period
  253. * that that appears at the start of a line, and adding a period-CRLF line at
  254. * the end. Replace all LF characters sequences with CRLF. Return the number
  255. * of bytes in *<b>out</b>.
  256. */
  257. /* static */ size_t
  258. write_escaped_data(const char *data, size_t len, char **out)
  259. {
  260. size_t sz_out = len+8;
  261. char *outp;
  262. const char *start = data, *end;
  263. int i;
  264. int start_of_line;
  265. for (i=0; i<(int)len; ++i) {
  266. if (data[i]== '\n')
  267. sz_out += 2; /* Maybe add a CR; maybe add a dot. */
  268. }
  269. *out = outp = tor_malloc(sz_out+1);
  270. end = data+len;
  271. start_of_line = 1;
  272. while (data < end) {
  273. if (*data == '\n') {
  274. if (data > start && data[-1] != '\r')
  275. *outp++ = '\r';
  276. start_of_line = 1;
  277. } else if (*data == '.') {
  278. if (start_of_line) {
  279. start_of_line = 0;
  280. *outp++ = '.';
  281. }
  282. } else {
  283. start_of_line = 0;
  284. }
  285. *outp++ = *data++;
  286. }
  287. if (outp < *out+2 || memcmp(outp-2, "\r\n", 2)) {
  288. *outp++ = '\r';
  289. *outp++ = '\n';
  290. }
  291. *outp++ = '.';
  292. *outp++ = '\r';
  293. *outp++ = '\n';
  294. *outp = '\0'; /* NUL-terminate just in case. */
  295. tor_assert((outp - *out) <= (int)sz_out);
  296. return outp - *out;
  297. }
  298. /** Given a <b>len</b>-character string in <b>data</b>, made of lines
  299. * terminated by CRLF, allocate a new string in *<b>out</b>, and copy
  300. * the contents of <b>data</b> into *<b>out</b>, removing any period
  301. * that appears at the start of a line, and replacing all CRLF sequences
  302. * with LF. Return the number of
  303. * bytes in *<b>out</b>. */
  304. /* static */ size_t
  305. read_escaped_data(const char *data, size_t len, char **out)
  306. {
  307. char *outp;
  308. const char *next;
  309. const char *end;
  310. *out = outp = tor_malloc(len+1);
  311. end = data+len;
  312. while (data < end) {
  313. /* we're at the start of a line. */
  314. if (*data == '.')
  315. ++data;
  316. next = memchr(data, '\n', end-data);
  317. if (next) {
  318. size_t n_to_copy = next-data;
  319. /* Don't copy a CR that precedes this LF. */
  320. if (n_to_copy && *(next-1) == '\r')
  321. --n_to_copy;
  322. memcpy(outp, data, n_to_copy);
  323. outp += n_to_copy;
  324. data = next+1; /* This will point at the start of the next line,
  325. * or the end of the string, or a period. */
  326. } else {
  327. memcpy(outp, data, end-data);
  328. outp += (end-data);
  329. *outp = '\0';
  330. return outp - *out;
  331. }
  332. *outp++ = '\n';
  333. }
  334. *outp = '\0';
  335. return outp - *out;
  336. }
  337. /** Given a pointer to a string starting at <b>start</b> containing
  338. * <b>in_len_max</b> characters, decode a string beginning with one double
  339. * quote, containing any number of non-quote characters or characters escaped
  340. * with a backslash, and ending with a final double quote. Place the resulting
  341. * string (unquoted, unescaped) into a newly allocated string in *<b>out</b>;
  342. * store its length in <b>out_len</b>. On success, return a pointer to the
  343. * character immediately following the escaped string. On failure, return
  344. * NULL. */
  345. static const char *
  346. get_escaped_string(const char *start, size_t in_len_max,
  347. char **out, size_t *out_len)
  348. {
  349. const char *cp, *end;
  350. char *outp;
  351. size_t len=0;
  352. if (*start != '\"')
  353. return NULL;
  354. cp = start+1;
  355. end = start+in_len_max;
  356. /* Calculate length. */
  357. while (1) {
  358. if (cp >= end)
  359. return NULL;
  360. else if (*cp == '\\') {
  361. if (++cp == end)
  362. return NULL; /* Can't escape EOS. */
  363. ++cp;
  364. ++len;
  365. } else if (*cp == '\"') {
  366. break;
  367. } else {
  368. ++cp;
  369. ++len;
  370. }
  371. }
  372. end = cp;
  373. outp = *out = tor_malloc(len+1);
  374. *out_len = len;
  375. cp = start+1;
  376. while (cp < end) {
  377. if (*cp == '\\')
  378. ++cp;
  379. *outp++ = *cp++;
  380. }
  381. *outp = '\0';
  382. tor_assert((outp - *out) == (int)*out_len);
  383. return end+1;
  384. }
  385. /** Acts like sprintf, but writes its formatted string to the end of
  386. * <b>conn</b>-\>outbuf. The message may be truncated if it is too long,
  387. * but it will always end with a CRLF sequence.
  388. *
  389. * Currently the length of the message is limited to 1024 (including the
  390. * ending \r\n\0. */
  391. static void
  392. connection_printf_to_buf(control_connection_t *conn, const char *format, ...)
  393. {
  394. #define CONNECTION_PRINTF_TO_BUF_BUFFERSIZE 1024
  395. va_list ap;
  396. char buf[CONNECTION_PRINTF_TO_BUF_BUFFERSIZE];
  397. int r;
  398. size_t len;
  399. va_start(ap,format);
  400. r = tor_vsnprintf(buf, sizeof(buf), format, ap);
  401. va_end(ap);
  402. if (r<0) {
  403. log_warn(LD_BUG, "Unable to format string for controller.");
  404. return;
  405. }
  406. len = strlen(buf);
  407. if (memcmp("\r\n\0", buf+len-2, 3)) {
  408. buf[CONNECTION_PRINTF_TO_BUF_BUFFERSIZE-1] = '\0';
  409. buf[CONNECTION_PRINTF_TO_BUF_BUFFERSIZE-2] = '\n';
  410. buf[CONNECTION_PRINTF_TO_BUF_BUFFERSIZE-3] = '\r';
  411. }
  412. connection_write_to_buf(buf, len, TO_CONN(conn));
  413. }
  414. /** Send a "DONE" message down the control connection <b>conn</b>. */
  415. static void
  416. send_control_done(control_connection_t *conn)
  417. {
  418. connection_write_str_to_buf("250 OK\r\n", conn);
  419. }
  420. /* Send an event to all v1 controllers that are listening for code
  421. * <b>event</b>. The event's body is given by <b>msg</b>.
  422. *
  423. * If <b>which</b> & SHORT_NAMES, the event contains short-format names: send
  424. * it to controllers that haven't enabled the VERBOSE_NAMES feature. If
  425. * <b>which</b> & LONG_NAMES, the event contains long-format names: send it
  426. * to contollers that <em>have</em> enabled VERBOSE_NAMES.
  427. *
  428. * The EXTENDED_FORMAT and NONEXTENDED_FORMAT flags behave similarly with
  429. * respect to the EXTENDED_EVENTS feature. */
  430. static void
  431. send_control_event_string(uint16_t event, event_format_t which,
  432. const char *msg)
  433. {
  434. smartlist_t *conns = get_connection_array();
  435. tor_assert(event >= _EVENT_MIN && event <= _EVENT_MAX);
  436. SMARTLIST_FOREACH(conns, connection_t *, conn,
  437. {
  438. if (conn->type == CONN_TYPE_CONTROL &&
  439. !conn->marked_for_close &&
  440. conn->state == CONTROL_CONN_STATE_OPEN) {
  441. control_connection_t *control_conn = TO_CONTROL_CONN(conn);
  442. if (control_conn->use_long_names) {
  443. if (!(which & LONG_NAMES))
  444. continue;
  445. } else {
  446. if (!(which & SHORT_NAMES))
  447. continue;
  448. }
  449. if (control_conn->use_extended_events) {
  450. if (!(which & EXTENDED_FORMAT))
  451. continue;
  452. } else {
  453. if (!(which & NONEXTENDED_FORMAT))
  454. continue;
  455. }
  456. if (control_conn->event_mask & (1<<event)) {
  457. int is_err = 0;
  458. connection_write_to_buf(msg, strlen(msg), TO_CONN(control_conn));
  459. if (event == EVENT_ERR_MSG)
  460. is_err = 1;
  461. else if (event == EVENT_STATUS_GENERAL)
  462. is_err = !strcmpstart(msg, "STATUS_GENERAL ERR ");
  463. else if (event == EVENT_STATUS_CLIENT)
  464. is_err = !strcmpstart(msg, "STATUS_CLIENT ERR ");
  465. else if (event == EVENT_STATUS_SERVER)
  466. is_err = !strcmpstart(msg, "STATUS_SERVER ERR ");
  467. if (is_err)
  468. connection_handle_write(TO_CONN(control_conn), 1);
  469. }
  470. }
  471. });
  472. }
  473. /** Helper for send_control1_event and send_control1_event_extended:
  474. * Send an event to all v1 controllers that are listening for code
  475. * <b>event</b>. The event's body is created by the printf-style format in
  476. * <b>format</b>, and other arguments as provided.
  477. *
  478. * If <b>extended</b> is true, and the format contains a single '@' character,
  479. * it will be replaced with a space and all text after that character will be
  480. * sent only to controllers that have enabled extended events.
  481. *
  482. * Currently the length of the message is limited to 1024 (including the
  483. * ending \n\r\0). */
  484. static void
  485. send_control_event_impl(uint16_t event, event_format_t which, int extended,
  486. const char *format, va_list ap)
  487. {
  488. /* This is just a little longer than the longest allowed log message */
  489. #define SEND_CONTROL1_EVENT_BUFFERSIZE 10064
  490. int r;
  491. char buf[SEND_CONTROL1_EVENT_BUFFERSIZE];
  492. size_t len;
  493. char *cp;
  494. r = tor_vsnprintf(buf, sizeof(buf), format, ap);
  495. if (r<0) {
  496. log_warn(LD_BUG, "Unable to format event for controller.");
  497. return;
  498. }
  499. len = strlen(buf);
  500. if (memcmp("\r\n\0", buf+len-2, 3)) {
  501. /* if it is not properly terminated, do it now */
  502. buf[SEND_CONTROL1_EVENT_BUFFERSIZE-1] = '\0';
  503. buf[SEND_CONTROL1_EVENT_BUFFERSIZE-2] = '\n';
  504. buf[SEND_CONTROL1_EVENT_BUFFERSIZE-3] = '\r';
  505. }
  506. if (extended && (cp = strchr(buf, '@'))) {
  507. which &= ~ALL_FORMATS;
  508. *cp = ' ';
  509. send_control_event_string(event, which|EXTENDED_FORMAT, buf);
  510. memcpy(cp, "\r\n\0", 3);
  511. send_control_event_string(event, which|NONEXTENDED_FORMAT, buf);
  512. } else {
  513. send_control_event_string(event, which|ALL_FORMATS, buf);
  514. }
  515. }
  516. /* Send an event to all v1 controllers that are listening for code
  517. * <b>event</b>. The event's body is created by the printf-style format in
  518. * <b>format</b>, and other arguments as provided.
  519. *
  520. * Currently the length of the message is limited to 1024 (including the
  521. * ending \n\r\0. */
  522. static void
  523. send_control_event(uint16_t event, event_format_t which,
  524. const char *format, ...)
  525. {
  526. va_list ap;
  527. va_start(ap, format);
  528. send_control_event_impl(event, which, 0, format, ap);
  529. va_end(ap);
  530. }
  531. /* Send an event to all v1 controllers that are listening for code
  532. * <b>event</b>. The event's body is created by the printf-style format in
  533. * <b>format</b>, and other arguments as provided.
  534. *
  535. * If the format contains a single '@' character, it will be replaced with a
  536. * space and all text after that character will be sent only to controllers
  537. * that have enabled extended events.
  538. *
  539. * Currently the length of the message is limited to 1024 (including the
  540. * ending \n\r\0. */
  541. static void
  542. send_control_event_extended(uint16_t event, event_format_t which,
  543. const char *format, ...)
  544. {
  545. va_list ap;
  546. va_start(ap, format);
  547. send_control_event_impl(event, which, 1, format, ap);
  548. va_end(ap);
  549. }
  550. /** Given a text circuit <b>id</b>, return the corresponding circuit. */
  551. static origin_circuit_t *
  552. get_circ(const char *id)
  553. {
  554. unsigned long n_id;
  555. int ok;
  556. n_id = tor_parse_ulong(id, 10, 0, ULONG_MAX, &ok, NULL);
  557. if (!ok)
  558. return NULL;
  559. return circuit_get_by_global_id(n_id);
  560. }
  561. /** Given a text stream <b>id</b>, return the corresponding AP connection. */
  562. static edge_connection_t *
  563. get_stream(const char *id)
  564. {
  565. unsigned long n_id;
  566. int ok;
  567. edge_connection_t *conn;
  568. n_id = tor_parse_ulong(id, 10, 0, ULONG_MAX, &ok, NULL);
  569. if (!ok)
  570. return NULL;
  571. conn = connection_get_by_global_id(n_id);
  572. if (!conn || conn->_base.type != CONN_TYPE_AP)
  573. return NULL;
  574. return conn;
  575. }
  576. /** Helper for setconf and resetconf. Acts like setconf, except
  577. * it passes <b>use_defaults</b> on to options_trial_assign(). Modifies the
  578. * contents of body.
  579. */
  580. static int
  581. control_setconf_helper(control_connection_t *conn, uint32_t len, char *body,
  582. int use_defaults)
  583. {
  584. int r;
  585. config_line_t *lines=NULL;
  586. char *start = body;
  587. char *errstring = NULL;
  588. const int clear_first = 1;
  589. char *config;
  590. smartlist_t *entries = smartlist_create();
  591. /* We have a string, "body", of the format '(key(=val|="val")?)' entries
  592. * separated by space. break it into a list of configuration entries. */
  593. while (*body) {
  594. char *eq = body;
  595. char *key;
  596. char *entry;
  597. while (!TOR_ISSPACE(*eq) && *eq != '=')
  598. ++eq;
  599. key = tor_strndup(body, eq-body);
  600. body = eq+1;
  601. if (*eq == '=') {
  602. char *val;
  603. size_t val_len;
  604. size_t ent_len;
  605. if (*body != '\"') {
  606. char *val_start = body;
  607. while (!TOR_ISSPACE(*body))
  608. body++;
  609. val = tor_strndup(val_start, body-val_start);
  610. val_len = strlen(val);
  611. } else {
  612. body = (char*)get_escaped_string(body, (len - (body-start)),
  613. &val, &val_len);
  614. if (!body) {
  615. connection_write_str_to_buf("551 Couldn't parse string\r\n", conn);
  616. SMARTLIST_FOREACH(entries, char *, cp, tor_free(cp));
  617. smartlist_free(entries);
  618. return 0;
  619. }
  620. }
  621. ent_len = strlen(key)+val_len+3;
  622. entry = tor_malloc(ent_len+1);
  623. tor_snprintf(entry, ent_len, "%s %s", key, val);
  624. tor_free(key);
  625. tor_free(val);
  626. } else {
  627. entry = key;
  628. }
  629. smartlist_add(entries, entry);
  630. while (TOR_ISSPACE(*body))
  631. ++body;
  632. }
  633. smartlist_add(entries, tor_strdup(""));
  634. config = smartlist_join_strings(entries, "\n", 0, NULL);
  635. SMARTLIST_FOREACH(entries, char *, cp, tor_free(cp));
  636. smartlist_free(entries);
  637. if (config_get_lines(config, &lines) < 0) {
  638. log_warn(LD_CONTROL,"Controller gave us config lines we can't parse.");
  639. connection_write_str_to_buf("551 Couldn't parse configuration\r\n",
  640. conn);
  641. tor_free(config);
  642. return 0;
  643. }
  644. tor_free(config);
  645. if ((r=options_trial_assign(lines, use_defaults,
  646. clear_first, &errstring)) < 0) {
  647. const char *msg;
  648. log_warn(LD_CONTROL,
  649. "Controller gave us config lines that didn't validate: %s",
  650. errstring);
  651. switch (r) {
  652. case -1:
  653. msg = "552 Unrecognized option";
  654. break;
  655. case -2:
  656. msg = "513 Unacceptable option value";
  657. break;
  658. case -3:
  659. msg = "553 Transition not allowed";
  660. break;
  661. case -4:
  662. default:
  663. msg = "553 Unable to set option";
  664. break;
  665. }
  666. connection_printf_to_buf(conn, "%s: %s\r\n", msg, errstring);
  667. config_free_lines(lines);
  668. tor_free(errstring);
  669. return 0;
  670. }
  671. config_free_lines(lines);
  672. send_control_done(conn);
  673. return 0;
  674. }
  675. /** Called when we receive a SETCONF message: parse the body and try
  676. * to update our configuration. Reply with a DONE or ERROR message.
  677. * Modifies the contents of body.*/
  678. static int
  679. handle_control_setconf(control_connection_t *conn, uint32_t len, char *body)
  680. {
  681. return control_setconf_helper(conn, len, body, 0);
  682. }
  683. /** Called when we receive a RESETCONF message: parse the body and try
  684. * to update our configuration. Reply with a DONE or ERROR message.
  685. * Modifies the contents of body. */
  686. static int
  687. handle_control_resetconf(control_connection_t *conn, uint32_t len, char *body)
  688. {
  689. return control_setconf_helper(conn, len, body, 1);
  690. }
  691. /** Called when we receive a GETCONF message. Parse the request, and
  692. * reply with a CONFVALUE or an ERROR message */
  693. static int
  694. handle_control_getconf(control_connection_t *conn, uint32_t body_len,
  695. const char *body)
  696. {
  697. smartlist_t *questions = NULL;
  698. smartlist_t *answers = NULL;
  699. smartlist_t *unrecognized = NULL;
  700. char *msg = NULL;
  701. size_t msg_len;
  702. or_options_t *options = get_options();
  703. int i, len;
  704. questions = smartlist_create();
  705. (void) body_len; /* body is nul-terminated; so we can ignore len. */
  706. smartlist_split_string(questions, body, " ",
  707. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  708. answers = smartlist_create();
  709. unrecognized = smartlist_create();
  710. SMARTLIST_FOREACH(questions, char *, q,
  711. {
  712. if (!option_is_recognized(q)) {
  713. smartlist_add(unrecognized, q);
  714. } else {
  715. config_line_t *answer = option_get_assignment(options,q);
  716. if (!answer) {
  717. const char *name = option_get_canonical_name(q);
  718. size_t alen = strlen(name)+8;
  719. char *astr = tor_malloc(alen);
  720. tor_snprintf(astr, alen, "250-%s\r\n", name);
  721. smartlist_add(answers, astr);
  722. }
  723. while (answer) {
  724. config_line_t *next;
  725. size_t alen = strlen(answer->key)+strlen(answer->value)+8;
  726. char *astr = tor_malloc(alen);
  727. tor_snprintf(astr, alen, "250-%s=%s\r\n",
  728. answer->key, answer->value);
  729. smartlist_add(answers, astr);
  730. next = answer->next;
  731. tor_free(answer->key);
  732. tor_free(answer->value);
  733. tor_free(answer);
  734. answer = next;
  735. }
  736. }
  737. });
  738. if ((len = smartlist_len(unrecognized))) {
  739. for (i=0; i < len-1; ++i)
  740. connection_printf_to_buf(conn,
  741. "552-Unrecognized configuration key \"%s\"\r\n",
  742. (char*)smartlist_get(unrecognized, i));
  743. connection_printf_to_buf(conn,
  744. "552 Unrecognized configuration key \"%s\"\r\n",
  745. (char*)smartlist_get(unrecognized, len-1));
  746. } else if ((len = smartlist_len(answers))) {
  747. char *tmp = smartlist_get(answers, len-1);
  748. tor_assert(strlen(tmp)>4);
  749. tmp[3] = ' ';
  750. msg = smartlist_join_strings(answers, "", 0, &msg_len);
  751. connection_write_to_buf(msg, msg_len, TO_CONN(conn));
  752. } else {
  753. connection_write_str_to_buf("250 OK\r\n", conn);
  754. }
  755. if (answers) {
  756. SMARTLIST_FOREACH(answers, char *, cp, tor_free(cp));
  757. smartlist_free(answers);
  758. }
  759. if (questions) {
  760. SMARTLIST_FOREACH(questions, char *, cp, tor_free(cp));
  761. smartlist_free(questions);
  762. }
  763. smartlist_free(unrecognized);
  764. tor_free(msg);
  765. return 0;
  766. }
  767. /** Called when we get a SETEVENTS message: update conn->event_mask,
  768. * and reply with DONE or ERROR. */
  769. static int
  770. handle_control_setevents(control_connection_t *conn, uint32_t len,
  771. const char *body)
  772. {
  773. uint16_t event_code;
  774. uint32_t event_mask = 0;
  775. unsigned int extended = 0;
  776. smartlist_t *events = smartlist_create();
  777. (void) len;
  778. smartlist_split_string(events, body, " ",
  779. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  780. SMARTLIST_FOREACH(events, const char *, ev,
  781. {
  782. if (!strcasecmp(ev, "EXTENDED")) {
  783. extended = 1;
  784. continue;
  785. } else if (!strcasecmp(ev, "CIRC"))
  786. event_code = EVENT_CIRCUIT_STATUS;
  787. else if (!strcasecmp(ev, "STREAM"))
  788. event_code = EVENT_STREAM_STATUS;
  789. else if (!strcasecmp(ev, "ORCONN"))
  790. event_code = EVENT_OR_CONN_STATUS;
  791. else if (!strcasecmp(ev, "BW"))
  792. event_code = EVENT_BANDWIDTH_USED;
  793. else if (!strcasecmp(ev, "DEBUG"))
  794. event_code = EVENT_DEBUG_MSG;
  795. else if (!strcasecmp(ev, "INFO"))
  796. event_code = EVENT_INFO_MSG;
  797. else if (!strcasecmp(ev, "NOTICE"))
  798. event_code = EVENT_NOTICE_MSG;
  799. else if (!strcasecmp(ev, "WARN"))
  800. event_code = EVENT_WARN_MSG;
  801. else if (!strcasecmp(ev, "ERR"))
  802. event_code = EVENT_ERR_MSG;
  803. else if (!strcasecmp(ev, "NEWDESC"))
  804. event_code = EVENT_NEW_DESC;
  805. else if (!strcasecmp(ev, "ADDRMAP"))
  806. event_code = EVENT_ADDRMAP;
  807. else if (!strcasecmp(ev, "AUTHDIR_NEWDESCS"))
  808. event_code = EVENT_AUTHDIR_NEWDESCS;
  809. else if (!strcasecmp(ev, "DESCCHANGED"))
  810. event_code = EVENT_DESCCHANGED;
  811. else if (!strcasecmp(ev, "NS"))
  812. event_code = EVENT_NS;
  813. else if (!strcasecmp(ev, "STATUS_GENERAL"))
  814. event_code = EVENT_STATUS_GENERAL;
  815. else if (!strcasecmp(ev, "STATUS_CLIENT"))
  816. event_code = EVENT_STATUS_CLIENT;
  817. else if (!strcasecmp(ev, "STATUS_SERVER"))
  818. event_code = EVENT_STATUS_SERVER;
  819. else if (!strcasecmp(ev, "GUARD"))
  820. event_code = EVENT_GUARD;
  821. else if (!strcasecmp(ev, "GUARDS")) {
  822. /* XXXX021 This check is here to tolerate the controllers that
  823. * depended on the buggy spec in 0.1.2.5-alpha through 0.1.2.10-rc.
  824. * Once those versions are obsolete, stop supporting this. */
  825. log_warn(LD_CONTROL, "Controller used obsolete 'GUARDS' event name; "
  826. "use GUARD instead.");
  827. event_code = EVENT_GUARD;
  828. } else if (!strcasecmp(ev, "STREAM_BW"))
  829. event_code = EVENT_STREAM_BANDWIDTH_USED;
  830. else {
  831. connection_printf_to_buf(conn, "552 Unrecognized event \"%s\"\r\n",
  832. ev);
  833. SMARTLIST_FOREACH(events, char *, e, tor_free(e));
  834. smartlist_free(events);
  835. return 0;
  836. }
  837. event_mask |= (1 << event_code);
  838. });
  839. SMARTLIST_FOREACH(events, char *, e, tor_free(e));
  840. smartlist_free(events);
  841. conn->event_mask = event_mask;
  842. if (extended)
  843. conn->use_extended_events = 1;
  844. control_update_global_event_mask();
  845. send_control_done(conn);
  846. return 0;
  847. }
  848. /** Decode the hashed, base64'd passwords stored in <b>passwords</b>.
  849. * Return a smartlist of acceptable passwords (unterminated strings of
  850. * length S2K_SPECIFIER_LEN+DIGEST_LEN) on success, or NULL on failure.
  851. */
  852. smartlist_t *
  853. decode_hashed_passwords(config_line_t *passwords)
  854. {
  855. char decoded[64];
  856. config_line_t *cl;
  857. smartlist_t *sl = smartlist_create();
  858. tor_assert(passwords);
  859. for (cl = passwords; cl; cl = cl->next) {
  860. const char *hashed = cl->value;
  861. if (!strcmpstart(hashed, "16:")) {
  862. if (base16_decode(decoded, sizeof(decoded), hashed+3, strlen(hashed+3))<0
  863. || strlen(hashed+3) != (S2K_SPECIFIER_LEN+DIGEST_LEN)*2) {
  864. goto err;
  865. }
  866. } else {
  867. if (base64_decode(decoded, sizeof(decoded), hashed, strlen(hashed))
  868. != S2K_SPECIFIER_LEN+DIGEST_LEN) {
  869. goto err;
  870. }
  871. }
  872. smartlist_add(sl, tor_memdup(decoded, S2K_SPECIFIER_LEN+DIGEST_LEN));
  873. }
  874. return sl;
  875. err:
  876. SMARTLIST_FOREACH(sl, char*, cp, tor_free(cp));
  877. smartlist_free(sl);
  878. return NULL;
  879. }
  880. /** Called when we get an AUTHENTICATE message. Check whether the
  881. * authentication is valid, and if so, update the connection's state to
  882. * OPEN. Reply with DONE or ERROR.
  883. */
  884. static int
  885. handle_control_authenticate(control_connection_t *conn, uint32_t len,
  886. const char *body)
  887. {
  888. int used_quoted_string = 0;
  889. or_options_t *options = get_options();
  890. const char *errstr = NULL;
  891. char *password;
  892. size_t password_len;
  893. const char *cp;
  894. int i;
  895. int bad_cookie=0, bad_password=0;
  896. smartlist_t *sl = NULL;
  897. if (TOR_ISXDIGIT(body[0])) {
  898. cp = body;
  899. while (TOR_ISXDIGIT(*cp))
  900. ++cp;
  901. i = cp - body;
  902. tor_assert(i>0);
  903. password_len = i/2;
  904. password = tor_malloc(password_len + 1);
  905. if (base16_decode(password, password_len+1, body, i)<0) {
  906. connection_write_str_to_buf(
  907. "551 Invalid hexadecimal encoding. Maybe you tried a plain text "
  908. "password? If so, the standard requires that you put it in "
  909. "double quotes.\r\n", conn);
  910. connection_mark_for_close(TO_CONN(conn));
  911. tor_free(password);
  912. return 0;
  913. }
  914. } else if (TOR_ISSPACE(body[0])) {
  915. password = tor_strdup("");
  916. password_len = 0;
  917. } else {
  918. if (!get_escaped_string(body, len, &password, &password_len)) {
  919. connection_write_str_to_buf("551 Invalid quoted string. You need "
  920. "to put the password in double quotes.\r\n", conn);
  921. connection_mark_for_close(TO_CONN(conn));
  922. return 0;
  923. }
  924. used_quoted_string = 1;
  925. }
  926. if (!options->CookieAuthentication && !options->HashedControlPassword) {
  927. /* if Tor doesn't demand any stronger authentication, then
  928. * the controller can get in with anything. */
  929. goto ok;
  930. }
  931. if (options->CookieAuthentication) {
  932. int also_password = options->HashedControlPassword != NULL;
  933. if (password_len != AUTHENTICATION_COOKIE_LEN) {
  934. if (!also_password) {
  935. log_warn(LD_CONTROL, "Got authentication cookie with wrong length "
  936. "(%d)", (int)password_len);
  937. errstr = "Wrong length on authentication cookie.";
  938. goto err;
  939. }
  940. bad_cookie = 1;
  941. } else if (memcmp(authentication_cookie, password, password_len)) {
  942. if (!also_password) {
  943. log_warn(LD_CONTROL, "Got mismatched authentication cookie");
  944. errstr = "Authentication cookie did not match expected value.";
  945. goto err;
  946. }
  947. bad_cookie = 1;
  948. } else {
  949. goto ok;
  950. }
  951. }
  952. if (options->HashedControlPassword) {
  953. char received[DIGEST_LEN];
  954. int also_cookie = options->CookieAuthentication;
  955. sl = decode_hashed_passwords(options->HashedControlPassword);
  956. if (!sl) {
  957. if (!also_cookie) {
  958. log_warn(LD_CONTROL,
  959. "Couldn't decode HashedControlPassword: invalid base16");
  960. errstr="Couldn't decode HashedControlPassword value in configuration.";
  961. }
  962. bad_password = 1;
  963. } else {
  964. SMARTLIST_FOREACH(sl, char *, expected,
  965. {
  966. secret_to_key(received,DIGEST_LEN,password,password_len,expected);
  967. if (!memcmp(expected+S2K_SPECIFIER_LEN, received, DIGEST_LEN))
  968. goto ok;
  969. });
  970. SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  971. smartlist_free(sl);
  972. if (used_quoted_string)
  973. errstr = "Password did not match HashedControlPassword value from "
  974. "configuration";
  975. else
  976. errstr = "Password did not match HashedControlPassword value from "
  977. "configuration. Maybe you tried a plain text password? "
  978. "If so, the standard requires that you put it in double quotes.";
  979. bad_password = 1;
  980. if (!also_cookie)
  981. goto err;
  982. }
  983. }
  984. /** We only get here if both kinds of authentication failed. */
  985. tor_assert(bad_password && bad_cookie);
  986. log_warn(LD_CONTROL, "Bad password or authentication cookie on controller.");
  987. errstr = "Password did not match HashedControlPassword *or* authentication "
  988. "cookie.";
  989. err:
  990. tor_free(password);
  991. if (!errstr)
  992. errstr = "Unknown reason.";
  993. connection_printf_to_buf(conn, "515 Authentication failed: %s\r\n",
  994. errstr);
  995. connection_mark_for_close(TO_CONN(conn));
  996. return 0;
  997. ok:
  998. log_info(LD_CONTROL, "Authenticated control connection (%d)", conn->_base.s);
  999. send_control_done(conn);
  1000. conn->_base.state = CONTROL_CONN_STATE_OPEN;
  1001. tor_free(password);
  1002. if (sl) { /* clean up */
  1003. SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1004. smartlist_free(sl);
  1005. }
  1006. return 0;
  1007. }
  1008. /** Called when we get a SAVECONF command. Try to flush the current options to
  1009. * disk, and report success or failure. */
  1010. static int
  1011. handle_control_saveconf(control_connection_t *conn, uint32_t len,
  1012. const char *body)
  1013. {
  1014. (void) len;
  1015. (void) body;
  1016. if (options_save_current()<0) {
  1017. connection_write_str_to_buf(
  1018. "551 Unable to write configuration to disk.\r\n", conn);
  1019. } else {
  1020. send_control_done(conn);
  1021. }
  1022. return 0;
  1023. }
  1024. /** Called when we get a SIGNAL command. React to the provided signal, and
  1025. * report success or failure. (If the signal results in a shutdown, success
  1026. * may not be reported.) */
  1027. static int
  1028. handle_control_signal(control_connection_t *conn, uint32_t len,
  1029. const char *body)
  1030. {
  1031. int sig;
  1032. int n = 0;
  1033. char *s;
  1034. (void) len;
  1035. while (body[n] && ! TOR_ISSPACE(body[n]))
  1036. ++n;
  1037. s = tor_strndup(body, n);
  1038. if (!strcasecmp(s, "RELOAD") || !strcasecmp(s, "HUP"))
  1039. sig = SIGHUP;
  1040. else if (!strcasecmp(s, "SHUTDOWN") || !strcasecmp(s, "INT"))
  1041. sig = SIGINT;
  1042. else if (!strcasecmp(s, "DUMP") || !strcasecmp(s, "USR1"))
  1043. sig = SIGUSR1;
  1044. else if (!strcasecmp(s, "DEBUG") || !strcasecmp(s, "USR2"))
  1045. sig = SIGUSR2;
  1046. else if (!strcasecmp(s, "HALT") || !strcasecmp(s, "TERM"))
  1047. sig = SIGTERM;
  1048. else if (!strcasecmp(s, "NEWNYM"))
  1049. sig = SIGNEWNYM;
  1050. else if (!strcasecmp(s, "CLEARDNSCACHE"))
  1051. sig = SIGCLEARDNSCACHE;
  1052. else {
  1053. connection_printf_to_buf(conn, "552 Unrecognized signal code \"%s\"\r\n",
  1054. s);
  1055. sig = -1;
  1056. }
  1057. tor_free(s);
  1058. if (sig<0)
  1059. return 0;
  1060. send_control_done(conn);
  1061. /* Flush the "done" first if the signal might make us shut down. */
  1062. if (sig == SIGTERM || sig == SIGINT)
  1063. connection_handle_write(TO_CONN(conn), 1);
  1064. control_signal_act(sig);
  1065. return 0;
  1066. }
  1067. /** Called when we get a MAPADDRESS command; try to bind all listed addresses,
  1068. * and report success or failrue. */
  1069. static int
  1070. handle_control_mapaddress(control_connection_t *conn, uint32_t len,
  1071. const char *body)
  1072. {
  1073. smartlist_t *elts;
  1074. smartlist_t *lines;
  1075. smartlist_t *reply;
  1076. char *r;
  1077. size_t sz;
  1078. (void) len; /* body is nul-terminated, so it's safe to ignore the length. */
  1079. lines = smartlist_create();
  1080. elts = smartlist_create();
  1081. reply = smartlist_create();
  1082. smartlist_split_string(lines, body, " ",
  1083. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1084. SMARTLIST_FOREACH(lines, char *, line,
  1085. {
  1086. tor_strlower(line);
  1087. smartlist_split_string(elts, line, "=", 0, 2);
  1088. if (smartlist_len(elts) == 2) {
  1089. const char *from = smartlist_get(elts,0);
  1090. const char *to = smartlist_get(elts,1);
  1091. size_t anslen = strlen(line)+512;
  1092. char *ans = tor_malloc(anslen);
  1093. if (address_is_invalid_destination(to, 1)) {
  1094. tor_snprintf(ans, anslen,
  1095. "512-syntax error: invalid address '%s'", to);
  1096. smartlist_add(reply, ans);
  1097. log_warn(LD_CONTROL,
  1098. "Skipping invalid argument '%s' in MapAddress msg", to);
  1099. } else if (!strcmp(from, ".") || !strcmp(from, "0.0.0.0")) {
  1100. const char *address = addressmap_register_virtual_address(
  1101. !strcmp(from,".") ? RESOLVED_TYPE_HOSTNAME : RESOLVED_TYPE_IPV4,
  1102. tor_strdup(to));
  1103. if (!address) {
  1104. tor_snprintf(ans, anslen,
  1105. "451-resource exhausted: skipping '%s'", line);
  1106. smartlist_add(reply, ans);
  1107. log_warn(LD_CONTROL,
  1108. "Unable to allocate address for '%s' in MapAddress msg",
  1109. safe_str(line));
  1110. } else {
  1111. tor_snprintf(ans, anslen, "250-%s=%s", address, to);
  1112. smartlist_add(reply, ans);
  1113. }
  1114. } else {
  1115. addressmap_register(from, tor_strdup(to), 1);
  1116. tor_snprintf(ans, anslen, "250-%s", line);
  1117. smartlist_add(reply, ans);
  1118. }
  1119. } else {
  1120. size_t anslen = strlen(line)+256;
  1121. char *ans = tor_malloc(anslen);
  1122. tor_snprintf(ans, anslen, "512-syntax error: mapping '%s' is "
  1123. "not of expected form 'foo=bar'.", line);
  1124. smartlist_add(reply, ans);
  1125. log_info(LD_CONTROL, "Skipping MapAddress '%s': wrong "
  1126. "number of items.", safe_str(line));
  1127. }
  1128. SMARTLIST_FOREACH(elts, char *, cp, tor_free(cp));
  1129. smartlist_clear(elts);
  1130. });
  1131. SMARTLIST_FOREACH(lines, char *, cp, tor_free(cp));
  1132. smartlist_free(lines);
  1133. smartlist_free(elts);
  1134. if (smartlist_len(reply)) {
  1135. ((char*)smartlist_get(reply,smartlist_len(reply)-1))[3] = ' ';
  1136. r = smartlist_join_strings(reply, "\r\n", 1, &sz);
  1137. connection_write_to_buf(r, sz, TO_CONN(conn));
  1138. tor_free(r);
  1139. } else {
  1140. const char *response =
  1141. "512 syntax error: not enough arguments to mapaddress.\r\n";
  1142. connection_write_to_buf(response, strlen(response), TO_CONN(conn));
  1143. }
  1144. SMARTLIST_FOREACH(reply, char *, cp, tor_free(cp));
  1145. smartlist_free(reply);
  1146. return 0;
  1147. }
  1148. /** Implementation helper for GETINFO: knows the answers for various
  1149. * trivial-to-implement questions. */
  1150. static int
  1151. getinfo_helper_misc(control_connection_t *conn, const char *question,
  1152. char **answer)
  1153. {
  1154. (void) conn;
  1155. if (!strcmp(question, "version")) {
  1156. *answer = tor_strdup(get_version());
  1157. } else if (!strcmp(question, "config-file")) {
  1158. *answer = tor_strdup(get_torrc_fname());
  1159. } else if (!strcmp(question, "info/names")) {
  1160. *answer = list_getinfo_options();
  1161. } else if (!strcmp(question, "events/names")) {
  1162. *answer = tor_strdup("CIRC STREAM ORCONN BW DEBUG INFO NOTICE WARN ERR "
  1163. "NEWDESC ADDRMAP AUTHDIR_NEWDESCS DESCCHANGED "
  1164. "NS STATUS_GENERAL STATUS_CLIENT STATUS_SERVER "
  1165. "GUARD STREAM_BW");
  1166. } else if (!strcmp(question, "features/names")) {
  1167. *answer = tor_strdup("VERBOSE_NAMES EXTENDED_EVENTS");
  1168. } else if (!strcmp(question, "address")) {
  1169. uint32_t addr;
  1170. if (router_pick_published_address(get_options(), &addr) < 0)
  1171. return -1;
  1172. *answer = tor_dup_addr(addr);
  1173. } else if (!strcmp(question, "dir-usage")) {
  1174. *answer = directory_dump_request_log();
  1175. } else if (!strcmp(question, "fingerprint")) {
  1176. routerinfo_t *me = router_get_my_routerinfo();
  1177. if (!me)
  1178. return -1;
  1179. *answer = tor_malloc(HEX_DIGEST_LEN+1);
  1180. base16_encode(*answer, HEX_DIGEST_LEN+1, me->cache_info.identity_digest,
  1181. DIGEST_LEN);
  1182. }
  1183. return 0;
  1184. }
  1185. /** Awful hack: return a newly allocated string based on a routerinfo and
  1186. * (possibly) an extrainfo, sticking the read-history and write-history from
  1187. * <b>ei</b> into the resulting string. The thing you get back won't
  1188. * necessarily have a valid signature.
  1189. *
  1190. * New code should never use this; it's for backward compatibiliy.
  1191. *
  1192. * NOTE: <b>ri_body</b> is as returned by signed_descriptor_get_body: it might
  1193. * not be NUL-terminated. */
  1194. static char *
  1195. munge_extrainfo_into_routerinfo(const char *ri_body, signed_descriptor_t *ri,
  1196. signed_descriptor_t *ei)
  1197. {
  1198. char *out = NULL, *outp;
  1199. int i;
  1200. const char *router_sig;
  1201. const char *ei_body = signed_descriptor_get_body(ei);
  1202. size_t ri_len = ri->signed_descriptor_len;
  1203. size_t ei_len = ei->signed_descriptor_len;
  1204. if (!ei_body)
  1205. goto bail;
  1206. outp = out = tor_malloc(ri_len+ei_len+1);
  1207. if (!(router_sig = tor_memstr(ri_body, ri_len, "\nrouter-signature")))
  1208. goto bail;
  1209. ++router_sig;
  1210. memcpy(out, ri_body, router_sig-ri_body);
  1211. outp += router_sig-ri_body;
  1212. for (i=0; i < 2; ++i) {
  1213. const char *kwd = i?"\nwrite-history ":"\nread-history ";
  1214. const char *cp, *eol;
  1215. if (!(cp = tor_memstr(ei_body, ei_len, kwd)))
  1216. continue;
  1217. ++cp;
  1218. eol = memchr(cp, '\n', ei_len - (cp-ei_body));
  1219. memcpy(outp, cp, eol-cp+1);
  1220. outp += eol-cp+1;
  1221. }
  1222. memcpy(outp, router_sig, ri_len - (router_sig-ri_body));
  1223. *outp++ = '\0';
  1224. tor_assert(outp-out < (int)(ri_len+ei_len+1));
  1225. return out;
  1226. bail:
  1227. tor_free(out);
  1228. return tor_strndup(ri_body, ri->signed_descriptor_len);
  1229. }
  1230. /** Implementation helper for GETINFO: knows the answers for questions about
  1231. * directory information. */
  1232. static int
  1233. getinfo_helper_dir(control_connection_t *control_conn,
  1234. const char *question, char **answer)
  1235. {
  1236. if (!strcmpstart(question, "desc/id/")) {
  1237. routerinfo_t *ri = router_get_by_hexdigest(question+strlen("desc/id/"));
  1238. if (ri) {
  1239. const char *body = signed_descriptor_get_body(&ri->cache_info);
  1240. if (body)
  1241. *answer = tor_strndup(body, ri->cache_info.signed_descriptor_len);
  1242. }
  1243. } else if (!strcmpstart(question, "desc/name/")) {
  1244. routerinfo_t *ri = router_get_by_nickname(question+strlen("desc/name/"),1);
  1245. if (ri) {
  1246. const char *body = signed_descriptor_get_body(&ri->cache_info);
  1247. if (body)
  1248. *answer = tor_strndup(body, ri->cache_info.signed_descriptor_len);
  1249. }
  1250. } else if (!strcmp(question, "desc/all-recent")) {
  1251. routerlist_t *routerlist = router_get_routerlist();
  1252. smartlist_t *sl = smartlist_create();
  1253. if (routerlist && routerlist->routers) {
  1254. SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, ri,
  1255. {
  1256. const char *body = signed_descriptor_get_body(&ri->cache_info);
  1257. if (body)
  1258. smartlist_add(sl,
  1259. tor_strndup(body, ri->cache_info.signed_descriptor_len));
  1260. });
  1261. }
  1262. *answer = smartlist_join_strings(sl, "", 0, NULL);
  1263. SMARTLIST_FOREACH(sl, char *, c, tor_free(c));
  1264. smartlist_free(sl);
  1265. } else if (!strcmp(question, "desc/all-recent-extrainfo-hack")) {
  1266. /* XXXX Remove this once Torstat asks for extrainfos. */
  1267. routerlist_t *routerlist = router_get_routerlist();
  1268. smartlist_t *sl = smartlist_create();
  1269. if (routerlist && routerlist->routers) {
  1270. SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, ri,
  1271. {
  1272. const char *body = signed_descriptor_get_body(&ri->cache_info);
  1273. signed_descriptor_t *ei = extrainfo_get_by_descriptor_digest(
  1274. ri->cache_info.extra_info_digest);
  1275. if (ei && body) {
  1276. smartlist_add(sl, munge_extrainfo_into_routerinfo(body,
  1277. &ri->cache_info, ei));
  1278. } else if (body) {
  1279. smartlist_add(sl,
  1280. tor_strndup(body, ri->cache_info.signed_descriptor_len));
  1281. }
  1282. });
  1283. }
  1284. *answer = smartlist_join_strings(sl, "", 0, NULL);
  1285. SMARTLIST_FOREACH(sl, char *, c, tor_free(c));
  1286. smartlist_free(sl);
  1287. } else if (!strcmpstart(question, "desc-annotations/id/")) {
  1288. routerinfo_t *ri = router_get_by_hexdigest(question+
  1289. strlen("desc-annotations/id/"));
  1290. if (ri) {
  1291. const char *annotations =
  1292. signed_descriptor_get_annotations(&ri->cache_info);
  1293. if (annotations)
  1294. *answer = tor_strndup(annotations,
  1295. ri->cache_info.annotations_len);
  1296. }
  1297. } else if (!strcmpstart(question, "dir/server/")) {
  1298. size_t answer_len = 0, url_len = strlen(question)+2;
  1299. char *url = tor_malloc(url_len);
  1300. smartlist_t *descs = smartlist_create();
  1301. const char *msg;
  1302. int res;
  1303. char *cp;
  1304. tor_snprintf(url, url_len, "/tor/%s", question+4);
  1305. res = dirserv_get_routerdescs(descs, url, &msg);
  1306. if (res) {
  1307. log_warn(LD_CONTROL, "getinfo '%s': %s", question, msg);
  1308. return -1;
  1309. }
  1310. SMARTLIST_FOREACH(descs, signed_descriptor_t *, sd,
  1311. answer_len += sd->signed_descriptor_len);
  1312. cp = *answer = tor_malloc(answer_len+1);
  1313. SMARTLIST_FOREACH(descs, signed_descriptor_t *, sd,
  1314. {
  1315. memcpy(cp, signed_descriptor_get_body(sd),
  1316. sd->signed_descriptor_len);
  1317. cp += sd->signed_descriptor_len;
  1318. });
  1319. *cp = '\0';
  1320. tor_free(url);
  1321. smartlist_free(descs);
  1322. } else if (!strcmpstart(question, "dir/status/")) {
  1323. if (directory_permits_controller_requests(get_options())) {
  1324. size_t len=0;
  1325. char *cp;
  1326. smartlist_t *status_list = smartlist_create();
  1327. dirserv_get_networkstatus_v2(status_list,
  1328. question+strlen("dir/status/"));
  1329. SMARTLIST_FOREACH(status_list, cached_dir_t *, d, len += d->dir_len);
  1330. cp = *answer = tor_malloc(len+1);
  1331. SMARTLIST_FOREACH(status_list, cached_dir_t *, d, {
  1332. memcpy(cp, d->dir, d->dir_len);
  1333. cp += d->dir_len;
  1334. });
  1335. *cp = '\0';
  1336. smartlist_free(status_list);
  1337. } else {
  1338. smartlist_t *fp_list = smartlist_create();
  1339. smartlist_t *status_list = smartlist_create();
  1340. dirserv_get_networkstatus_v2_fingerprints(
  1341. fp_list, question+strlen("dir/status/"));
  1342. SMARTLIST_FOREACH(fp_list, const char *, fp, {
  1343. char *s;
  1344. char *fname = networkstatus_get_cache_filename(fp);
  1345. s = read_file_to_str(fname, 0, NULL);
  1346. if (s)
  1347. smartlist_add(status_list, s);
  1348. tor_free(fname);
  1349. });
  1350. SMARTLIST_FOREACH(fp_list, char *, fp, tor_free(fp));
  1351. smartlist_free(fp_list);
  1352. *answer = smartlist_join_strings(status_list, "", 0, NULL);
  1353. SMARTLIST_FOREACH(status_list, char *, s, tor_free(s));
  1354. smartlist_free(status_list);
  1355. }
  1356. } else if (!strcmp(question, "network-status")) {
  1357. routerlist_t *routerlist = router_get_routerlist();
  1358. int verbose = control_conn->use_long_names;
  1359. if (!routerlist || !routerlist->routers ||
  1360. list_server_status_v1(routerlist->routers, answer,
  1361. verbose ? 2 : 1) < 0) {
  1362. return -1;
  1363. }
  1364. } else if (!strcmpstart(question, "extra-info/digest/")) {
  1365. question += strlen("extra-info/digest/");
  1366. if (strlen(question) == HEX_DIGEST_LEN) {
  1367. char d[DIGEST_LEN];
  1368. signed_descriptor_t *sd;
  1369. base16_decode(d, sizeof(d), question, strlen(question));
  1370. sd = extrainfo_get_by_descriptor_digest(d);
  1371. if (sd) {
  1372. const char *body = signed_descriptor_get_body(sd);
  1373. if (body)
  1374. *answer = tor_strndup(body, sd->signed_descriptor_len);
  1375. }
  1376. }
  1377. }
  1378. return 0;
  1379. }
  1380. /** Implementation helper for GETINFO: knows how to generate summaries of the
  1381. * current states of things we send events about. */
  1382. static int
  1383. getinfo_helper_events(control_connection_t *control_conn,
  1384. const char *question, char **answer)
  1385. {
  1386. if (!strcmp(question, "circuit-status")) {
  1387. circuit_t *circ;
  1388. smartlist_t *status = smartlist_create();
  1389. for (circ = _circuit_get_global_list(); circ; circ = circ->next) {
  1390. char *s, *path;
  1391. size_t slen;
  1392. const char *state;
  1393. if (! CIRCUIT_IS_ORIGIN(circ) || circ->marked_for_close)
  1394. continue;
  1395. if (control_conn->use_long_names)
  1396. path = circuit_list_path_for_controller(TO_ORIGIN_CIRCUIT(circ));
  1397. else
  1398. path = circuit_list_path(TO_ORIGIN_CIRCUIT(circ),0);
  1399. if (circ->state == CIRCUIT_STATE_OPEN)
  1400. state = "BUILT";
  1401. else if (strlen(path))
  1402. state = "EXTENDED";
  1403. else
  1404. state = "LAUNCHED";
  1405. slen = strlen(path)+strlen(state)+20;
  1406. s = tor_malloc(slen+1);
  1407. tor_snprintf(s, slen, "%lu %s%s%s",
  1408. (unsigned long)TO_ORIGIN_CIRCUIT(circ)->global_identifier,
  1409. state, *path ? " " : "", path);
  1410. smartlist_add(status, s);
  1411. tor_free(path);
  1412. }
  1413. *answer = smartlist_join_strings(status, "\r\n", 0, NULL);
  1414. SMARTLIST_FOREACH(status, char *, cp, tor_free(cp));
  1415. smartlist_free(status);
  1416. } else if (!strcmp(question, "stream-status")) {
  1417. smartlist_t *conns = get_connection_array();
  1418. smartlist_t *status = smartlist_create();
  1419. char buf[256];
  1420. SMARTLIST_FOREACH(conns, connection_t *, base_conn,
  1421. {
  1422. const char *state;
  1423. edge_connection_t *conn;
  1424. char *s;
  1425. size_t slen;
  1426. circuit_t *circ;
  1427. origin_circuit_t *origin_circ = NULL;
  1428. if (base_conn->type != CONN_TYPE_AP ||
  1429. base_conn->marked_for_close ||
  1430. base_conn->state == AP_CONN_STATE_SOCKS_WAIT ||
  1431. base_conn->state == AP_CONN_STATE_NATD_WAIT)
  1432. continue;
  1433. conn = TO_EDGE_CONN(base_conn);
  1434. switch (conn->_base.state)
  1435. {
  1436. case AP_CONN_STATE_CONTROLLER_WAIT:
  1437. case AP_CONN_STATE_CIRCUIT_WAIT:
  1438. if (conn->socks_request &&
  1439. SOCKS_COMMAND_IS_RESOLVE(conn->socks_request->command))
  1440. state = "NEWRESOLVE";
  1441. else
  1442. state = "NEW";
  1443. break;
  1444. case AP_CONN_STATE_RENDDESC_WAIT:
  1445. case AP_CONN_STATE_CONNECT_WAIT:
  1446. state = "SENTCONNECT"; break;
  1447. case AP_CONN_STATE_RESOLVE_WAIT:
  1448. state = "SENTRESOLVE"; break;
  1449. case AP_CONN_STATE_OPEN:
  1450. state = "SUCCEEDED"; break;
  1451. default:
  1452. log_warn(LD_BUG, "Asked for stream in unknown state %d",
  1453. conn->_base.state);
  1454. continue;
  1455. }
  1456. circ = circuit_get_by_edge_conn(conn);
  1457. if (circ && CIRCUIT_IS_ORIGIN(circ))
  1458. origin_circ = TO_ORIGIN_CIRCUIT(circ);
  1459. write_stream_target_to_buf(conn, buf, sizeof(buf));
  1460. slen = strlen(buf)+strlen(state)+32;
  1461. s = tor_malloc(slen+1);
  1462. tor_snprintf(s, slen, "%lu %s %lu %s",
  1463. (unsigned long) conn->global_identifier,state,
  1464. origin_circ?
  1465. (unsigned long)origin_circ->global_identifier : 0ul,
  1466. buf);
  1467. smartlist_add(status, s);
  1468. });
  1469. *answer = smartlist_join_strings(status, "\r\n", 0, NULL);
  1470. SMARTLIST_FOREACH(status, char *, cp, tor_free(cp));
  1471. smartlist_free(status);
  1472. } else if (!strcmp(question, "orconn-status")) {
  1473. smartlist_t *conns = get_connection_array();
  1474. smartlist_t *status = smartlist_create();
  1475. SMARTLIST_FOREACH(conns, connection_t *, base_conn,
  1476. {
  1477. const char *state;
  1478. char *s;
  1479. char name[128];
  1480. size_t slen;
  1481. or_connection_t *conn;
  1482. if (base_conn->type != CONN_TYPE_OR || base_conn->marked_for_close)
  1483. continue;
  1484. conn = TO_OR_CONN(base_conn);
  1485. if (conn->_base.state == OR_CONN_STATE_OPEN)
  1486. state = "CONNECTED";
  1487. else if (conn->nickname)
  1488. state = "LAUNCHED";
  1489. else
  1490. state = "NEW";
  1491. orconn_target_get_name(control_conn->use_long_names, name, sizeof(name),
  1492. conn);
  1493. slen = strlen(name)+strlen(state)+2;
  1494. s = tor_malloc(slen+1);
  1495. tor_snprintf(s, slen, "%s %s", name, state);
  1496. smartlist_add(status, s);
  1497. });
  1498. *answer = smartlist_join_strings(status, "\r\n", 0, NULL);
  1499. SMARTLIST_FOREACH(status, char *, cp, tor_free(cp));
  1500. smartlist_free(status);
  1501. } else if (!strcmpstart(question, "addr-mappings/") ||
  1502. !strcmpstart(question, "address-mappings/")) {
  1503. /* XXXX020 Warn about deprecated addr-mappings variant? Or wait for
  1504. * 0.2.1.x? */
  1505. time_t min_e, max_e;
  1506. smartlist_t *mappings;
  1507. int want_expiry = !strcmpstart(question, "address-mappings/");
  1508. question += strlen(want_expiry ? "address-mappings/"
  1509. : "addr-mappings/");
  1510. if (!strcmp(question, "all")) {
  1511. min_e = 0; max_e = TIME_MAX;
  1512. } else if (!strcmp(question, "cache")) {
  1513. min_e = 2; max_e = TIME_MAX;
  1514. } else if (!strcmp(question, "config")) {
  1515. min_e = 0; max_e = 0;
  1516. } else if (!strcmp(question, "control")) {
  1517. min_e = 1; max_e = 1;
  1518. } else {
  1519. return 0;
  1520. }
  1521. mappings = smartlist_create();
  1522. addressmap_get_mappings(mappings, min_e, max_e, want_expiry);
  1523. *answer = smartlist_join_strings(mappings, "\r\n", 0, NULL);
  1524. SMARTLIST_FOREACH(mappings, char *, cp, tor_free(cp));
  1525. smartlist_free(mappings);
  1526. } else if (!strcmpstart(question, "status/")) {
  1527. /* Note that status/ is not a catch-all for events; there's only supposed
  1528. * to be a status GETINFO if there's a corresponding STATUS event. */
  1529. if (!strcmp(question, "status/circuit-established")) {
  1530. *answer = tor_strdup(has_completed_circuit ? "1" : "0");
  1531. } else if (!strcmp(question, "status/enough-dir-info")) {
  1532. *answer = tor_strdup(router_have_minimum_dir_info() ? "1" : "0");
  1533. } else if (!strcmp(question, "status/good-server-descriptor")) {
  1534. *answer = tor_strdup(directories_have_accepted_server_descriptor()
  1535. ? "1" : "0");
  1536. } else if (!strcmp(question, "status/reachability-succeeded/or")) {
  1537. *answer = tor_strdup(check_whether_orport_reachable() ? "1" : "0");
  1538. } else if (!strcmp(question, "status/reachability-succeeded/dir")) {
  1539. *answer = tor_strdup(check_whether_dirport_reachable() ? "1" : "0");
  1540. } else if (!strcmp(question, "status/reachability-succeeded")) {
  1541. *answer = tor_malloc(16);
  1542. tor_snprintf(*answer, 16, "OR=%d DIR=%d",
  1543. check_whether_orport_reachable() ? 1 : 0,
  1544. check_whether_dirport_reachable() ? 1 : 0);
  1545. } else if (!strcmpstart(question, "status/version/")) {
  1546. int is_server = server_mode(get_options());
  1547. networkstatus_vote_t *c = networkstatus_get_latest_consensus();
  1548. version_status_t status;
  1549. const char *recommended;
  1550. if (c) {
  1551. recommended = is_server ? c->server_versions : c->client_versions;
  1552. status = tor_version_is_obsolete(VERSION, recommended);
  1553. } else {
  1554. recommended = "?";
  1555. status = VS_UNKNOWN;
  1556. }
  1557. if (!strcmp(question, "status/version/recommended")) {
  1558. *answer = tor_strdup(recommended);
  1559. return 0;
  1560. }
  1561. if (!strcmp(question, "status/version/current")) {
  1562. switch (status)
  1563. {
  1564. case VS_RECOMMENDED: *answer = tor_strdup("recommended"); break;
  1565. case VS_OLD: *answer = tor_strdup("obsolete"); break;
  1566. case VS_NEW: *answer = tor_strdup("new"); break;
  1567. case VS_NEW_IN_SERIES: *answer = tor_strdup("new in series"); break;
  1568. case VS_UNRECOMMENDED: *answer = tor_strdup("unrecommended"); break;
  1569. case VS_UNKNOWN: *answer = tor_strdup("unknown"); break;
  1570. default: tor_fragile_assert();
  1571. }
  1572. } else if (!strcmp(question, "status/version/num-versioning") ||
  1573. !strcmp(question, "status/version/num-concurring")) {
  1574. /*XXXX020 deprecate.*/
  1575. char s[33];
  1576. tor_snprintf(s, sizeof(s), "%d", get_n_authorities(V3_AUTHORITY));
  1577. *answer = tor_strdup(s);
  1578. }
  1579. } else {
  1580. return 0;
  1581. }
  1582. }
  1583. return 0;
  1584. }
  1585. /** Callback function for GETINFO: on a given control connection, try to
  1586. * answer the question <b>q</b> and store the newly-allocated answer in
  1587. * *<b>a</b>. If there's no answer, or an error occurs, just don't set
  1588. * <b>a</b>. Return 0.
  1589. */
  1590. typedef int (*getinfo_helper_t)(control_connection_t *,
  1591. const char *q, char **a);
  1592. /** A single item for the GETINFO question-to-answer-function table. */
  1593. typedef struct getinfo_item_t {
  1594. const char *varname; /**< The value (or prefix) of the question. */
  1595. getinfo_helper_t fn; /**< The function that knows the answer: NULL if
  1596. * this entry is documentation-only. */
  1597. const char *desc; /**< Description of the variable. */
  1598. int is_prefix; /** Must varname match exactly, or must it be a prefix? */
  1599. } getinfo_item_t;
  1600. #define ITEM(name, fn, desc) { name, getinfo_helper_##fn, desc, 0 }
  1601. #define PREFIX(name, fn, desc) { name, getinfo_helper_##fn, desc, 1 }
  1602. #define DOC(name, desc) { name, NULL, desc, 0 }
  1603. /** Table mapping questions accepted by GETINFO to the functions that know how
  1604. * to answer them. */
  1605. static const getinfo_item_t getinfo_items[] = {
  1606. ITEM("version", misc, "The current version of Tor."),
  1607. ITEM("config-file", misc, "Current location of the \"torrc\" file."),
  1608. ITEM("accounting/bytes", accounting,
  1609. "Number of bytes read/written so far in the accounting interval."),
  1610. ITEM("accounting/bytes-left", accounting,
  1611. "Number of bytes left to write/read so far in the accounting interval."),
  1612. ITEM("accounting/enabled", accounting, "Is accounting currently enabled?"),
  1613. ITEM("accounting/hibernating", accounting, "Are we hibernating or awake?"),
  1614. ITEM("accounting/interval-start", accounting,
  1615. "Time when the accounting period starts."),
  1616. ITEM("accounting/interval-end", accounting,
  1617. "Time when the accounting period ends."),
  1618. ITEM("accounting/interval-wake", accounting,
  1619. "Time to wake up in this accounting period."),
  1620. ITEM("helper-nodes", entry_guards, NULL), /* deprecated */
  1621. ITEM("entry-guards", entry_guards,
  1622. "Which nodes are we using as entry guards?"),
  1623. ITEM("fingerprint", misc, NULL),
  1624. PREFIX("config/", config, "Current configuration values."),
  1625. DOC("config/names",
  1626. "List of configuration options, types, and documentation."),
  1627. ITEM("info/names", misc,
  1628. "List of GETINFO options, types, and documentation."),
  1629. ITEM("events/names", misc,
  1630. "Events that the controller can ask for with SETEVENTS."),
  1631. ITEM("features/names", misc, "What arguments can USEFEATURE take?"),
  1632. PREFIX("desc/id/", dir, "Router descriptors by ID."),
  1633. PREFIX("desc/name/", dir, "Router descriptors by nickname."),
  1634. ITEM("desc/all-recent", dir,
  1635. "All non-expired, non-superseded router descriptors."),
  1636. ITEM("desc/all-recent-extrainfo-hack", dir, NULL), /* Hack. */
  1637. PREFIX("extra-info/digest/", dir, "Extra-info documents by digest."),
  1638. ITEM("ns/all", networkstatus,
  1639. "Brief summary of router status (v2 directory format)"),
  1640. PREFIX("ns/id/", networkstatus,
  1641. "Brief summary of router status by ID (v2 directory format)."),
  1642. PREFIX("ns/name/", networkstatus,
  1643. "Brief summary of router status by nickname (v2 directory format)."),
  1644. PREFIX("ns/purpose/", networkstatus,
  1645. "Brief summary of router status by purpose (v2 directory format)."),
  1646. PREFIX("unregistered-servers-", dirserv_unregistered, NULL),
  1647. ITEM("network-status", dir,
  1648. "Brief summary of router status (v1 directory format)"),
  1649. ITEM("circuit-status", events, "List of current circuits originating here."),
  1650. ITEM("stream-status", events,"List of current streams."),
  1651. ITEM("orconn-status", events, "A list of current OR connections."),
  1652. PREFIX("address-mappings/", events, NULL),
  1653. DOC("address-mappings/all", "Current address mappings."),
  1654. DOC("address-mappings/cache", "Current cached DNS replies."),
  1655. DOC("address-mappings/config",
  1656. "Current address mappings from configuration."),
  1657. DOC("address-mappings/control", "Current address mappings from controller."),
  1658. PREFIX("addr-mappings/", events, NULL),
  1659. DOC("addr-mappings/all", "Current address mappings without expiry times."),
  1660. DOC("addr-mappings/cache",
  1661. "Current cached DNS replies without expiry times."),
  1662. DOC("addr-mappings/config",
  1663. "Current address mappings from configuration without expiry times."),
  1664. DOC("addr-mappings/control",
  1665. "Current address mappings from controller without expiry times."),
  1666. PREFIX("status/", events, NULL),
  1667. DOC("status/circuit-established",
  1668. "Whether we think client functionality is working."),
  1669. DOC("status/enough-dir-info",
  1670. "Whether we have enough up-to-date directory information to build "
  1671. "circuits."),
  1672. DOC("status/version/recommended", "List of currently recommended versions."),
  1673. DOC("status/version/current", "Status of the current version."),
  1674. DOC("status/version/num-versioning", "Number of versioning authorities."),
  1675. DOC("status/version/num-concurring",
  1676. "Number of versioning authorities agreeing on the status of the "
  1677. "current version"),
  1678. ITEM("address", misc, "IP address of this Tor host, if we can guess it."),
  1679. ITEM("dir-usage", misc, "Breakdown of bytes transferred over DirPort."),
  1680. PREFIX("desc-annotations/id/", dir, "Router annotations by hexdigest."),
  1681. PREFIX("dir/server/", dir,"Router descriptors as retrieved from a DirPort."),
  1682. PREFIX("dir/status/", dir,"Networkstatus docs as retrieved from a DirPort."),
  1683. PREFIX("exit-policy/default", policies,
  1684. "The default value appended to the configured exit policy."),
  1685. PREFIX("ip-to-country/", geoip, "Perform a GEOIP lookup"),
  1686. { NULL, NULL, NULL, 0 }
  1687. };
  1688. /** Allocate and return a list of recognized GETINFO options. */
  1689. static char *
  1690. list_getinfo_options(void)
  1691. {
  1692. int i;
  1693. char buf[300];
  1694. smartlist_t *lines = smartlist_create();
  1695. char *ans;
  1696. for (i = 0; getinfo_items[i].varname; ++i) {
  1697. if (!getinfo_items[i].desc)
  1698. continue;
  1699. tor_snprintf(buf, sizeof(buf), "%s%s -- %s\n",
  1700. getinfo_items[i].varname,
  1701. getinfo_items[i].is_prefix ? "*" : "",
  1702. getinfo_items[i].desc);
  1703. smartlist_add(lines, tor_strdup(buf));
  1704. }
  1705. smartlist_sort_strings(lines);
  1706. ans = smartlist_join_strings(lines, "", 0, NULL);
  1707. SMARTLIST_FOREACH(lines, char *, cp, tor_free(cp));
  1708. smartlist_free(lines);
  1709. return ans;
  1710. }
  1711. /** Lookup the 'getinfo' entry <b>question</b>, and return
  1712. * the answer in <b>*answer</b> (or NULL if key not recognized).
  1713. * Return 0 if success or unrecognized, or -1 if recognized but
  1714. * internal error. */
  1715. static int
  1716. handle_getinfo_helper(control_connection_t *control_conn,
  1717. const char *question, char **answer)
  1718. {
  1719. int i;
  1720. *answer = NULL; /* unrecognized key by default */
  1721. for (i = 0; getinfo_items[i].varname; ++i) {
  1722. int match;
  1723. if (getinfo_items[i].is_prefix)
  1724. match = !strcmpstart(question, getinfo_items[i].varname);
  1725. else
  1726. match = !strcmp(question, getinfo_items[i].varname);
  1727. if (match) {
  1728. tor_assert(getinfo_items[i].fn);
  1729. return getinfo_items[i].fn(control_conn, question, answer);
  1730. }
  1731. }
  1732. return 0; /* unrecognized */
  1733. }
  1734. /** Called when we receive a GETINFO command. Try to fetch all requested
  1735. * information, and reply with information or error message. */
  1736. static int
  1737. handle_control_getinfo(control_connection_t *conn, uint32_t len,
  1738. const char *body)
  1739. {
  1740. smartlist_t *questions = NULL;
  1741. smartlist_t *answers = NULL;
  1742. smartlist_t *unrecognized = NULL;
  1743. char *msg = NULL, *ans = NULL;
  1744. int i;
  1745. (void) len; /* body is nul-terminated, so it's safe to ignore the length. */
  1746. questions = smartlist_create();
  1747. smartlist_split_string(questions, body, " ",
  1748. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1749. answers = smartlist_create();
  1750. unrecognized = smartlist_create();
  1751. SMARTLIST_FOREACH(questions, const char *, q,
  1752. {
  1753. if (handle_getinfo_helper(conn, q, &ans) < 0) {
  1754. connection_write_str_to_buf("551 Internal error\r\n", conn);
  1755. goto done;
  1756. }
  1757. if (!ans) {
  1758. smartlist_add(unrecognized, (char*)q);
  1759. } else {
  1760. smartlist_add(answers, tor_strdup(q));
  1761. smartlist_add(answers, ans);
  1762. }
  1763. });
  1764. if (smartlist_len(unrecognized)) {
  1765. for (i=0; i < smartlist_len(unrecognized)-1; ++i)
  1766. connection_printf_to_buf(conn,
  1767. "552-Unrecognized key \"%s\"\r\n",
  1768. (char*)smartlist_get(unrecognized, i));
  1769. connection_printf_to_buf(conn,
  1770. "552 Unrecognized key \"%s\"\r\n",
  1771. (char*)smartlist_get(unrecognized, i));
  1772. goto done;
  1773. }
  1774. for (i = 0; i < smartlist_len(answers); i += 2) {
  1775. char *k = smartlist_get(answers, i);
  1776. char *v = smartlist_get(answers, i+1);
  1777. if (!strchr(v, '\n') && !strchr(v, '\r')) {
  1778. connection_printf_to_buf(conn, "250-%s=", k);
  1779. connection_write_str_to_buf(v, conn);
  1780. connection_write_str_to_buf("\r\n", conn);
  1781. } else {
  1782. char *esc = NULL;
  1783. size_t esc_len;
  1784. esc_len = write_escaped_data(v, strlen(v), &esc);
  1785. connection_printf_to_buf(conn, "250+%s=\r\n", k);
  1786. connection_write_to_buf(esc, esc_len, TO_CONN(conn));
  1787. tor_free(esc);
  1788. }
  1789. }
  1790. connection_write_str_to_buf("250 OK\r\n", conn);
  1791. done:
  1792. if (answers) {
  1793. SMARTLIST_FOREACH(answers, char *, cp, tor_free(cp));
  1794. smartlist_free(answers);
  1795. }
  1796. if (questions) {
  1797. SMARTLIST_FOREACH(questions, char *, cp, tor_free(cp));
  1798. smartlist_free(questions);
  1799. }
  1800. smartlist_free(unrecognized);
  1801. tor_free(msg);
  1802. return 0;
  1803. }
  1804. /** Given a string, convert it to a circuit purpose. */
  1805. static uint8_t
  1806. circuit_purpose_from_string(const char *string)
  1807. {
  1808. if (!strcmpstart(string, "purpose="))
  1809. string += strlen("purpose=");
  1810. if (!strcmp(string, "general"))
  1811. return CIRCUIT_PURPOSE_C_GENERAL;
  1812. else if (!strcmp(string, "controller"))
  1813. return CIRCUIT_PURPOSE_CONTROLLER;
  1814. else
  1815. return CIRCUIT_PURPOSE_UNKNOWN;
  1816. }
  1817. /** Return a newly allocated smartlist containing the arguments to the command
  1818. * waiting in <b>body</b>. If there are fewer than <b>min_args</b> arguments,
  1819. * or if <b>max_args</b> is nonnegative and there are more than
  1820. * <b>max_args</b> arguments, send a 512 error to the controller, using
  1821. * <b>command</b> as the command name in the error message. */
  1822. static smartlist_t *
  1823. getargs_helper(const char *command, control_connection_t *conn,
  1824. const char *body, int min_args, int max_args)
  1825. {
  1826. smartlist_t *args = smartlist_create();
  1827. smartlist_split_string(args, body, " ",
  1828. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1829. if (smartlist_len(args) < min_args) {
  1830. connection_printf_to_buf(conn, "512 Missing argument to %s\r\n",command);
  1831. goto err;
  1832. } else if (max_args >= 0 && smartlist_len(args) > max_args) {
  1833. connection_printf_to_buf(conn, "512 Too many arguments to %s\r\n",command);
  1834. goto err;
  1835. }
  1836. return args;
  1837. err:
  1838. SMARTLIST_FOREACH(args, char *, s, tor_free(s));
  1839. smartlist_free(args);
  1840. return NULL;
  1841. }
  1842. /** Called when we get an EXTENDCIRCUIT message. Try to extend the listed
  1843. * circuit, and report success or failure. */
  1844. static int
  1845. handle_control_extendcircuit(control_connection_t *conn, uint32_t len,
  1846. const char *body)
  1847. {
  1848. smartlist_t *router_nicknames=NULL, *routers=NULL;
  1849. origin_circuit_t *circ = NULL;
  1850. int zero_circ;
  1851. uint8_t intended_purpose = CIRCUIT_PURPOSE_C_GENERAL;
  1852. smartlist_t *args;
  1853. (void) len;
  1854. router_nicknames = smartlist_create();
  1855. args = getargs_helper("EXTENDCIRCUIT", conn, body, 2, -1);
  1856. if (!args)
  1857. goto done;
  1858. zero_circ = !strcmp("0", (char*)smartlist_get(args,0));
  1859. if (!zero_circ && !(circ = get_circ(smartlist_get(args,0)))) {
  1860. connection_printf_to_buf(conn, "552 Unknown circuit \"%s\"\r\n",
  1861. (char*)smartlist_get(args, 0));
  1862. }
  1863. smartlist_split_string(router_nicknames, smartlist_get(args,1), ",", 0, 0);
  1864. if (zero_circ && smartlist_len(args)>2) {
  1865. char *purp = smartlist_get(args,2);
  1866. intended_purpose = circuit_purpose_from_string(purp);
  1867. if (intended_purpose == CIRCUIT_PURPOSE_UNKNOWN) {
  1868. connection_printf_to_buf(conn, "552 Unknown purpose \"%s\"\r\n", purp);
  1869. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  1870. smartlist_free(args);
  1871. goto done;
  1872. }
  1873. }
  1874. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  1875. smartlist_free(args);
  1876. if (!zero_circ && !circ) {
  1877. goto done;
  1878. }
  1879. routers = smartlist_create();
  1880. SMARTLIST_FOREACH(router_nicknames, const char *, n,
  1881. {
  1882. routerinfo_t *r = router_get_by_nickname(n, 1);
  1883. if (!r) {
  1884. connection_printf_to_buf(conn, "552 No such router \"%s\"\r\n", n);
  1885. goto done;
  1886. }
  1887. smartlist_add(routers, r);
  1888. });
  1889. if (!smartlist_len(routers)) {
  1890. connection_write_str_to_buf("512 No router names provided\r\n", conn);
  1891. goto done;
  1892. }
  1893. if (zero_circ) {
  1894. /* start a new circuit */
  1895. circ = origin_circuit_init(intended_purpose, 0, 0, 0, 0);
  1896. }
  1897. /* now circ refers to something that is ready to be extended */
  1898. SMARTLIST_FOREACH(routers, routerinfo_t *, r,
  1899. {
  1900. extend_info_t *info = extend_info_from_router(r);
  1901. circuit_append_new_exit(circ, info);
  1902. extend_info_free(info);
  1903. });
  1904. /* now that we've populated the cpath, start extending */
  1905. if (zero_circ) {
  1906. int err_reason = 0;
  1907. if ((err_reason = circuit_handle_first_hop(circ)) < 0) {
  1908. circuit_mark_for_close(TO_CIRCUIT(circ), -err_reason);
  1909. connection_write_str_to_buf("551 Couldn't start circuit\r\n", conn);
  1910. goto done;
  1911. }
  1912. } else {
  1913. if (circ->_base.state == CIRCUIT_STATE_OPEN) {
  1914. int err_reason = 0;
  1915. circuit_set_state(TO_CIRCUIT(circ), CIRCUIT_STATE_BUILDING);
  1916. if ((err_reason = circuit_send_next_onion_skin(circ)) < 0) {
  1917. log_info(LD_CONTROL,
  1918. "send_next_onion_skin failed; circuit marked for closing.");
  1919. circuit_mark_for_close(TO_CIRCUIT(circ), -err_reason);
  1920. connection_write_str_to_buf("551 Couldn't send onion skin\r\n", conn);
  1921. goto done;
  1922. }
  1923. }
  1924. }
  1925. connection_printf_to_buf(conn, "250 EXTENDED %lu\r\n",
  1926. (unsigned long)circ->global_identifier);
  1927. if (zero_circ) /* send a 'launched' event, for completeness */
  1928. control_event_circuit_status(circ, CIRC_EVENT_LAUNCHED, 0);
  1929. done:
  1930. SMARTLIST_FOREACH(router_nicknames, char *, n, tor_free(n));
  1931. smartlist_free(router_nicknames);
  1932. if (routers)
  1933. smartlist_free(routers);
  1934. return 0;
  1935. }
  1936. /** Called when we get a SETCIRCUITPURPOSE message. If we can find the
  1937. * circuit and it's a valid purpose, change it. */
  1938. static int
  1939. handle_control_setcircuitpurpose(control_connection_t *conn,
  1940. uint32_t len, const char *body)
  1941. {
  1942. origin_circuit_t *circ = NULL;
  1943. uint8_t new_purpose;
  1944. smartlist_t *args;
  1945. (void) len; /* body is nul-terminated, so it's safe to ignore the length. */
  1946. args = getargs_helper("SETCIRCUITPURPOSE", conn, body, 2, -1);
  1947. if (!args)
  1948. goto done;
  1949. if (!(circ = get_circ(smartlist_get(args,0)))) {
  1950. connection_printf_to_buf(conn, "552 Unknown circuit \"%s\"\r\n",
  1951. (char*)smartlist_get(args, 0));
  1952. goto done;
  1953. }
  1954. {
  1955. char *purp = smartlist_get(args,1);
  1956. new_purpose = circuit_purpose_from_string(purp);
  1957. if (new_purpose == CIRCUIT_PURPOSE_UNKNOWN) {
  1958. connection_printf_to_buf(conn, "552 Unknown purpose \"%s\"\r\n", purp);
  1959. goto done;
  1960. }
  1961. }
  1962. circ->_base.purpose = new_purpose;
  1963. connection_write_str_to_buf("250 OK\r\n", conn);
  1964. done:
  1965. if (args) {
  1966. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  1967. smartlist_free(args);
  1968. }
  1969. return 0;
  1970. }
  1971. /** Called when we get an ATTACHSTREAM message. Try to attach the requested
  1972. * stream, and report success or failure. */
  1973. static int
  1974. handle_control_attachstream(control_connection_t *conn, uint32_t len,
  1975. const char *body)
  1976. {
  1977. edge_connection_t *ap_conn = NULL;
  1978. origin_circuit_t *circ = NULL;
  1979. int zero_circ;
  1980. smartlist_t *args;
  1981. crypt_path_t *cpath=NULL;
  1982. int hop=0, hop_line_ok=1;
  1983. (void) len;
  1984. args = getargs_helper("ATTACHSTREAM", conn, body, 2, -1);
  1985. if (!args)
  1986. return 0;
  1987. zero_circ = !strcmp("0", (char*)smartlist_get(args,1));
  1988. if (!(ap_conn = get_stream(smartlist_get(args, 0)))) {
  1989. connection_printf_to_buf(conn, "552 Unknown stream \"%s\"\r\n",
  1990. (char*)smartlist_get(args, 0));
  1991. } else if (!zero_circ && !(circ = get_circ(smartlist_get(args, 1)))) {
  1992. connection_printf_to_buf(conn, "552 Unknown circuit \"%s\"\r\n",
  1993. (char*)smartlist_get(args, 1));
  1994. } else if (circ && smartlist_len(args) > 2) {
  1995. char *hopstring = smartlist_get(args, 2);
  1996. if (!strcasecmpstart(hopstring, "HOP=")) {
  1997. hopstring += strlen("HOP=");
  1998. hop = tor_parse_ulong(hopstring, 10, 0, ULONG_MAX,
  1999. &hop_line_ok, NULL);
  2000. if (!hop_line_ok) { /* broken hop line */
  2001. connection_printf_to_buf(conn, "552 Bad value hop=%s\r\n", hopstring);
  2002. }
  2003. }
  2004. }
  2005. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  2006. smartlist_free(args);
  2007. if (!ap_conn || (!zero_circ && !circ) || !hop_line_ok)
  2008. return 0;
  2009. if (ap_conn->_base.state != AP_CONN_STATE_CONTROLLER_WAIT &&
  2010. ap_conn->_base.state != AP_CONN_STATE_CONNECT_WAIT &&
  2011. ap_conn->_base.state != AP_CONN_STATE_RESOLVE_WAIT) {
  2012. connection_write_str_to_buf(
  2013. "555 Connection is not managed by controller.\r\n",
  2014. conn);
  2015. return 0;
  2016. }
  2017. /* Do we need to detach it first? */
  2018. if (ap_conn->_base.state != AP_CONN_STATE_CONTROLLER_WAIT) {
  2019. circuit_t *tmpcirc = circuit_get_by_edge_conn(ap_conn);
  2020. connection_edge_end(ap_conn, END_STREAM_REASON_TIMEOUT);
  2021. /* Un-mark it as ending, since we're going to reuse it. */
  2022. ap_conn->_base.edge_has_sent_end = 0;
  2023. ap_conn->end_reason = 0;
  2024. if (tmpcirc)
  2025. circuit_detach_stream(tmpcirc,ap_conn);
  2026. ap_conn->_base.state = AP_CONN_STATE_CONTROLLER_WAIT;
  2027. }
  2028. if (circ && (circ->_base.state != CIRCUIT_STATE_OPEN)) {
  2029. connection_write_str_to_buf(
  2030. "551 Can't attach stream to non-open origin circuit\r\n",
  2031. conn);
  2032. return 0;
  2033. }
  2034. if (circ && (circuit_get_cpath_len(circ)<2 || hop==1)) {
  2035. connection_write_str_to_buf(
  2036. "551 Can't attach stream to one-hop circuit.\r\n", conn);
  2037. return 0;
  2038. }
  2039. if (circ && hop>0) {
  2040. /* find this hop in the circuit, and set cpath */
  2041. cpath = circuit_get_cpath_hop(circ, hop);
  2042. if (!cpath) {
  2043. connection_printf_to_buf(conn,
  2044. "551 Circuit doesn't have %d hops.\r\n", hop);
  2045. return 0;
  2046. }
  2047. }
  2048. if (connection_ap_handshake_rewrite_and_attach(ap_conn, circ, cpath) < 0) {
  2049. connection_write_str_to_buf("551 Unable to attach stream\r\n", conn);
  2050. return 0;
  2051. }
  2052. send_control_done(conn);
  2053. return 0;
  2054. }
  2055. /** Called when we get a POSTDESCRIPTOR message. Try to learn the provided
  2056. * descriptor, and report success or failure. */
  2057. static int
  2058. handle_control_postdescriptor(control_connection_t *conn, uint32_t len,
  2059. const char *body)
  2060. {
  2061. char *desc;
  2062. const char *msg=NULL;
  2063. uint8_t purpose = ROUTER_PURPOSE_GENERAL;
  2064. int cache = 0; /* eventually, we may switch this to 1 */
  2065. char *cp = memchr(body, '\n', len);
  2066. smartlist_t *args = smartlist_create();
  2067. tor_assert(cp);
  2068. *cp++ = '\0';
  2069. smartlist_split_string(args, body, " ",
  2070. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  2071. SMARTLIST_FOREACH(args, char *, option,
  2072. {
  2073. if (!strcasecmpstart(option, "purpose=")) {
  2074. option += strlen("purpose=");
  2075. purpose = router_purpose_from_string(option);
  2076. if (purpose == ROUTER_PURPOSE_UNKNOWN) {
  2077. connection_printf_to_buf(conn, "552 Unknown purpose \"%s\"\r\n",
  2078. option);
  2079. goto done;
  2080. }
  2081. } else if (!strcasecmpstart(option, "cache=")) {
  2082. option += strlen("cache=");
  2083. if (!strcmp(option, "no"))
  2084. cache = 0;
  2085. else if (!strcmp(option, "yes"))
  2086. cache = 1;
  2087. else {
  2088. connection_printf_to_buf(conn, "552 Unknown cache request \"%s\"\r\n",
  2089. option);
  2090. goto done;
  2091. }
  2092. } else { /* unrecognized argument? */
  2093. connection_printf_to_buf(conn,
  2094. "512 Unexpected argument \"%s\" to postdescriptor\r\n", option);
  2095. goto done;
  2096. }
  2097. });
  2098. read_escaped_data(cp, len-(cp-body), &desc);
  2099. switch (router_load_single_router(desc, purpose, cache, &msg)) {
  2100. case -1:
  2101. if (!msg) msg = "Could not parse descriptor";
  2102. connection_printf_to_buf(conn, "554 %s\r\n", msg);
  2103. break;
  2104. case 0:
  2105. if (!msg) msg = "Descriptor not added";
  2106. connection_printf_to_buf(conn, "251 %s\r\n",msg);
  2107. break;
  2108. case 1:
  2109. send_control_done(conn);
  2110. break;
  2111. }
  2112. tor_free(desc);
  2113. done:
  2114. SMARTLIST_FOREACH(args, char *, arg, tor_free(arg));
  2115. smartlist_free(args);
  2116. return 0;
  2117. }
  2118. /** Called when we receive a REDIRECTSTERAM command. Try to change the target
  2119. * address of the named AP stream, and report success or failure. */
  2120. static int
  2121. handle_control_redirectstream(control_connection_t *conn, uint32_t len,
  2122. const char *body)
  2123. {
  2124. edge_connection_t *ap_conn = NULL;
  2125. char *new_addr = NULL;
  2126. uint16_t new_port = 0;
  2127. smartlist_t *args;
  2128. (void) len;
  2129. args = getargs_helper("REDIRECTSTREAM", conn, body, 2, -1);
  2130. if (!args)
  2131. return 0;
  2132. if (!(ap_conn = get_stream(smartlist_get(args, 0)))
  2133. || !ap_conn->socks_request) {
  2134. connection_printf_to_buf(conn, "552 Unknown stream \"%s\"\r\n",
  2135. (char*)smartlist_get(args, 0));
  2136. } else {
  2137. int ok;
  2138. if (smartlist_len(args) > 2) { /* they included a port too */
  2139. new_port = (uint16_t) tor_parse_ulong(smartlist_get(args, 2),
  2140. 10, 1, 65535, &ok, NULL);
  2141. }
  2142. if (!ok) {
  2143. connection_printf_to_buf(conn, "512 Cannot parse port \"%s\"\r\n",
  2144. (char*)smartlist_get(args, 2));
  2145. } else {
  2146. new_addr = tor_strdup(smartlist_get(args, 1));
  2147. }
  2148. }
  2149. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  2150. smartlist_free(args);
  2151. if (!new_addr)
  2152. return 0;
  2153. strlcpy(ap_conn->socks_request->address, new_addr,
  2154. sizeof(ap_conn->socks_request->address));
  2155. if (new_port)
  2156. ap_conn->socks_request->port = new_port;
  2157. tor_free(new_addr);
  2158. send_control_done(conn);
  2159. return 0;
  2160. }
  2161. /** Called when we get a CLOSESTREAM command; try to close the named stream
  2162. * and report success or failure. */
  2163. static int
  2164. handle_control_closestream(control_connection_t *conn, uint32_t len,
  2165. const char *body)
  2166. {
  2167. edge_connection_t *ap_conn=NULL;
  2168. uint8_t reason=0;
  2169. smartlist_t *args;
  2170. int ok;
  2171. (void) len;
  2172. args = getargs_helper("CLOSESTREAM", conn, body, 2, -1);
  2173. if (!args)
  2174. return 0;
  2175. else if (!(ap_conn = get_stream(smartlist_get(args, 0))))
  2176. connection_printf_to_buf(conn, "552 Unknown stream \"%s\"\r\n",
  2177. (char*)smartlist_get(args, 0));
  2178. else {
  2179. reason = (uint8_t) tor_parse_ulong(smartlist_get(args,1), 10, 0, 255,
  2180. &ok, NULL);
  2181. if (!ok) {
  2182. connection_printf_to_buf(conn, "552 Unrecognized reason \"%s\"\r\n",
  2183. (char*)smartlist_get(args, 1));
  2184. ap_conn = NULL;
  2185. }
  2186. }
  2187. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  2188. smartlist_free(args);
  2189. if (!ap_conn)
  2190. return 0;
  2191. connection_mark_unattached_ap(ap_conn, reason);
  2192. send_control_done(conn);
  2193. return 0;
  2194. }
  2195. /** Called when we get a CLOSECIRCUIT command; try to close the named circuit
  2196. * and report success or failure. */
  2197. static int
  2198. handle_control_closecircuit(control_connection_t *conn, uint32_t len,
  2199. const char *body)
  2200. {
  2201. origin_circuit_t *circ = NULL;
  2202. int safe = 0;
  2203. smartlist_t *args;
  2204. (void) len;
  2205. args = getargs_helper("CLOSECIRCUIT", conn, body, 1, -1);
  2206. if (!args)
  2207. return 0;
  2208. if (!(circ=get_circ(smartlist_get(args, 0))))
  2209. connection_printf_to_buf(conn, "552 Unknown circuit \"%s\"\r\n",
  2210. (char*)smartlist_get(args, 0));
  2211. else {
  2212. int i;
  2213. for (i=1; i < smartlist_len(args); ++i) {
  2214. if (!strcasecmp(smartlist_get(args, i), "IfUnused"))
  2215. safe = 1;
  2216. else
  2217. log_info(LD_CONTROL, "Skipping unknown option %s",
  2218. (char*)smartlist_get(args,i));
  2219. }
  2220. }
  2221. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  2222. smartlist_free(args);
  2223. if (!circ)
  2224. return 0;
  2225. if (!safe || !circ->p_streams) {
  2226. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_REQUESTED);
  2227. }
  2228. send_control_done(conn);
  2229. return 0;
  2230. }
  2231. /** Called when we get a RESOLVE command: start trying to resolve
  2232. * the listed addresses. */
  2233. static int
  2234. handle_control_resolve(control_connection_t *conn, uint32_t len,
  2235. const char *body)
  2236. {
  2237. smartlist_t *args;
  2238. int is_reverse = 0;
  2239. (void) len; /* body is nul-terminated; it's safe to ignore the length */
  2240. if (!(conn->event_mask & (1L<<EVENT_ADDRMAP))) {
  2241. log_warn(LD_CONTROL, "Controller asked us to resolve an address, but "
  2242. "isn't listening for ADDRMAP events. It probably won't see "
  2243. "the answer.");
  2244. }
  2245. args = smartlist_create();
  2246. smartlist_split_string(args, body, " ",
  2247. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  2248. if (smartlist_len(args) &&
  2249. !strcasecmp(smartlist_get(args, 0), "mode=reverse")) {
  2250. char *cp = smartlist_get(args, 0);
  2251. smartlist_del_keeporder(args, 0);
  2252. tor_free(cp);
  2253. is_reverse = 1;
  2254. }
  2255. SMARTLIST_FOREACH(args, const char *, arg, {
  2256. dnsserv_launch_request(arg, is_reverse);
  2257. });
  2258. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  2259. smartlist_free(args);
  2260. send_control_done(conn);
  2261. return 0;
  2262. }
  2263. /** Called when we get a PROTOCOLINFO command: send back a reply. */
  2264. static int
  2265. handle_control_protocolinfo(control_connection_t *conn, uint32_t len,
  2266. const char *body)
  2267. {
  2268. const char *bad_arg = NULL;
  2269. smartlist_t *args;
  2270. (void)len;
  2271. conn->have_sent_protocolinfo = 1;
  2272. args = smartlist_create();
  2273. smartlist_split_string(args, body, " ",
  2274. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  2275. SMARTLIST_FOREACH(args, const char *, arg, {
  2276. int ok;
  2277. tor_parse_long(arg, 10, 0, LONG_MAX, &ok, NULL);
  2278. if (!ok) {
  2279. bad_arg = arg;
  2280. break;
  2281. }
  2282. });
  2283. if (bad_arg) {
  2284. connection_printf_to_buf(conn, "513 No such version %s\r\n",
  2285. escaped(bad_arg));
  2286. /* Don't tolerate bad arguments when not authenticated. */
  2287. if (!STATE_IS_OPEN(TO_CONN(conn)->state))
  2288. connection_mark_for_close(TO_CONN(conn));
  2289. goto done;
  2290. } else {
  2291. or_options_t *options = get_options();
  2292. int cookies = options->CookieAuthentication;
  2293. char *cfile = get_cookie_file();
  2294. char *esc_cfile = esc_for_log(cfile);
  2295. char *methods;
  2296. {
  2297. int passwd = (options->HashedControlPassword != NULL);
  2298. smartlist_t *mlist = smartlist_create();
  2299. if (cookies)
  2300. smartlist_add(mlist, (char*)"COOKIE");
  2301. if (passwd)
  2302. smartlist_add(mlist, (char*)"HASHEDPASSWORD");
  2303. if (!cookies && !passwd)
  2304. smartlist_add(mlist, (char*)"NULL");
  2305. methods = smartlist_join_strings(mlist, ",", 0, NULL);
  2306. smartlist_free(mlist);
  2307. }
  2308. connection_printf_to_buf(conn,
  2309. "250-PROTOCOLINFO 1\r\n"
  2310. "250-AUTH METHODS=%s%s%s\r\n"
  2311. "250-VERSION Tor=%s\r\n"
  2312. "250 OK\r\n",
  2313. methods,
  2314. cookies?" COOKIEFILE=":"",
  2315. cookies?esc_cfile:"",
  2316. escaped(VERSION));
  2317. tor_free(methods);
  2318. tor_free(cfile);
  2319. tor_free(esc_cfile);
  2320. }
  2321. done:
  2322. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  2323. smartlist_free(args);
  2324. return 0;
  2325. }
  2326. /** Called when we get a USEFEATURE command: parse the feature list, and
  2327. * set up the control_connection's options properly. */
  2328. static int
  2329. handle_control_usefeature(control_connection_t *conn,
  2330. uint32_t len,
  2331. const char *body)
  2332. {
  2333. smartlist_t *args;
  2334. int verbose_names = 0, extended_events = 0;
  2335. int bad = 0;
  2336. (void) len; /* body is nul-terminated; it's safe to ignore the length */
  2337. args = smartlist_create();
  2338. smartlist_split_string(args, body, " ",
  2339. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  2340. SMARTLIST_FOREACH(args, const char *, arg, {
  2341. if (!strcasecmp(arg, "VERBOSE_NAMES"))
  2342. verbose_names = 1;
  2343. else if (!strcasecmp(arg, "EXTENDED_EVENTS")) /* <- documented */
  2344. extended_events = 1;
  2345. else if (!strcasecmp(arg, "EXTENDED_FORMAT")) {
  2346. /* remove this in 0.1.2.4; EXTENDED_FORMAT only ever worked for a
  2347. * little while during 0.1.2.2-alpha-dev. */
  2348. log_warn(LD_GENERAL,
  2349. "EXTENDED_FORMAT is deprecated; use EXTENDED_EVENTS "
  2350. "instead.");
  2351. extended_events = 1;
  2352. } else {
  2353. connection_printf_to_buf(conn, "552 Unrecognized feature \"%s\"\r\n",
  2354. arg);
  2355. bad = 1;
  2356. break;
  2357. }
  2358. });
  2359. if (!bad) {
  2360. if (verbose_names) {
  2361. conn->use_long_names = 1;
  2362. control_update_global_event_mask();
  2363. }
  2364. if (extended_events)
  2365. conn->use_extended_events = 1;
  2366. send_control_done(conn);
  2367. }
  2368. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  2369. smartlist_free(args);
  2370. return 0;
  2371. }
  2372. /** Called when <b>conn</b> has no more bytes left on its outbuf. */
  2373. int
  2374. connection_control_finished_flushing(control_connection_t *conn)
  2375. {
  2376. tor_assert(conn);
  2377. connection_stop_writing(TO_CONN(conn));
  2378. return 0;
  2379. }
  2380. /** Called when <b>conn</b> has gotten its socket closed. */
  2381. int
  2382. connection_control_reached_eof(control_connection_t *conn)
  2383. {
  2384. tor_assert(conn);
  2385. log_info(LD_CONTROL,"Control connection reached EOF. Closing.");
  2386. connection_mark_for_close(TO_CONN(conn));
  2387. return 0;
  2388. }
  2389. /** Return true iff <b>cmd</b> is allowable (or at least forgivable) at this
  2390. * stage of the protocol. */
  2391. static int
  2392. is_valid_initial_command(control_connection_t *conn, const char *cmd)
  2393. {
  2394. if (conn->_base.state == CONTROL_CONN_STATE_OPEN)
  2395. return 1;
  2396. if (!strcasecmp(cmd, "PROTOCOLINFO"))
  2397. return !conn->have_sent_protocolinfo;
  2398. if (!strcasecmp(cmd, "AUTHENTICATE") ||
  2399. !strcasecmp(cmd, "QUIT"))
  2400. return 1;
  2401. return 0;
  2402. }
  2403. /** Called when data has arrived on a v1 control connection: Try to fetch
  2404. * commands from conn->inbuf, and execute them.
  2405. */
  2406. int
  2407. connection_control_process_inbuf(control_connection_t *conn)
  2408. {
  2409. size_t data_len;
  2410. int cmd_len;
  2411. char *args;
  2412. tor_assert(conn);
  2413. tor_assert(conn->_base.state == CONTROL_CONN_STATE_OPEN ||
  2414. conn->_base.state == CONTROL_CONN_STATE_NEEDAUTH);
  2415. if (!conn->incoming_cmd) {
  2416. conn->incoming_cmd = tor_malloc(1024);
  2417. conn->incoming_cmd_len = 1024;
  2418. conn->incoming_cmd_cur_len = 0;
  2419. }
  2420. if (conn->_base.state == CONTROL_CONN_STATE_NEEDAUTH &&
  2421. peek_buf_has_control0_command(conn->_base.inbuf)) {
  2422. /* Detect v0 commands and send a "no more v0" message. */
  2423. size_t body_len;
  2424. char buf[128];
  2425. set_uint16(buf+2, htons(0x0000)); /* type == error */
  2426. set_uint16(buf+4, htons(0x0001)); /* code == internal error */
  2427. strlcpy(buf+6, "The v0 control protocol is not supported by Tor 0.1.2.17 "
  2428. "and later; upgrade your controller.",
  2429. sizeof(buf)-6);
  2430. body_len = 2+strlen(buf+6)+2; /* code, msg, nul. */
  2431. set_uint16(buf+0, htons(body_len));
  2432. connection_write_to_buf(buf, 4+body_len, TO_CONN(conn));
  2433. connection_mark_for_close(TO_CONN(conn));
  2434. conn->_base.hold_open_until_flushed = 1;
  2435. return 0;
  2436. }
  2437. again:
  2438. while (1) {
  2439. size_t last_idx;
  2440. int r;
  2441. /* First, fetch a line. */
  2442. do {
  2443. data_len = conn->incoming_cmd_len - conn->incoming_cmd_cur_len;
  2444. r = fetch_from_buf_line(conn->_base.inbuf,
  2445. conn->incoming_cmd+conn->incoming_cmd_cur_len,
  2446. &data_len);
  2447. if (r == 0)
  2448. /* Line not all here yet. Wait. */
  2449. return 0;
  2450. else if (r == -1) {
  2451. while (conn->incoming_cmd_len < data_len+conn->incoming_cmd_cur_len)
  2452. conn->incoming_cmd_len *= 2;
  2453. conn->incoming_cmd = tor_realloc(conn->incoming_cmd,
  2454. conn->incoming_cmd_len);
  2455. }
  2456. } while (r != 1);
  2457. tor_assert(data_len);
  2458. last_idx = conn->incoming_cmd_cur_len;
  2459. conn->incoming_cmd_cur_len += data_len;
  2460. /* We have appended a line to incoming_cmd. Is the command done? */
  2461. if (last_idx == 0 && *conn->incoming_cmd != '+')
  2462. /* One line command, didn't start with '+'. */
  2463. break;
  2464. /* XXXX this code duplication is kind of dumb. */
  2465. if (last_idx+3 == conn->incoming_cmd_cur_len &&
  2466. !memcmp(conn->incoming_cmd + last_idx, ".\r\n", 3)) {
  2467. /* Just appended ".\r\n"; we're done. Remove it. */
  2468. conn->incoming_cmd_cur_len -= 3;
  2469. break;
  2470. } else if (last_idx+2 == conn->incoming_cmd_cur_len &&
  2471. !memcmp(conn->incoming_cmd + last_idx, ".\n", 2)) {
  2472. /* Just appended ".\n"; we're done. Remove it. */
  2473. conn->incoming_cmd_cur_len -= 2;
  2474. break;
  2475. }
  2476. /* Otherwise, read another line. */
  2477. }
  2478. data_len = conn->incoming_cmd_cur_len;
  2479. /* Okay, we now have a command sitting on conn->incoming_cmd. See if we
  2480. * recognize it.
  2481. */
  2482. cmd_len = 0;
  2483. while ((size_t)cmd_len < data_len
  2484. && !TOR_ISSPACE(conn->incoming_cmd[cmd_len]))
  2485. ++cmd_len;
  2486. data_len -= cmd_len;
  2487. conn->incoming_cmd[cmd_len]='\0';
  2488. args = conn->incoming_cmd+cmd_len+1;
  2489. while (*args == ' ' || *args == '\t') {
  2490. ++args;
  2491. --data_len;
  2492. }
  2493. /* Quit is always valid. */
  2494. if (!strcasecmp(conn->incoming_cmd, "QUIT")) {
  2495. connection_write_str_to_buf("250 closing connection\r\n", conn);
  2496. connection_mark_for_close(TO_CONN(conn));
  2497. return 0;
  2498. }
  2499. if (conn->_base.state == CONTROL_CONN_STATE_NEEDAUTH &&
  2500. !is_valid_initial_command(conn, conn->incoming_cmd)) {
  2501. connection_write_str_to_buf("514 Authentication required.\r\n", conn);
  2502. connection_mark_for_close(TO_CONN(conn));
  2503. return 0;
  2504. }
  2505. if (!strcasecmp(conn->incoming_cmd, "SETCONF")) {
  2506. if (handle_control_setconf(conn, data_len, args))
  2507. return -1;
  2508. } else if (!strcasecmp(conn->incoming_cmd, "RESETCONF")) {
  2509. if (handle_control_resetconf(conn, data_len, args))
  2510. return -1;
  2511. } else if (!strcasecmp(conn->incoming_cmd, "GETCONF")) {
  2512. if (handle_control_getconf(conn, data_len, args))
  2513. return -1;
  2514. } else if (!strcasecmp(conn->incoming_cmd, "SETEVENTS")) {
  2515. if (handle_control_setevents(conn, data_len, args))
  2516. return -1;
  2517. } else if (!strcasecmp(conn->incoming_cmd, "AUTHENTICATE")) {
  2518. if (handle_control_authenticate(conn, data_len, args))
  2519. return -1;
  2520. } else if (!strcasecmp(conn->incoming_cmd, "SAVECONF")) {
  2521. if (handle_control_saveconf(conn, data_len, args))
  2522. return -1;
  2523. } else if (!strcasecmp(conn->incoming_cmd, "SIGNAL")) {
  2524. if (handle_control_signal(conn, data_len, args))
  2525. return -1;
  2526. } else if (!strcasecmp(conn->incoming_cmd, "MAPADDRESS")) {
  2527. if (handle_control_mapaddress(conn, data_len, args))
  2528. return -1;
  2529. } else if (!strcasecmp(conn->incoming_cmd, "GETINFO")) {
  2530. if (handle_control_getinfo(conn, data_len, args))
  2531. return -1;
  2532. } else if (!strcasecmp(conn->incoming_cmd, "EXTENDCIRCUIT")) {
  2533. if (handle_control_extendcircuit(conn, data_len, args))
  2534. return -1;
  2535. } else if (!strcasecmp(conn->incoming_cmd, "SETCIRCUITPURPOSE")) {
  2536. if (handle_control_setcircuitpurpose(conn, data_len, args))
  2537. return -1;
  2538. } else if (!strcasecmp(conn->incoming_cmd, "SETROUTERPURPOSE")) {
  2539. connection_write_str_to_buf("511 SETROUTERPURPOSE is obsolete.\r\n", conn);
  2540. } else if (!strcasecmp(conn->incoming_cmd, "ATTACHSTREAM")) {
  2541. if (handle_control_attachstream(conn, data_len, args))
  2542. return -1;
  2543. } else if (!strcasecmp(conn->incoming_cmd, "+POSTDESCRIPTOR")) {
  2544. if (handle_control_postdescriptor(conn, data_len, args))
  2545. return -1;
  2546. } else if (!strcasecmp(conn->incoming_cmd, "REDIRECTSTREAM")) {
  2547. if (handle_control_redirectstream(conn, data_len, args))
  2548. return -1;
  2549. } else if (!strcasecmp(conn->incoming_cmd, "CLOSESTREAM")) {
  2550. if (handle_control_closestream(conn, data_len, args))
  2551. return -1;
  2552. } else if (!strcasecmp(conn->incoming_cmd, "CLOSECIRCUIT")) {
  2553. if (handle_control_closecircuit(conn, data_len, args))
  2554. return -1;
  2555. } else if (!strcasecmp(conn->incoming_cmd, "USEFEATURE")) {
  2556. if (handle_control_usefeature(conn, data_len, args))
  2557. return -1;
  2558. } else if (!strcasecmp(conn->incoming_cmd, "RESOLVE")) {
  2559. if (handle_control_resolve(conn, data_len, args))
  2560. return -1;
  2561. } else if (!strcasecmp(conn->incoming_cmd, "PROTOCOLINFO")) {
  2562. if (handle_control_protocolinfo(conn, data_len, args))
  2563. return -1;
  2564. } else {
  2565. connection_printf_to_buf(conn, "510 Unrecognized command \"%s\"\r\n",
  2566. conn->incoming_cmd);
  2567. }
  2568. conn->incoming_cmd_cur_len = 0;
  2569. goto again;
  2570. }
  2571. /** Convert a numeric reason for destroying a circuit into a string for a
  2572. * CIRCUIT event. */
  2573. static const char *
  2574. circuit_end_reason_to_string(int reason)
  2575. {
  2576. if (reason >= 0 && reason & END_CIRC_REASON_FLAG_REMOTE)
  2577. reason &= ~END_CIRC_REASON_FLAG_REMOTE;
  2578. switch (reason) {
  2579. case END_CIRC_AT_ORIGIN:
  2580. /* This shouldn't get passed here; it's a catch-all reason. */
  2581. return "ORIGIN";
  2582. case END_CIRC_REASON_NONE:
  2583. /* This shouldn't get passed here; it's a catch-all reason. */
  2584. return "NONE";
  2585. case END_CIRC_REASON_TORPROTOCOL:
  2586. return "TORPROTOCOL";
  2587. case END_CIRC_REASON_INTERNAL:
  2588. return "INTERNAL";
  2589. case END_CIRC_REASON_REQUESTED:
  2590. return "REQUESTED";
  2591. case END_CIRC_REASON_HIBERNATING:
  2592. return "HIBERNATING";
  2593. case END_CIRC_REASON_RESOURCELIMIT:
  2594. return "RESOURCELIMIT";
  2595. case END_CIRC_REASON_CONNECTFAILED:
  2596. return "CONNECTFAILED";
  2597. case END_CIRC_REASON_OR_IDENTITY:
  2598. return "OR_IDENTITY";
  2599. case END_CIRC_REASON_OR_CONN_CLOSED:
  2600. return "OR_CONN_CLOSED";
  2601. case END_CIRC_REASON_FINISHED:
  2602. return "FINISHED";
  2603. case END_CIRC_REASON_TIMEOUT:
  2604. return "TIMEOUT";
  2605. case END_CIRC_REASON_DESTROYED:
  2606. return "DESTROYED";
  2607. case END_CIRC_REASON_NOPATH:
  2608. return "NOPATH";
  2609. case END_CIRC_REASON_NOSUCHSERVICE:
  2610. return "NOSUCHSERVICE";
  2611. default:
  2612. log_warn(LD_BUG, "Unrecognized reason code %d", (int)reason);
  2613. return NULL;
  2614. }
  2615. }
  2616. /** Something has happened to circuit <b>circ</b>: tell any interested
  2617. * control connections. */
  2618. int
  2619. control_event_circuit_status(origin_circuit_t *circ, circuit_status_event_t tp,
  2620. int reason_code)
  2621. {
  2622. const char *status;
  2623. char reason_buf[64];
  2624. int providing_reason=0;
  2625. char *path=NULL;
  2626. if (!EVENT_IS_INTERESTING(EVENT_CIRCUIT_STATUS))
  2627. return 0;
  2628. tor_assert(circ);
  2629. if (EVENT_IS_INTERESTING1S(EVENT_CIRCUIT_STATUS))
  2630. path = circuit_list_path(circ,0);
  2631. switch (tp)
  2632. {
  2633. case CIRC_EVENT_LAUNCHED: status = "LAUNCHED"; break;
  2634. case CIRC_EVENT_BUILT: status = "BUILT"; break;
  2635. case CIRC_EVENT_EXTENDED: status = "EXTENDED"; break;
  2636. case CIRC_EVENT_FAILED: status = "FAILED"; break;
  2637. case CIRC_EVENT_CLOSED: status = "CLOSED"; break;
  2638. default:
  2639. log_warn(LD_BUG, "Unrecognized status code %d", (int)tp);
  2640. return 0;
  2641. }
  2642. if (tp == CIRC_EVENT_FAILED || tp == CIRC_EVENT_CLOSED) {
  2643. const char *reason_str = circuit_end_reason_to_string(reason_code);
  2644. char *reason = NULL;
  2645. providing_reason=1;
  2646. if (!reason_str) {
  2647. reason = tor_malloc(16);
  2648. tor_snprintf(reason, 16, "UNKNOWN_%d", reason_code);
  2649. reason_str = reason;
  2650. }
  2651. if (reason_code > 0 && reason_code & END_CIRC_REASON_FLAG_REMOTE) {
  2652. tor_snprintf(reason_buf, sizeof(reason_buf),
  2653. "REASON=DESTROYED REMOTE_REASON=%s", reason_str);
  2654. } else {
  2655. tor_snprintf(reason_buf, sizeof(reason_buf),
  2656. "REASON=%s", reason_str);
  2657. }
  2658. tor_free(reason);
  2659. }
  2660. if (EVENT_IS_INTERESTING1S(EVENT_CIRCUIT_STATUS)) {
  2661. const char *sp = strlen(path) ? " " : "";
  2662. if (providing_reason)
  2663. send_control_event_extended(EVENT_CIRCUIT_STATUS, SHORT_NAMES,
  2664. "650 CIRC %lu %s%s%s@%s\r\n",
  2665. (unsigned long)circ->global_identifier,
  2666. status, sp, path, reason_buf);
  2667. else
  2668. send_control_event_extended(EVENT_CIRCUIT_STATUS, SHORT_NAMES,
  2669. "650 CIRC %lu %s%s%s\r\n",
  2670. (unsigned long)circ->global_identifier,
  2671. status, sp, path);
  2672. }
  2673. if (EVENT_IS_INTERESTING1L(EVENT_CIRCUIT_STATUS)) {
  2674. char *vpath = circuit_list_path_for_controller(circ);
  2675. const char *sp = strlen(vpath) ? " " : "";
  2676. if (providing_reason)
  2677. send_control_event_extended(EVENT_CIRCUIT_STATUS, LONG_NAMES,
  2678. "650 CIRC %lu %s%s%s@%s\r\n",
  2679. (unsigned long)circ->global_identifier,
  2680. status, sp, vpath, reason_buf);
  2681. else
  2682. send_control_event_extended(EVENT_CIRCUIT_STATUS, LONG_NAMES,
  2683. "650 CIRC %lu %s%s%s\r\n",
  2684. (unsigned long)circ->global_identifier,
  2685. status, sp, vpath);
  2686. tor_free(vpath);
  2687. }
  2688. tor_free(path);
  2689. return 0;
  2690. }
  2691. /** Given an AP connection <b>conn</b> and a <b>len</b>-character buffer
  2692. * <b>buf</b>, determine the address:port combination requested on
  2693. * <b>conn</b>, and write it to <b>buf</b>. Return 0 on success, -1 on
  2694. * failure. */
  2695. static int
  2696. write_stream_target_to_buf(edge_connection_t *conn, char *buf, size_t len)
  2697. {
  2698. char buf2[256];
  2699. if (conn->chosen_exit_name)
  2700. if (tor_snprintf(buf2, sizeof(buf2), ".%s.exit", conn->chosen_exit_name)<0)
  2701. return -1;
  2702. if (tor_snprintf(buf, len, "%s%s%s:%d",
  2703. conn->socks_request->address,
  2704. conn->chosen_exit_name ? buf2 : "",
  2705. !conn->chosen_exit_name &&
  2706. connection_edge_is_rendezvous_stream(conn) ? ".onion" : "",
  2707. conn->socks_request->port)<0)
  2708. return -1;
  2709. return 0;
  2710. }
  2711. /** Convert the reason for ending a stream <b>reason</b> into the format used
  2712. * in STREAM events. Return NULL if the reason is unrecognized. */
  2713. static const char *
  2714. stream_end_reason_to_string(int reason)
  2715. {
  2716. reason &= END_STREAM_REASON_MASK;
  2717. switch (reason) {
  2718. case END_STREAM_REASON_MISC: return "MISC";
  2719. case END_STREAM_REASON_RESOLVEFAILED: return "RESOLVEFAILED";
  2720. case END_STREAM_REASON_CONNECTREFUSED: return "CONNECTREFUSED";
  2721. case END_STREAM_REASON_EXITPOLICY: return "EXITPOLICY";
  2722. case END_STREAM_REASON_DESTROY: return "DESTROY";
  2723. case END_STREAM_REASON_DONE: return "DONE";
  2724. case END_STREAM_REASON_TIMEOUT: return "TIMEOUT";
  2725. case END_STREAM_REASON_HIBERNATING: return "HIBERNATING";
  2726. case END_STREAM_REASON_INTERNAL: return "INTERNAL";
  2727. case END_STREAM_REASON_RESOURCELIMIT: return "RESOURCELIMIT";
  2728. case END_STREAM_REASON_CONNRESET: return "CONNRESET";
  2729. case END_STREAM_REASON_TORPROTOCOL: return "TORPROTOCOL";
  2730. case END_STREAM_REASON_NOTDIRECTORY: return "NOTDIRECTORY";
  2731. case END_STREAM_REASON_CANT_ATTACH: return "CANT_ATTACH";
  2732. case END_STREAM_REASON_NET_UNREACHABLE: return "NET_UNREACHABLE";
  2733. case END_STREAM_REASON_SOCKSPROTOCOL: return "SOCKS_PROTOCOL";
  2734. default: return NULL;
  2735. }
  2736. }
  2737. /** Something has happened to the stream associated with AP connection
  2738. * <b>conn</b>: tell any interested control connections. */
  2739. int
  2740. control_event_stream_status(edge_connection_t *conn, stream_status_event_t tp,
  2741. int reason_code)
  2742. {
  2743. char reason_buf[64];
  2744. char addrport_buf[64];
  2745. const char *status;
  2746. circuit_t *circ;
  2747. origin_circuit_t *origin_circ = NULL;
  2748. char buf[256];
  2749. tor_assert(conn->socks_request);
  2750. if (!EVENT_IS_INTERESTING(EVENT_STREAM_STATUS))
  2751. return 0;
  2752. if (tp == STREAM_EVENT_CLOSED &&
  2753. (reason_code & END_STREAM_REASON_FLAG_ALREADY_SENT_CLOSED))
  2754. return 0;
  2755. write_stream_target_to_buf(conn, buf, sizeof(buf));
  2756. reason_buf[0] = '\0';
  2757. switch (tp)
  2758. {
  2759. case STREAM_EVENT_SENT_CONNECT: status = "SENTCONNECT"; break;
  2760. case STREAM_EVENT_SENT_RESOLVE: status = "SENTRESOLVE"; break;
  2761. case STREAM_EVENT_SUCCEEDED: status = "SUCCEEDED"; break;
  2762. case STREAM_EVENT_FAILED: status = "FAILED"; break;
  2763. case STREAM_EVENT_CLOSED: status = "CLOSED"; break;
  2764. case STREAM_EVENT_NEW: status = "NEW"; break;
  2765. case STREAM_EVENT_NEW_RESOLVE: status = "NEWRESOLVE"; break;
  2766. case STREAM_EVENT_FAILED_RETRIABLE: status = "DETACHED"; break;
  2767. case STREAM_EVENT_REMAP: status = "REMAP"; break;
  2768. default:
  2769. log_warn(LD_BUG, "Unrecognized status code %d", (int)tp);
  2770. return 0;
  2771. }
  2772. if (reason_code && (tp == STREAM_EVENT_FAILED ||
  2773. tp == STREAM_EVENT_CLOSED ||
  2774. tp == STREAM_EVENT_FAILED_RETRIABLE)) {
  2775. const char *reason_str = stream_end_reason_to_string(reason_code);
  2776. char *r = NULL;
  2777. if (!reason_str) {
  2778. r = tor_malloc(16);
  2779. tor_snprintf(r, 16, "UNKNOWN_%d", reason_code);
  2780. reason_str = r;
  2781. }
  2782. if (reason_code & END_STREAM_REASON_FLAG_REMOTE)
  2783. tor_snprintf(reason_buf, sizeof(reason_buf),
  2784. "REASON=END REMOTE_REASON=%s", reason_str);
  2785. else
  2786. tor_snprintf(reason_buf, sizeof(reason_buf),
  2787. "REASON=%s", reason_str);
  2788. tor_free(r);
  2789. } else if (reason_code && tp == STREAM_EVENT_REMAP) {
  2790. switch (reason_code) {
  2791. case REMAP_STREAM_SOURCE_CACHE:
  2792. strlcpy(reason_buf, "SOURCE=CACHE", sizeof(reason_buf));
  2793. break;
  2794. case REMAP_STREAM_SOURCE_EXIT:
  2795. strlcpy(reason_buf, "SOURCE=EXIT", sizeof(reason_buf));
  2796. break;
  2797. default:
  2798. tor_snprintf(reason_buf, sizeof(reason_buf), "REASON=UNKNOWN_%d",
  2799. reason_code);
  2800. break;
  2801. }
  2802. }
  2803. if (tp == STREAM_EVENT_NEW) {
  2804. tor_snprintf(addrport_buf,sizeof(addrport_buf), "%sSOURCE_ADDR=%s:%d",
  2805. strlen(reason_buf) ? " " : "",
  2806. TO_CONN(conn)->address, TO_CONN(conn)->port );
  2807. } else {
  2808. addrport_buf[0] = '\0';
  2809. }
  2810. circ = circuit_get_by_edge_conn(conn);
  2811. if (circ && CIRCUIT_IS_ORIGIN(circ))
  2812. origin_circ = TO_ORIGIN_CIRCUIT(circ);
  2813. send_control_event_extended(EVENT_STREAM_STATUS, ALL_NAMES,
  2814. "650 STREAM %lu %s %lu %s@%s%s\r\n",
  2815. (unsigned long)conn->global_identifier, status,
  2816. origin_circ?
  2817. (unsigned long)origin_circ->global_identifier : 0ul,
  2818. buf, reason_buf, addrport_buf);
  2819. /* XXX need to specify its intended exit, etc? */
  2820. return 0;
  2821. }
  2822. /** Figure out the best name for the target router of an OR connection
  2823. * <b>conn</b>, and write it into the <b>len</b>-character buffer
  2824. * <b>name</b>. Use verbose names if <b>long_names</b> is set. */
  2825. static void
  2826. orconn_target_get_name(int long_names,
  2827. char *name, size_t len, or_connection_t *conn)
  2828. {
  2829. if (! long_names) {
  2830. if (conn->nickname)
  2831. strlcpy(name, conn->nickname, len);
  2832. else
  2833. tor_snprintf(name, len, "%s:%d",
  2834. conn->_base.address, conn->_base.port);
  2835. } else {
  2836. routerinfo_t *ri = router_get_by_digest(conn->identity_digest);
  2837. if (ri) {
  2838. tor_assert(len > MAX_VERBOSE_NICKNAME_LEN);
  2839. router_get_verbose_nickname(name, ri);
  2840. } else if (! tor_digest_is_zero(conn->identity_digest)) {
  2841. name[0] = '$';
  2842. base16_encode(name+1, len-1, conn->identity_digest,
  2843. DIGEST_LEN);
  2844. } else {
  2845. tor_snprintf(name, len, "%s:%d",
  2846. conn->_base.address, conn->_base.port);
  2847. }
  2848. }
  2849. }
  2850. /** Convert a TOR_TLS_* error code into an END_OR_CONN_* reason. */
  2851. int
  2852. control_tls_error_to_reason(int e)
  2853. {
  2854. switch (e) {
  2855. case TOR_TLS_ERROR_IO:
  2856. return END_OR_CONN_REASON_TLS_IO_ERROR;
  2857. case TOR_TLS_ERROR_CONNREFUSED:
  2858. return END_OR_CONN_REASON_TCP_REFUSED;
  2859. case TOR_TLS_ERROR_CONNRESET:
  2860. return END_OR_CONN_REASON_TLS_CONNRESET;
  2861. case TOR_TLS_ERROR_NO_ROUTE:
  2862. return END_OR_CONN_REASON_TLS_NO_ROUTE;
  2863. case TOR_TLS_ERROR_TIMEOUT:
  2864. return END_OR_CONN_REASON_TLS_TIMEOUT;
  2865. case TOR_TLS_WANTREAD:
  2866. case TOR_TLS_WANTWRITE:
  2867. case TOR_TLS_CLOSE:
  2868. case TOR_TLS_DONE:
  2869. return END_OR_CONN_REASON_DONE;
  2870. default:
  2871. return END_OR_CONN_REASON_TLS_MISC;
  2872. }
  2873. }
  2874. /** Convert the reason for ending an OR connection <b>r</b> into the format
  2875. * used in ORCONN events. Return NULL if the reason is unrecognized. */
  2876. static const char *
  2877. or_conn_end_reason_to_string(int r)
  2878. {
  2879. switch (r) {
  2880. case END_OR_CONN_REASON_DONE:
  2881. return "REASON=DONE";
  2882. case END_OR_CONN_REASON_TCP_REFUSED:
  2883. return "REASON=CONNECTREFUSED";
  2884. case END_OR_CONN_REASON_OR_IDENTITY:
  2885. return "REASON=IDENTITY";
  2886. case END_OR_CONN_REASON_TLS_CONNRESET:
  2887. return "REASON=CONNECTRESET";
  2888. case END_OR_CONN_REASON_TLS_TIMEOUT:
  2889. return "REASON=TIMEOUT";
  2890. case END_OR_CONN_REASON_TLS_NO_ROUTE:
  2891. return "REASON=NOROUTE";
  2892. case END_OR_CONN_REASON_TLS_IO_ERROR:
  2893. return "REASON=IOERROR";
  2894. case END_OR_CONN_REASON_TLS_MISC:
  2895. return "REASON=MISC";
  2896. case 0:
  2897. return "";
  2898. default:
  2899. log_warn(LD_BUG, "Unrecognized or_conn reason code %d", r);
  2900. return "REASON=BOGUS";
  2901. }
  2902. }
  2903. /** Called when the status of an OR connection <b>conn</b> changes: tell any
  2904. * interested control connections. <b>tp</b> is the new status for the
  2905. * connection. If <b>conn</b> has just closed or failed, then <b>reason</b>
  2906. * may be the reason why.
  2907. */
  2908. int
  2909. control_event_or_conn_status(or_connection_t *conn, or_conn_status_event_t tp,
  2910. int reason)
  2911. {
  2912. int ncircs = 0;
  2913. const char *status;
  2914. char name[128];
  2915. char ncircs_buf[32] = {0}; /* > 8 + log10(2^32)=10 + 2 */
  2916. if (!EVENT_IS_INTERESTING(EVENT_OR_CONN_STATUS))
  2917. return 0;
  2918. switch (tp)
  2919. {
  2920. case OR_CONN_EVENT_LAUNCHED: status = "LAUNCHED"; break;
  2921. case OR_CONN_EVENT_CONNECTED: status = "CONNECTED"; break;
  2922. case OR_CONN_EVENT_FAILED: status = "FAILED"; break;
  2923. case OR_CONN_EVENT_CLOSED: status = "CLOSED"; break;
  2924. case OR_CONN_EVENT_NEW: status = "NEW"; break;
  2925. default:
  2926. log_warn(LD_BUG, "Unrecognized status code %d", (int)tp);
  2927. return 0;
  2928. }
  2929. ncircs = circuit_count_pending_on_or_conn(conn);
  2930. ncircs += conn->n_circuits;
  2931. if (ncircs && (tp == OR_CONN_EVENT_FAILED || tp == OR_CONN_EVENT_CLOSED)) {
  2932. tor_snprintf(ncircs_buf, sizeof(ncircs_buf), "%sNCIRCS=%d",
  2933. reason ? " " : "", ncircs);
  2934. }
  2935. if (EVENT_IS_INTERESTING1S(EVENT_OR_CONN_STATUS)) {
  2936. orconn_target_get_name(0, name, sizeof(name), conn);
  2937. send_control_event_extended(EVENT_OR_CONN_STATUS, SHORT_NAMES,
  2938. "650 ORCONN %s %s@%s%s\r\n",
  2939. name, status,
  2940. or_conn_end_reason_to_string(reason), ncircs_buf);
  2941. }
  2942. if (EVENT_IS_INTERESTING1L(EVENT_OR_CONN_STATUS)) {
  2943. orconn_target_get_name(1, name, sizeof(name), conn);
  2944. send_control_event_extended(EVENT_OR_CONN_STATUS, LONG_NAMES,
  2945. "650 ORCONN %s %s@%s%s\r\n",
  2946. name, status,
  2947. or_conn_end_reason_to_string(reason), ncircs_buf);
  2948. }
  2949. return 0;
  2950. }
  2951. /** A second or more has elapsed: tell any interested control
  2952. * connections how much bandwidth streams have used. */
  2953. int
  2954. control_event_stream_bandwidth_used(void)
  2955. {
  2956. if (EVENT_IS_INTERESTING(EVENT_STREAM_BANDWIDTH_USED)) {
  2957. smartlist_t *conns = get_connection_array();
  2958. edge_connection_t *edge_conn;
  2959. SMARTLIST_FOREACH(conns, connection_t *, conn,
  2960. {
  2961. if (conn->type != CONN_TYPE_AP)
  2962. continue;
  2963. edge_conn = TO_EDGE_CONN(conn);
  2964. if (!edge_conn->n_read && !edge_conn->n_written)
  2965. continue;
  2966. send_control_event(EVENT_STREAM_BANDWIDTH_USED, ALL_NAMES,
  2967. "650 STREAM_BW %lu %lu %lu\r\n",
  2968. (unsigned long)edge_conn->global_identifier,
  2969. (unsigned long)edge_conn->n_read,
  2970. (unsigned long)edge_conn->n_written);
  2971. edge_conn->n_written = edge_conn->n_read = 0;
  2972. });
  2973. }
  2974. return 0;
  2975. }
  2976. /** A second or more has elapsed: tell any interested control
  2977. * connections how much bandwidth we used. */
  2978. int
  2979. control_event_bandwidth_used(uint32_t n_read, uint32_t n_written)
  2980. {
  2981. if (EVENT_IS_INTERESTING(EVENT_BANDWIDTH_USED)) {
  2982. send_control_event(EVENT_BANDWIDTH_USED, ALL_NAMES,
  2983. "650 BW %lu %lu\r\n",
  2984. (unsigned long)n_read,
  2985. (unsigned long)n_written);
  2986. }
  2987. return 0;
  2988. }
  2989. /** Called when we are sending a log message to the controllers: suspend
  2990. * sending further log messages to the controllers until we're done. Used by
  2991. * CONN_LOG_PROTECT. */
  2992. void
  2993. disable_control_logging(void)
  2994. {
  2995. ++disable_log_messages;
  2996. }
  2997. /** We're done sending a log message to the controllers: re-enable controller
  2998. * logging. Used by CONN_LOG_PROTECT. */
  2999. void
  3000. enable_control_logging(void)
  3001. {
  3002. if (--disable_log_messages < 0)
  3003. tor_assert(0);
  3004. }
  3005. /** We got a log message: tell any interested control connections. */
  3006. void
  3007. control_event_logmsg(int severity, uint32_t domain, const char *msg)
  3008. {
  3009. int event;
  3010. if (disable_log_messages)
  3011. return;
  3012. if (domain == LD_BUG && EVENT_IS_INTERESTING(EVENT_STATUS_GENERAL) &&
  3013. severity <= LOG_NOTICE) {
  3014. char *esc = esc_for_log(msg);
  3015. ++disable_log_messages;
  3016. control_event_general_status(severity, "BUG REASON=\"%s\"", esc);
  3017. --disable_log_messages;
  3018. tor_free(esc);
  3019. }
  3020. event = log_severity_to_event(severity);
  3021. if (event >= 0 && EVENT_IS_INTERESTING(event)) {
  3022. char *b = NULL;
  3023. const char *s;
  3024. if (strchr(msg, '\n')) {
  3025. char *cp;
  3026. b = tor_strdup(msg);
  3027. for (cp = b; *cp; ++cp)
  3028. if (*cp == '\r' || *cp == '\n')
  3029. *cp = ' ';
  3030. }
  3031. switch (severity) {
  3032. case LOG_DEBUG: s = "DEBUG"; break;
  3033. case LOG_INFO: s = "INFO"; break;
  3034. case LOG_NOTICE: s = "NOTICE"; break;
  3035. case LOG_WARN: s = "WARN"; break;
  3036. case LOG_ERR: s = "ERR"; break;
  3037. default: s = "UnknownLogSeverity"; break;
  3038. }
  3039. ++disable_log_messages;
  3040. send_control_event(event, ALL_NAMES, "650 %s %s\r\n", s, b?b:msg);
  3041. --disable_log_messages;
  3042. tor_free(b);
  3043. }
  3044. }
  3045. /** Called whenever we receive new router descriptors: tell any
  3046. * interested control connections. <b>routers</b> is a list of
  3047. * routerinfo_t's.
  3048. */
  3049. int
  3050. control_event_descriptors_changed(smartlist_t *routers)
  3051. {
  3052. size_t len;
  3053. char *msg;
  3054. smartlist_t *identities = NULL;
  3055. char buf[HEX_DIGEST_LEN+1];
  3056. if (!EVENT_IS_INTERESTING(EVENT_NEW_DESC))
  3057. return 0;
  3058. if (EVENT_IS_INTERESTING1S(EVENT_NEW_DESC)) {
  3059. identities = smartlist_create();
  3060. SMARTLIST_FOREACH(routers, routerinfo_t *, r,
  3061. {
  3062. base16_encode(buf,sizeof(buf),r->cache_info.identity_digest,DIGEST_LEN);
  3063. smartlist_add(identities, tor_strdup(buf));
  3064. });
  3065. }
  3066. if (EVENT_IS_INTERESTING1S(EVENT_NEW_DESC)) {
  3067. char *ids = smartlist_join_strings(identities, " ", 0, &len);
  3068. size_t ids_len = strlen(ids)+32;
  3069. msg = tor_malloc(ids_len);
  3070. tor_snprintf(msg, ids_len, "650 NEWDESC %s\r\n", ids);
  3071. send_control_event_string(EVENT_NEW_DESC, SHORT_NAMES|ALL_FORMATS, msg);
  3072. tor_free(ids);
  3073. tor_free(msg);
  3074. }
  3075. if (EVENT_IS_INTERESTING1L(EVENT_NEW_DESC)) {
  3076. smartlist_t *names = smartlist_create();
  3077. char *ids;
  3078. size_t names_len;
  3079. SMARTLIST_FOREACH(routers, routerinfo_t *, ri, {
  3080. char *b = tor_malloc(MAX_VERBOSE_NICKNAME_LEN+1);
  3081. router_get_verbose_nickname(b, ri);
  3082. smartlist_add(names, b);
  3083. });
  3084. ids = smartlist_join_strings(names, " ", 0, &names_len);
  3085. names_len = strlen(ids)+32;
  3086. msg = tor_malloc(names_len);
  3087. tor_snprintf(msg, names_len, "650 NEWDESC %s\r\n", ids);
  3088. send_control_event_string(EVENT_NEW_DESC, LONG_NAMES|ALL_FORMATS, msg);
  3089. tor_free(ids);
  3090. tor_free(msg);
  3091. SMARTLIST_FOREACH(names, char *, cp, tor_free(cp));
  3092. smartlist_free(names);
  3093. }
  3094. if (identities) {
  3095. SMARTLIST_FOREACH(identities, char *, cp, tor_free(cp));
  3096. smartlist_free(identities);
  3097. }
  3098. return 0;
  3099. }
  3100. /** Called whenever an address mapping on <b>from<b> from changes to <b>to</b>.
  3101. * <b>expires</b> values less than 3 are special; see connection_edge.c. If
  3102. * <b>error</b> is non-NULL, it is an error code describing the failure
  3103. * mode of the mapping.
  3104. */
  3105. int
  3106. control_event_address_mapped(const char *from, const char *to, time_t expires,
  3107. const char *error)
  3108. {
  3109. if (!EVENT_IS_INTERESTING(EVENT_ADDRMAP))
  3110. return 0;
  3111. if (expires < 3 || expires == TIME_MAX)
  3112. send_control_event_extended(EVENT_ADDRMAP, ALL_NAMES,
  3113. "650 ADDRMAP %s %s NEVER@%s\r\n", from, to,
  3114. error?error:"");
  3115. else {
  3116. char buf[ISO_TIME_LEN+1];
  3117. char buf2[ISO_TIME_LEN+1];
  3118. format_local_iso_time(buf,expires);
  3119. format_iso_time(buf2,expires);
  3120. send_control_event_extended(EVENT_ADDRMAP, ALL_NAMES,
  3121. "650 ADDRMAP %s %s \"%s\""
  3122. "@%s%sEXPIRES=\"%s\"\r\n",
  3123. from, to, buf,
  3124. error?error:"", error?" ":"",
  3125. buf2);
  3126. }
  3127. return 0;
  3128. }
  3129. /** The authoritative dirserver has received a new descriptor that
  3130. * has passed basic syntax checks and is properly self-signed.
  3131. *
  3132. * Notify any interested party of the new descriptor and what has
  3133. * been done with it, and also optionally give an explanation/reason. */
  3134. int
  3135. control_event_or_authdir_new_descriptor(const char *action,
  3136. const char *desc, size_t desclen,
  3137. const char *msg)
  3138. {
  3139. char firstline[1024];
  3140. char *buf;
  3141. int totallen;
  3142. char *esc = NULL;
  3143. size_t esclen;
  3144. if (!EVENT_IS_INTERESTING(EVENT_AUTHDIR_NEWDESCS))
  3145. return 0;
  3146. tor_snprintf(firstline, sizeof(firstline),
  3147. "650+AUTHDIR_NEWDESC=\r\n%s\r\n%s\r\n",
  3148. action,
  3149. msg ? msg : "");
  3150. /* Escape the server descriptor properly */
  3151. esclen = write_escaped_data(desc, desclen, &esc);
  3152. totallen = strlen(firstline) + esclen + 1;
  3153. buf = tor_malloc(totallen);
  3154. strlcpy(buf, firstline, totallen);
  3155. strlcpy(buf+strlen(firstline), esc, totallen);
  3156. send_control_event_string(EVENT_AUTHDIR_NEWDESCS, ALL_NAMES|ALL_FORMATS,
  3157. buf);
  3158. send_control_event_string(EVENT_AUTHDIR_NEWDESCS, ALL_NAMES|ALL_FORMATS,
  3159. "650 OK\r\n");
  3160. tor_free(esc);
  3161. tor_free(buf);
  3162. return 0;
  3163. }
  3164. /** Called when the routerstatus_ts <b>statuses</b> have changed: sends
  3165. * an NS event to any controller that cares. */
  3166. int
  3167. control_event_networkstatus_changed(smartlist_t *statuses)
  3168. {
  3169. smartlist_t *strs;
  3170. char *s, *esc = NULL;
  3171. if (!EVENT_IS_INTERESTING(EVENT_NS) || !smartlist_len(statuses))
  3172. return 0;
  3173. strs = smartlist_create();
  3174. smartlist_add(strs, tor_strdup("650+NS\r\n"));
  3175. SMARTLIST_FOREACH(statuses, routerstatus_t *, rs,
  3176. {
  3177. s = networkstatus_getinfo_helper_single(rs);
  3178. if (!s) continue;
  3179. smartlist_add(strs, s);
  3180. });
  3181. s = smartlist_join_strings(strs, "", 0, NULL);
  3182. write_escaped_data(s, strlen(s), &esc);
  3183. SMARTLIST_FOREACH(strs, char *, cp, tor_free(cp));
  3184. smartlist_free(strs);
  3185. tor_free(s);
  3186. send_control_event_string(EVENT_NS, ALL_NAMES|ALL_FORMATS, esc);
  3187. send_control_event_string(EVENT_NS, ALL_NAMES|ALL_FORMATS,
  3188. "650 OK\r\n");
  3189. tor_free(esc);
  3190. return 0;
  3191. }
  3192. /** Called when a single local_routerstatus_t has changed: Sends an NS event
  3193. * to any countroller that cares. */
  3194. int
  3195. control_event_networkstatus_changed_single(routerstatus_t *rs)
  3196. {
  3197. smartlist_t *statuses;
  3198. int r;
  3199. if (!EVENT_IS_INTERESTING(EVENT_NS))
  3200. return 0;
  3201. statuses = smartlist_create();
  3202. smartlist_add(statuses, rs);
  3203. r = control_event_networkstatus_changed(statuses);
  3204. smartlist_free(statuses);
  3205. return r;
  3206. }
  3207. /** Our own router descriptor has changed; tell any controllers that care.
  3208. */
  3209. int
  3210. control_event_my_descriptor_changed(void)
  3211. {
  3212. send_control_event(EVENT_DESCCHANGED, ALL_NAMES, "650 DESCCHANGED\r\n");
  3213. return 0;
  3214. }
  3215. /** Helper: sends a status event where <b>type</b> is one of
  3216. * EVENT_STATUS_{GENERAL,CLIENT,SERVER}, where <b>severity</b> is one of
  3217. * LOG_{NOTICE,WARN,ERR}, and where <b>format</b> is a printf-style format
  3218. * string corresponding to <b>args</b>. */
  3219. static int
  3220. control_event_status(int type, int severity, const char *format, va_list args)
  3221. {
  3222. char format_buf[160];
  3223. const char *status, *sev;
  3224. switch (type) {
  3225. case EVENT_STATUS_GENERAL:
  3226. status = "STATUS_GENERAL";
  3227. break;
  3228. case EVENT_STATUS_CLIENT:
  3229. status = "STATUS_CLIENT";
  3230. break;
  3231. case EVENT_STATUS_SERVER:
  3232. status = "STATUS_SEVER";
  3233. break;
  3234. default:
  3235. log_warn(LD_BUG, "Unrecognized status type %d", type);
  3236. return -1;
  3237. }
  3238. switch (severity) {
  3239. case LOG_NOTICE:
  3240. sev = "NOTICE";
  3241. break;
  3242. case LOG_WARN:
  3243. sev = "WARN";
  3244. break;
  3245. case LOG_ERR:
  3246. sev = "ERR";
  3247. break;
  3248. default:
  3249. log_warn(LD_BUG, "Unrecognized status severity %d", severity);
  3250. return -1;
  3251. }
  3252. if (tor_snprintf(format_buf, sizeof(format_buf), "650 %s %s %s\r\n",
  3253. status, sev, format)<0) {
  3254. log_warn(LD_BUG, "Format string too long.");
  3255. return -1;
  3256. }
  3257. send_control_event_impl(type, ALL_NAMES|ALL_FORMATS, 0, format_buf, args);
  3258. return 0;
  3259. }
  3260. /** Format and send an EVENT_STATUS_GENERAL event whose main text is obtained
  3261. * by formatting the arguments using the printf-style <b>format</b>. */
  3262. int
  3263. control_event_general_status(int severity, const char *format, ...)
  3264. {
  3265. va_list ap;
  3266. int r;
  3267. if (!EVENT_IS_INTERESTING(EVENT_STATUS_GENERAL))
  3268. return 0;
  3269. va_start(ap, format);
  3270. r = control_event_status(EVENT_STATUS_GENERAL, severity, format, ap);
  3271. va_end(ap);
  3272. return r;
  3273. }
  3274. /** Format and send an EVENT_STATUS_CLIENT event whose main text is obtained
  3275. * by formatting the arguments using the printf-style <b>format</b>. */
  3276. int
  3277. control_event_client_status(int severity, const char *format, ...)
  3278. {
  3279. va_list ap;
  3280. int r;
  3281. if (!EVENT_IS_INTERESTING(EVENT_STATUS_CLIENT))
  3282. return 0;
  3283. va_start(ap, format);
  3284. r = control_event_status(EVENT_STATUS_CLIENT, severity, format, ap);
  3285. va_end(ap);
  3286. return r;
  3287. }
  3288. /** Format and send an EVENT_STATUS_SERVER event whose main text is obtained
  3289. * by formatting the arguments using the printf-style <b>format</b>. */
  3290. int
  3291. control_event_server_status(int severity, const char *format, ...)
  3292. {
  3293. va_list ap;
  3294. int r;
  3295. if (!EVENT_IS_INTERESTING(EVENT_STATUS_SERVER))
  3296. return 0;
  3297. va_start(ap, format);
  3298. r = control_event_status(EVENT_STATUS_SERVER, severity, format, ap);
  3299. va_end(ap);
  3300. return r;
  3301. }
  3302. /** Called when the status of an entry guard with the given <b>nickname</b>
  3303. * and identity <b>digest</b> has changed to <b>status</b>: tells any
  3304. * controllers that care. */
  3305. int
  3306. control_event_guard(const char *nickname, const char *digest,
  3307. const char *status)
  3308. {
  3309. char hbuf[HEX_DIGEST_LEN+1];
  3310. base16_encode(hbuf, sizeof(hbuf), digest, DIGEST_LEN);
  3311. if (!EVENT_IS_INTERESTING(EVENT_GUARD))
  3312. return 0;
  3313. if (EVENT_IS_INTERESTING1L(EVENT_GUARD)) {
  3314. char buf[MAX_VERBOSE_NICKNAME_LEN+1];
  3315. routerinfo_t *ri = router_get_by_digest(digest);
  3316. if (ri) {
  3317. router_get_verbose_nickname(buf, ri);
  3318. } else {
  3319. tor_snprintf(buf, sizeof(buf), "$%s~%s", hbuf, nickname);
  3320. }
  3321. send_control_event(EVENT_GUARD, LONG_NAMES,
  3322. "650 GUARD ENTRY %s %s\r\n", buf, status);
  3323. }
  3324. if (EVENT_IS_INTERESTING1S(EVENT_GUARD)) {
  3325. send_control_event(EVENT_GUARD, SHORT_NAMES,
  3326. "650 GUARD ENTRY $%s %s\r\n", hbuf, status);
  3327. }
  3328. return 0;
  3329. }
  3330. /** Helper: Return a newly allocated string containing a path to the
  3331. * file where we store our authentication cookie. */
  3332. static char *
  3333. get_cookie_file(void)
  3334. {
  3335. or_options_t *options = get_options();
  3336. if (options->CookieAuthFile && strlen(options->CookieAuthFile)) {
  3337. return tor_strdup(options->CookieAuthFile);
  3338. } else {
  3339. return get_datadir_fname("control_auth_cookie");
  3340. }
  3341. }
  3342. /** Choose a random authentication cookie and write it to disk.
  3343. * Anybody who can read the cookie from disk will be considered
  3344. * authorized to use the control connection. Return -1 if we can't
  3345. * write the file, or 0 on success. */
  3346. int
  3347. init_cookie_authentication(int enabled)
  3348. {
  3349. char *fname;
  3350. if (!enabled) {
  3351. authentication_cookie_is_set = 0;
  3352. return 0;
  3353. }
  3354. /* We don't want to generate a new cookie every time we call
  3355. * options_act(). One should be enough. */
  3356. if (authentication_cookie_is_set)
  3357. return 0; /* all set */
  3358. fname = get_cookie_file();
  3359. crypto_rand(authentication_cookie, AUTHENTICATION_COOKIE_LEN);
  3360. authentication_cookie_is_set = 1;
  3361. if (write_bytes_to_file(fname, authentication_cookie,
  3362. AUTHENTICATION_COOKIE_LEN, 1)) {
  3363. log_warn(LD_FS,"Error writing authentication cookie to %s.",
  3364. escaped(fname));
  3365. tor_free(fname);
  3366. return -1;
  3367. }
  3368. #ifndef MS_WINDOWS
  3369. if (get_options()->CookieAuthFileGroupReadable) {
  3370. if (chmod(fname, 0640)) {
  3371. log_warn(LD_FS,"Unable to make %s group-readable.", escaped(fname));
  3372. }
  3373. }
  3374. #endif
  3375. tor_free(fname);
  3376. return 0;
  3377. }