main.c 117 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675
  1. /* Copyright (c) 2001 Matej Pfajfar.
  2. * Copyright (c) 2001-2004, Roger Dingledine.
  3. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  4. * Copyright (c) 2007-2016, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  6. /**
  7. * \file main.c
  8. * \brief Toplevel module. Handles signals, multiplexes between
  9. * connections, implements main loop, and drives scheduled events.
  10. **/
  11. #define MAIN_PRIVATE
  12. #include "or.h"
  13. #include "addressmap.h"
  14. #include "backtrace.h"
  15. #include "buffers.h"
  16. #include "channel.h"
  17. #include "channeltls.h"
  18. #include "circuitbuild.h"
  19. #include "circuitlist.h"
  20. #include "circuituse.h"
  21. #include "command.h"
  22. #include "config.h"
  23. #include "confparse.h"
  24. #include "connection.h"
  25. #include "connection_edge.h"
  26. #include "connection_or.h"
  27. #include "control.h"
  28. #include "cpuworker.h"
  29. #include "crypto_s2k.h"
  30. #include "directory.h"
  31. #include "dirserv.h"
  32. #include "dirvote.h"
  33. #include "dns.h"
  34. #include "dnsserv.h"
  35. #include "entrynodes.h"
  36. #include "geoip.h"
  37. #include "hibernate.h"
  38. #include "keypin.h"
  39. #include "main.h"
  40. #include "microdesc.h"
  41. #include "networkstatus.h"
  42. #include "nodelist.h"
  43. #include "ntmain.h"
  44. #include "onion.h"
  45. #include "periodic.h"
  46. #include "policies.h"
  47. #include "transports.h"
  48. #include "relay.h"
  49. #include "rendclient.h"
  50. #include "rendcommon.h"
  51. #include "rendservice.h"
  52. #include "rephist.h"
  53. #include "router.h"
  54. #include "routerkeys.h"
  55. #include "routerlist.h"
  56. #include "routerparse.h"
  57. #include "scheduler.h"
  58. #include "statefile.h"
  59. #include "status.h"
  60. #include "util_process.h"
  61. #include "ext_orport.h"
  62. #ifdef USE_DMALLOC
  63. #include <dmalloc.h>
  64. #include <openssl/crypto.h>
  65. #endif
  66. #include "memarea.h"
  67. #include "sandbox.h"
  68. #ifdef HAVE_EVENT2_EVENT_H
  69. #include <event2/event.h>
  70. #else
  71. #include <event.h>
  72. #endif
  73. #ifdef USE_BUFFEREVENTS
  74. #include <event2/bufferevent.h>
  75. #endif
  76. #ifdef HAVE_SYSTEMD
  77. # if defined(__COVERITY__) && !defined(__INCLUDE_LEVEL__)
  78. /* Systemd's use of gcc's __INCLUDE_LEVEL__ extension macro appears to confuse
  79. * Coverity. Here's a kludge to unconfuse it.
  80. */
  81. # define __INCLUDE_LEVEL__ 2
  82. # endif
  83. #include <systemd/sd-daemon.h>
  84. #endif
  85. void evdns_shutdown(int);
  86. /********* PROTOTYPES **********/
  87. static void dumpmemusage(int severity);
  88. static void dumpstats(int severity); /* log stats */
  89. static void conn_read_callback(evutil_socket_t fd, short event, void *_conn);
  90. static void conn_write_callback(evutil_socket_t fd, short event, void *_conn);
  91. static void second_elapsed_callback(periodic_timer_t *timer, void *args);
  92. static int conn_close_if_marked(int i);
  93. static void connection_start_reading_from_linked_conn(connection_t *conn);
  94. static int connection_should_read_from_linked_conn(connection_t *conn);
  95. static int run_main_loop_until_done(void);
  96. static void process_signal(int sig);
  97. /********* START VARIABLES **********/
  98. #ifndef USE_BUFFEREVENTS
  99. int global_read_bucket; /**< Max number of bytes I can read this second. */
  100. int global_write_bucket; /**< Max number of bytes I can write this second. */
  101. /** Max number of relayed (bandwidth class 1) bytes I can read this second. */
  102. int global_relayed_read_bucket;
  103. /** Max number of relayed (bandwidth class 1) bytes I can write this second. */
  104. int global_relayed_write_bucket;
  105. /** What was the read bucket before the last second_elapsed_callback() call?
  106. * (used to determine how many bytes we've read). */
  107. static int stats_prev_global_read_bucket;
  108. /** What was the write bucket before the last second_elapsed_callback() call?
  109. * (used to determine how many bytes we've written). */
  110. static int stats_prev_global_write_bucket;
  111. #endif
  112. /* DOCDOC stats_prev_n_read */
  113. static uint64_t stats_prev_n_read = 0;
  114. /* DOCDOC stats_prev_n_written */
  115. static uint64_t stats_prev_n_written = 0;
  116. /* XXX we might want to keep stats about global_relayed_*_bucket too. Or not.*/
  117. /** How many bytes have we read since we started the process? */
  118. static uint64_t stats_n_bytes_read = 0;
  119. /** How many bytes have we written since we started the process? */
  120. static uint64_t stats_n_bytes_written = 0;
  121. /** What time did this process start up? */
  122. time_t time_of_process_start = 0;
  123. /** How many seconds have we been running? */
  124. long stats_n_seconds_working = 0;
  125. /** How often will we honor SIGNEWNYM requests? */
  126. #define MAX_SIGNEWNYM_RATE 10
  127. /** When did we last process a SIGNEWNYM request? */
  128. static time_t time_of_last_signewnym = 0;
  129. /** Is there a signewnym request we're currently waiting to handle? */
  130. static int signewnym_is_pending = 0;
  131. /** How many times have we called newnym? */
  132. static unsigned newnym_epoch = 0;
  133. /** Smartlist of all open connections. */
  134. static smartlist_t *connection_array = NULL;
  135. /** List of connections that have been marked for close and need to be freed
  136. * and removed from connection_array. */
  137. static smartlist_t *closeable_connection_lst = NULL;
  138. /** List of linked connections that are currently reading data into their
  139. * inbuf from their partner's outbuf. */
  140. static smartlist_t *active_linked_connection_lst = NULL;
  141. /** Flag: Set to true iff we entered the current libevent main loop via
  142. * <b>loop_once</b>. If so, there's no need to trigger a loopexit in order
  143. * to handle linked connections. */
  144. static int called_loop_once = 0;
  145. /** We set this to 1 when we've opened a circuit, so we can print a log
  146. * entry to inform the user that Tor is working. We set it to 0 when
  147. * we think the fact that we once opened a circuit doesn't mean we can do so
  148. * any longer (a big time jump happened, when we notice our directory is
  149. * heinously out-of-date, etc.
  150. */
  151. static int can_complete_circuits = 0;
  152. /** How often do we check for router descriptors that we should download
  153. * when we have too little directory info? */
  154. #define GREEDY_DESCRIPTOR_RETRY_INTERVAL (10)
  155. /** How often do we check for router descriptors that we should download
  156. * when we have enough directory info? */
  157. #define LAZY_DESCRIPTOR_RETRY_INTERVAL (60)
  158. /** How often do we 'forgive' undownloadable router descriptors and attempt
  159. * to download them again? */
  160. #define DESCRIPTOR_FAILURE_RESET_INTERVAL (60*60)
  161. /** Decides our behavior when no logs are configured/before any
  162. * logs have been configured. For 0, we log notice to stdout as normal.
  163. * For 1, we log warnings only. For 2, we log nothing.
  164. */
  165. int quiet_level = 0;
  166. /********* END VARIABLES ************/
  167. /****************************************************************************
  168. *
  169. * This section contains accessors and other methods on the connection_array
  170. * variables (which are global within this file and unavailable outside it).
  171. *
  172. ****************************************************************************/
  173. #if defined(_WIN32) && defined(USE_BUFFEREVENTS)
  174. /** Remove the kernel-space send and receive buffers for <b>s</b>. For use
  175. * with IOCP only. */
  176. static int
  177. set_buffer_lengths_to_zero(tor_socket_t s)
  178. {
  179. int zero = 0;
  180. int r = 0;
  181. if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, (void*)&zero,
  182. (socklen_t)sizeof(zero))) {
  183. log_warn(LD_NET, "Unable to clear SO_SNDBUF");
  184. r = -1;
  185. }
  186. if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, (void*)&zero,
  187. (socklen_t)sizeof(zero))) {
  188. log_warn(LD_NET, "Unable to clear SO_RCVBUF");
  189. r = -1;
  190. }
  191. return r;
  192. }
  193. #endif
  194. /** Return 1 if we have successfully built a circuit, and nothing has changed
  195. * to make us think that maybe we can't.
  196. */
  197. int
  198. have_completed_a_circuit(void)
  199. {
  200. return can_complete_circuits;
  201. }
  202. /** Note that we have successfully built a circuit, so that reachability
  203. * testing and introduction points and so on may be attempted. */
  204. void
  205. note_that_we_completed_a_circuit(void)
  206. {
  207. can_complete_circuits = 1;
  208. }
  209. /** Note that something has happened (like a clock jump, or DisableNetwork) to
  210. * make us think that maybe we can't complete circuits. */
  211. void
  212. note_that_we_maybe_cant_complete_circuits(void)
  213. {
  214. can_complete_circuits = 0;
  215. }
  216. /** Add <b>conn</b> to the array of connections that we can poll on. The
  217. * connection's socket must be set; the connection starts out
  218. * non-reading and non-writing.
  219. */
  220. int
  221. connection_add_impl(connection_t *conn, int is_connecting)
  222. {
  223. tor_assert(conn);
  224. tor_assert(SOCKET_OK(conn->s) ||
  225. conn->linked ||
  226. (conn->type == CONN_TYPE_AP &&
  227. TO_EDGE_CONN(conn)->is_dns_request));
  228. tor_assert(conn->conn_array_index == -1); /* can only connection_add once */
  229. conn->conn_array_index = smartlist_len(connection_array);
  230. smartlist_add(connection_array, conn);
  231. #ifdef USE_BUFFEREVENTS
  232. if (connection_type_uses_bufferevent(conn)) {
  233. if (SOCKET_OK(conn->s) && !conn->linked) {
  234. #ifdef _WIN32
  235. if (tor_libevent_using_iocp_bufferevents() &&
  236. get_options()->UserspaceIOCPBuffers) {
  237. set_buffer_lengths_to_zero(conn->s);
  238. }
  239. #endif
  240. conn->bufev = bufferevent_socket_new(
  241. tor_libevent_get_base(),
  242. conn->s,
  243. BEV_OPT_DEFER_CALLBACKS);
  244. if (!conn->bufev) {
  245. log_warn(LD_BUG, "Unable to create socket bufferevent");
  246. smartlist_del(connection_array, conn->conn_array_index);
  247. conn->conn_array_index = -1;
  248. return -1;
  249. }
  250. if (is_connecting) {
  251. /* Put the bufferevent into a "connecting" state so that we'll get
  252. * a "connected" event callback on successful write. */
  253. bufferevent_socket_connect(conn->bufev, NULL, 0);
  254. }
  255. connection_configure_bufferevent_callbacks(conn);
  256. } else if (conn->linked && conn->linked_conn &&
  257. connection_type_uses_bufferevent(conn->linked_conn)) {
  258. tor_assert(!(SOCKET_OK(conn->s)));
  259. if (!conn->bufev) {
  260. struct bufferevent *pair[2] = { NULL, NULL };
  261. if (bufferevent_pair_new(tor_libevent_get_base(),
  262. BEV_OPT_DEFER_CALLBACKS,
  263. pair) < 0) {
  264. log_warn(LD_BUG, "Unable to create bufferevent pair");
  265. smartlist_del(connection_array, conn->conn_array_index);
  266. conn->conn_array_index = -1;
  267. return -1;
  268. }
  269. tor_assert(pair[0]);
  270. conn->bufev = pair[0];
  271. conn->linked_conn->bufev = pair[1];
  272. } /* else the other side already was added, and got a bufferevent_pair */
  273. connection_configure_bufferevent_callbacks(conn);
  274. } else {
  275. tor_assert(!conn->linked);
  276. }
  277. if (conn->bufev)
  278. tor_assert(conn->inbuf == NULL);
  279. if (conn->linked_conn && conn->linked_conn->bufev)
  280. tor_assert(conn->linked_conn->inbuf == NULL);
  281. }
  282. #else
  283. (void) is_connecting;
  284. #endif
  285. if (!HAS_BUFFEREVENT(conn) && (SOCKET_OK(conn->s) || conn->linked)) {
  286. conn->read_event = tor_event_new(tor_libevent_get_base(),
  287. conn->s, EV_READ|EV_PERSIST, conn_read_callback, conn);
  288. conn->write_event = tor_event_new(tor_libevent_get_base(),
  289. conn->s, EV_WRITE|EV_PERSIST, conn_write_callback, conn);
  290. /* XXXX CHECK FOR NULL RETURN! */
  291. }
  292. log_debug(LD_NET,"new conn type %s, socket %d, address %s, n_conns %d.",
  293. conn_type_to_string(conn->type), (int)conn->s, conn->address,
  294. smartlist_len(connection_array));
  295. return 0;
  296. }
  297. /** Tell libevent that we don't care about <b>conn</b> any more. */
  298. void
  299. connection_unregister_events(connection_t *conn)
  300. {
  301. if (conn->read_event) {
  302. if (event_del(conn->read_event))
  303. log_warn(LD_BUG, "Error removing read event for %d", (int)conn->s);
  304. tor_free(conn->read_event);
  305. }
  306. if (conn->write_event) {
  307. if (event_del(conn->write_event))
  308. log_warn(LD_BUG, "Error removing write event for %d", (int)conn->s);
  309. tor_free(conn->write_event);
  310. }
  311. #ifdef USE_BUFFEREVENTS
  312. if (conn->bufev) {
  313. bufferevent_free(conn->bufev);
  314. conn->bufev = NULL;
  315. }
  316. #endif
  317. if (conn->type == CONN_TYPE_AP_DNS_LISTENER) {
  318. dnsserv_close_listener(conn);
  319. }
  320. }
  321. /** Remove the connection from the global list, and remove the
  322. * corresponding poll entry. Calling this function will shift the last
  323. * connection (if any) into the position occupied by conn.
  324. */
  325. int
  326. connection_remove(connection_t *conn)
  327. {
  328. int current_index;
  329. connection_t *tmp;
  330. tor_assert(conn);
  331. log_debug(LD_NET,"removing socket %d (type %s), n_conns now %d",
  332. (int)conn->s, conn_type_to_string(conn->type),
  333. smartlist_len(connection_array));
  334. if (conn->type == CONN_TYPE_AP && conn->socket_family == AF_UNIX) {
  335. log_info(LD_NET, "Closing SOCKS SocksSocket connection");
  336. }
  337. control_event_conn_bandwidth(conn);
  338. tor_assert(conn->conn_array_index >= 0);
  339. current_index = conn->conn_array_index;
  340. connection_unregister_events(conn); /* This is redundant, but cheap. */
  341. if (current_index == smartlist_len(connection_array)-1) { /* at the end */
  342. smartlist_del(connection_array, current_index);
  343. return 0;
  344. }
  345. /* replace this one with the one at the end */
  346. smartlist_del(connection_array, current_index);
  347. tmp = smartlist_get(connection_array, current_index);
  348. tmp->conn_array_index = current_index;
  349. return 0;
  350. }
  351. /** If <b>conn</b> is an edge conn, remove it from the list
  352. * of conn's on this circuit. If it's not on an edge,
  353. * flush and send destroys for all circuits on this conn.
  354. *
  355. * Remove it from connection_array (if applicable) and
  356. * from closeable_connection_list.
  357. *
  358. * Then free it.
  359. */
  360. static void
  361. connection_unlink(connection_t *conn)
  362. {
  363. connection_about_to_close_connection(conn);
  364. if (conn->conn_array_index >= 0) {
  365. connection_remove(conn);
  366. }
  367. if (conn->linked_conn) {
  368. conn->linked_conn->linked_conn = NULL;
  369. if (! conn->linked_conn->marked_for_close &&
  370. conn->linked_conn->reading_from_linked_conn)
  371. connection_start_reading(conn->linked_conn);
  372. conn->linked_conn = NULL;
  373. }
  374. smartlist_remove(closeable_connection_lst, conn);
  375. smartlist_remove(active_linked_connection_lst, conn);
  376. if (conn->type == CONN_TYPE_EXIT) {
  377. assert_connection_edge_not_dns_pending(TO_EDGE_CONN(conn));
  378. }
  379. if (conn->type == CONN_TYPE_OR) {
  380. if (!tor_digest_is_zero(TO_OR_CONN(conn)->identity_digest))
  381. connection_or_remove_from_identity_map(TO_OR_CONN(conn));
  382. /* connection_unlink() can only get called if the connection
  383. * was already on the closeable list, and it got there by
  384. * connection_mark_for_close(), which was called from
  385. * connection_or_close_normally() or
  386. * connection_or_close_for_error(), so the channel should
  387. * already be in CHANNEL_STATE_CLOSING, and then the
  388. * connection_about_to_close_connection() goes to
  389. * connection_or_about_to_close(), which calls channel_closed()
  390. * to notify the channel_t layer, and closed the channel, so
  391. * nothing more to do here to deal with the channel associated
  392. * with an orconn.
  393. */
  394. }
  395. connection_free(conn);
  396. }
  397. /** Initialize the global connection list, closeable connection list,
  398. * and active connection list. */
  399. STATIC void
  400. init_connection_lists(void)
  401. {
  402. if (!connection_array)
  403. connection_array = smartlist_new();
  404. if (!closeable_connection_lst)
  405. closeable_connection_lst = smartlist_new();
  406. if (!active_linked_connection_lst)
  407. active_linked_connection_lst = smartlist_new();
  408. }
  409. /** Schedule <b>conn</b> to be closed. **/
  410. void
  411. add_connection_to_closeable_list(connection_t *conn)
  412. {
  413. tor_assert(!smartlist_contains(closeable_connection_lst, conn));
  414. tor_assert(conn->marked_for_close);
  415. assert_connection_ok(conn, time(NULL));
  416. smartlist_add(closeable_connection_lst, conn);
  417. }
  418. /** Return 1 if conn is on the closeable list, else return 0. */
  419. int
  420. connection_is_on_closeable_list(connection_t *conn)
  421. {
  422. return smartlist_contains(closeable_connection_lst, conn);
  423. }
  424. /** Return true iff conn is in the current poll array. */
  425. int
  426. connection_in_array(connection_t *conn)
  427. {
  428. return smartlist_contains(connection_array, conn);
  429. }
  430. /** Set <b>*array</b> to an array of all connections. <b>*array</b> must not
  431. * be modified.
  432. */
  433. smartlist_t *
  434. get_connection_array(void)
  435. {
  436. if (!connection_array)
  437. connection_array = smartlist_new();
  438. return connection_array;
  439. }
  440. /** Provides the traffic read and written over the life of the process. */
  441. MOCK_IMPL(uint64_t,
  442. get_bytes_read,(void))
  443. {
  444. return stats_n_bytes_read;
  445. }
  446. /* DOCDOC get_bytes_written */
  447. MOCK_IMPL(uint64_t,
  448. get_bytes_written,(void))
  449. {
  450. return stats_n_bytes_written;
  451. }
  452. /** Set the event mask on <b>conn</b> to <b>events</b>. (The event
  453. * mask is a bitmask whose bits are READ_EVENT and WRITE_EVENT)
  454. */
  455. void
  456. connection_watch_events(connection_t *conn, watchable_events_t events)
  457. {
  458. IF_HAS_BUFFEREVENT(conn, {
  459. short ev = ((short)events) & (EV_READ|EV_WRITE);
  460. short old_ev = bufferevent_get_enabled(conn->bufev);
  461. if ((ev & ~old_ev) != 0) {
  462. bufferevent_enable(conn->bufev, ev);
  463. }
  464. if ((old_ev & ~ev) != 0) {
  465. bufferevent_disable(conn->bufev, old_ev & ~ev);
  466. }
  467. return;
  468. });
  469. if (events & READ_EVENT)
  470. connection_start_reading(conn);
  471. else
  472. connection_stop_reading(conn);
  473. if (events & WRITE_EVENT)
  474. connection_start_writing(conn);
  475. else
  476. connection_stop_writing(conn);
  477. }
  478. /** Return true iff <b>conn</b> is listening for read events. */
  479. int
  480. connection_is_reading(connection_t *conn)
  481. {
  482. tor_assert(conn);
  483. IF_HAS_BUFFEREVENT(conn,
  484. return (bufferevent_get_enabled(conn->bufev) & EV_READ) != 0;
  485. );
  486. return conn->reading_from_linked_conn ||
  487. (conn->read_event && event_pending(conn->read_event, EV_READ, NULL));
  488. }
  489. /** Check whether <b>conn</b> is correct in having (or not having) a
  490. * read/write event (passed in <b>ev</b>). On success, return 0. On failure,
  491. * log a warning and return -1. */
  492. static int
  493. connection_check_event(connection_t *conn, struct event *ev)
  494. {
  495. int bad;
  496. if (conn->type == CONN_TYPE_AP && TO_EDGE_CONN(conn)->is_dns_request) {
  497. /* DNS requests which we launch through the dnsserv.c module do not have
  498. * any underlying socket or any underlying linked connection, so they
  499. * shouldn't have any attached events either.
  500. */
  501. bad = ev != NULL;
  502. } else {
  503. /* Everytyhing else should have an underlying socket, or a linked
  504. * connection (which is also tracked with a read_event/write_event pair).
  505. */
  506. bad = ev == NULL;
  507. }
  508. if (bad) {
  509. log_warn(LD_BUG, "Event missing on connection %p [%s;%s]. "
  510. "socket=%d. linked=%d. "
  511. "is_dns_request=%d. Marked_for_close=%s:%d",
  512. conn,
  513. conn_type_to_string(conn->type),
  514. conn_state_to_string(conn->type, conn->state),
  515. (int)conn->s, (int)conn->linked,
  516. (conn->type == CONN_TYPE_AP &&
  517. TO_EDGE_CONN(conn)->is_dns_request),
  518. conn->marked_for_close_file ? conn->marked_for_close_file : "-",
  519. conn->marked_for_close
  520. );
  521. log_backtrace(LOG_WARN, LD_BUG, "Backtrace attached.");
  522. return -1;
  523. }
  524. return 0;
  525. }
  526. /** Tell the main loop to stop notifying <b>conn</b> of any read events. */
  527. MOCK_IMPL(void,
  528. connection_stop_reading,(connection_t *conn))
  529. {
  530. tor_assert(conn);
  531. IF_HAS_BUFFEREVENT(conn, {
  532. bufferevent_disable(conn->bufev, EV_READ);
  533. return;
  534. });
  535. if (connection_check_event(conn, conn->read_event) < 0) {
  536. return;
  537. }
  538. if (conn->linked) {
  539. conn->reading_from_linked_conn = 0;
  540. connection_stop_reading_from_linked_conn(conn);
  541. } else {
  542. if (event_del(conn->read_event))
  543. log_warn(LD_NET, "Error from libevent setting read event state for %d "
  544. "to unwatched: %s",
  545. (int)conn->s,
  546. tor_socket_strerror(tor_socket_errno(conn->s)));
  547. }
  548. }
  549. /** Tell the main loop to start notifying <b>conn</b> of any read events. */
  550. MOCK_IMPL(void,
  551. connection_start_reading,(connection_t *conn))
  552. {
  553. tor_assert(conn);
  554. IF_HAS_BUFFEREVENT(conn, {
  555. bufferevent_enable(conn->bufev, EV_READ);
  556. return;
  557. });
  558. if (connection_check_event(conn, conn->read_event) < 0) {
  559. return;
  560. }
  561. if (conn->linked) {
  562. conn->reading_from_linked_conn = 1;
  563. if (connection_should_read_from_linked_conn(conn))
  564. connection_start_reading_from_linked_conn(conn);
  565. } else {
  566. if (event_add(conn->read_event, NULL))
  567. log_warn(LD_NET, "Error from libevent setting read event state for %d "
  568. "to watched: %s",
  569. (int)conn->s,
  570. tor_socket_strerror(tor_socket_errno(conn->s)));
  571. }
  572. }
  573. /** Return true iff <b>conn</b> is listening for write events. */
  574. int
  575. connection_is_writing(connection_t *conn)
  576. {
  577. tor_assert(conn);
  578. IF_HAS_BUFFEREVENT(conn,
  579. return (bufferevent_get_enabled(conn->bufev) & EV_WRITE) != 0;
  580. );
  581. return conn->writing_to_linked_conn ||
  582. (conn->write_event && event_pending(conn->write_event, EV_WRITE, NULL));
  583. }
  584. /** Tell the main loop to stop notifying <b>conn</b> of any write events. */
  585. MOCK_IMPL(void,
  586. connection_stop_writing,(connection_t *conn))
  587. {
  588. tor_assert(conn);
  589. IF_HAS_BUFFEREVENT(conn, {
  590. bufferevent_disable(conn->bufev, EV_WRITE);
  591. return;
  592. });
  593. if (connection_check_event(conn, conn->write_event) < 0) {
  594. return;
  595. }
  596. if (conn->linked) {
  597. conn->writing_to_linked_conn = 0;
  598. if (conn->linked_conn)
  599. connection_stop_reading_from_linked_conn(conn->linked_conn);
  600. } else {
  601. if (event_del(conn->write_event))
  602. log_warn(LD_NET, "Error from libevent setting write event state for %d "
  603. "to unwatched: %s",
  604. (int)conn->s,
  605. tor_socket_strerror(tor_socket_errno(conn->s)));
  606. }
  607. }
  608. /** Tell the main loop to start notifying <b>conn</b> of any write events. */
  609. MOCK_IMPL(void,
  610. connection_start_writing,(connection_t *conn))
  611. {
  612. tor_assert(conn);
  613. IF_HAS_BUFFEREVENT(conn, {
  614. bufferevent_enable(conn->bufev, EV_WRITE);
  615. return;
  616. });
  617. if (connection_check_event(conn, conn->write_event) < 0) {
  618. return;
  619. }
  620. if (conn->linked) {
  621. conn->writing_to_linked_conn = 1;
  622. if (conn->linked_conn &&
  623. connection_should_read_from_linked_conn(conn->linked_conn))
  624. connection_start_reading_from_linked_conn(conn->linked_conn);
  625. } else {
  626. if (event_add(conn->write_event, NULL))
  627. log_warn(LD_NET, "Error from libevent setting write event state for %d "
  628. "to watched: %s",
  629. (int)conn->s,
  630. tor_socket_strerror(tor_socket_errno(conn->s)));
  631. }
  632. }
  633. /** Return true iff <b>conn</b> is linked conn, and reading from the conn
  634. * linked to it would be good and feasible. (Reading is "feasible" if the
  635. * other conn exists and has data in its outbuf, and is "good" if we have our
  636. * reading_from_linked_conn flag set and the other conn has its
  637. * writing_to_linked_conn flag set.)*/
  638. static int
  639. connection_should_read_from_linked_conn(connection_t *conn)
  640. {
  641. if (conn->linked && conn->reading_from_linked_conn) {
  642. if (! conn->linked_conn ||
  643. (conn->linked_conn->writing_to_linked_conn &&
  644. buf_datalen(conn->linked_conn->outbuf)))
  645. return 1;
  646. }
  647. return 0;
  648. }
  649. /** Helper: Tell the main loop to begin reading bytes into <b>conn</b> from
  650. * its linked connection, if it is not doing so already. Called by
  651. * connection_start_reading and connection_start_writing as appropriate. */
  652. static void
  653. connection_start_reading_from_linked_conn(connection_t *conn)
  654. {
  655. tor_assert(conn);
  656. tor_assert(conn->linked == 1);
  657. if (!conn->active_on_link) {
  658. conn->active_on_link = 1;
  659. smartlist_add(active_linked_connection_lst, conn);
  660. if (!called_loop_once) {
  661. /* This is the first event on the list; we won't be in LOOP_ONCE mode,
  662. * so we need to make sure that the event_base_loop() actually exits at
  663. * the end of its run through the current connections and lets us
  664. * activate read events for linked connections. */
  665. struct timeval tv = { 0, 0 };
  666. tor_event_base_loopexit(tor_libevent_get_base(), &tv);
  667. }
  668. } else {
  669. tor_assert(smartlist_contains(active_linked_connection_lst, conn));
  670. }
  671. }
  672. /** Tell the main loop to stop reading bytes into <b>conn</b> from its linked
  673. * connection, if is currently doing so. Called by connection_stop_reading,
  674. * connection_stop_writing, and connection_read. */
  675. void
  676. connection_stop_reading_from_linked_conn(connection_t *conn)
  677. {
  678. tor_assert(conn);
  679. tor_assert(conn->linked == 1);
  680. if (conn->active_on_link) {
  681. conn->active_on_link = 0;
  682. /* FFFF We could keep an index here so we can smartlist_del
  683. * cleanly. On the other hand, this doesn't show up on profiles,
  684. * so let's leave it alone for now. */
  685. smartlist_remove(active_linked_connection_lst, conn);
  686. } else {
  687. tor_assert(!smartlist_contains(active_linked_connection_lst, conn));
  688. }
  689. }
  690. /** Close all connections that have been scheduled to get closed. */
  691. STATIC void
  692. close_closeable_connections(void)
  693. {
  694. int i;
  695. for (i = 0; i < smartlist_len(closeable_connection_lst); ) {
  696. connection_t *conn = smartlist_get(closeable_connection_lst, i);
  697. if (conn->conn_array_index < 0) {
  698. connection_unlink(conn); /* blow it away right now */
  699. } else {
  700. if (!conn_close_if_marked(conn->conn_array_index))
  701. ++i;
  702. }
  703. }
  704. }
  705. /** Libevent callback: this gets invoked when (connection_t*)<b>conn</b> has
  706. * some data to read. */
  707. static void
  708. conn_read_callback(evutil_socket_t fd, short event, void *_conn)
  709. {
  710. connection_t *conn = _conn;
  711. (void)fd;
  712. (void)event;
  713. log_debug(LD_NET,"socket %d wants to read.",(int)conn->s);
  714. /* assert_connection_ok(conn, time(NULL)); */
  715. if (connection_handle_read(conn) < 0) {
  716. if (!conn->marked_for_close) {
  717. #ifndef _WIN32
  718. log_warn(LD_BUG,"Unhandled error on read for %s connection "
  719. "(fd %d); removing",
  720. conn_type_to_string(conn->type), (int)conn->s);
  721. tor_fragile_assert();
  722. #endif
  723. if (CONN_IS_EDGE(conn))
  724. connection_edge_end_errno(TO_EDGE_CONN(conn));
  725. connection_mark_for_close(conn);
  726. }
  727. }
  728. assert_connection_ok(conn, time(NULL));
  729. if (smartlist_len(closeable_connection_lst))
  730. close_closeable_connections();
  731. }
  732. /** Libevent callback: this gets invoked when (connection_t*)<b>conn</b> has
  733. * some data to write. */
  734. static void
  735. conn_write_callback(evutil_socket_t fd, short events, void *_conn)
  736. {
  737. connection_t *conn = _conn;
  738. (void)fd;
  739. (void)events;
  740. LOG_FN_CONN(conn, (LOG_DEBUG, LD_NET, "socket %d wants to write.",
  741. (int)conn->s));
  742. /* assert_connection_ok(conn, time(NULL)); */
  743. if (connection_handle_write(conn, 0) < 0) {
  744. if (!conn->marked_for_close) {
  745. /* this connection is broken. remove it. */
  746. log_fn(LOG_WARN,LD_BUG,
  747. "unhandled error on write for %s connection (fd %d); removing",
  748. conn_type_to_string(conn->type), (int)conn->s);
  749. tor_fragile_assert();
  750. if (CONN_IS_EDGE(conn)) {
  751. /* otherwise we cry wolf about duplicate close */
  752. edge_connection_t *edge_conn = TO_EDGE_CONN(conn);
  753. if (!edge_conn->end_reason)
  754. edge_conn->end_reason = END_STREAM_REASON_INTERNAL;
  755. edge_conn->edge_has_sent_end = 1;
  756. }
  757. connection_close_immediate(conn); /* So we don't try to flush. */
  758. connection_mark_for_close(conn);
  759. }
  760. }
  761. assert_connection_ok(conn, time(NULL));
  762. if (smartlist_len(closeable_connection_lst))
  763. close_closeable_connections();
  764. }
  765. /** If the connection at connection_array[i] is marked for close, then:
  766. * - If it has data that it wants to flush, try to flush it.
  767. * - If it _still_ has data to flush, and conn->hold_open_until_flushed is
  768. * true, then leave the connection open and return.
  769. * - Otherwise, remove the connection from connection_array and from
  770. * all other lists, close it, and free it.
  771. * Returns 1 if the connection was closed, 0 otherwise.
  772. */
  773. static int
  774. conn_close_if_marked(int i)
  775. {
  776. connection_t *conn;
  777. int retval;
  778. time_t now;
  779. conn = smartlist_get(connection_array, i);
  780. if (!conn->marked_for_close)
  781. return 0; /* nothing to see here, move along */
  782. now = time(NULL);
  783. assert_connection_ok(conn, now);
  784. /* assert_all_pending_dns_resolves_ok(); */
  785. #ifdef USE_BUFFEREVENTS
  786. if (conn->bufev) {
  787. if (conn->hold_open_until_flushed &&
  788. evbuffer_get_length(bufferevent_get_output(conn->bufev))) {
  789. /* don't close yet. */
  790. return 0;
  791. }
  792. if (conn->linked_conn && ! conn->linked_conn->marked_for_close) {
  793. /* We need to do this explicitly so that the linked connection
  794. * notices that there was an EOF. */
  795. bufferevent_flush(conn->bufev, EV_WRITE, BEV_FINISHED);
  796. }
  797. }
  798. #endif
  799. log_debug(LD_NET,"Cleaning up connection (fd "TOR_SOCKET_T_FORMAT").",
  800. conn->s);
  801. /* If the connection we are about to close was trying to connect to
  802. a proxy server and failed, the client won't be able to use that
  803. proxy. We should warn the user about this. */
  804. if (conn->proxy_state == PROXY_INFANT)
  805. log_failed_proxy_connection(conn);
  806. IF_HAS_BUFFEREVENT(conn, goto unlink);
  807. if ((SOCKET_OK(conn->s) || conn->linked_conn) &&
  808. connection_wants_to_flush(conn)) {
  809. /* s == -1 means it's an incomplete edge connection, or that the socket
  810. * has already been closed as unflushable. */
  811. ssize_t sz = connection_bucket_write_limit(conn, now);
  812. if (!conn->hold_open_until_flushed)
  813. log_info(LD_NET,
  814. "Conn (addr %s, fd %d, type %s, state %d) marked, but wants "
  815. "to flush %d bytes. (Marked at %s:%d)",
  816. escaped_safe_str_client(conn->address),
  817. (int)conn->s, conn_type_to_string(conn->type), conn->state,
  818. (int)conn->outbuf_flushlen,
  819. conn->marked_for_close_file, conn->marked_for_close);
  820. if (conn->linked_conn) {
  821. retval = move_buf_to_buf(conn->linked_conn->inbuf, conn->outbuf,
  822. &conn->outbuf_flushlen);
  823. if (retval >= 0) {
  824. /* The linked conn will notice that it has data when it notices that
  825. * we're gone. */
  826. connection_start_reading_from_linked_conn(conn->linked_conn);
  827. }
  828. log_debug(LD_GENERAL, "Flushed last %d bytes from a linked conn; "
  829. "%d left; flushlen %d; wants-to-flush==%d", retval,
  830. (int)connection_get_outbuf_len(conn),
  831. (int)conn->outbuf_flushlen,
  832. connection_wants_to_flush(conn));
  833. } else if (connection_speaks_cells(conn)) {
  834. if (conn->state == OR_CONN_STATE_OPEN) {
  835. retval = flush_buf_tls(TO_OR_CONN(conn)->tls, conn->outbuf, sz,
  836. &conn->outbuf_flushlen);
  837. } else
  838. retval = -1; /* never flush non-open broken tls connections */
  839. } else {
  840. retval = flush_buf(conn->s, conn->outbuf, sz, &conn->outbuf_flushlen);
  841. }
  842. if (retval >= 0 && /* Technically, we could survive things like
  843. TLS_WANT_WRITE here. But don't bother for now. */
  844. conn->hold_open_until_flushed && connection_wants_to_flush(conn)) {
  845. if (retval > 0) {
  846. LOG_FN_CONN(conn, (LOG_INFO,LD_NET,
  847. "Holding conn (fd %d) open for more flushing.",
  848. (int)conn->s));
  849. conn->timestamp_lastwritten = now; /* reset so we can flush more */
  850. } else if (sz == 0) {
  851. /* Also, retval==0. If we get here, we didn't want to write anything
  852. * (because of rate-limiting) and we didn't. */
  853. /* Connection must flush before closing, but it's being rate-limited.
  854. * Let's remove from Libevent, and mark it as blocked on bandwidth
  855. * so it will be re-added on next token bucket refill. Prevents
  856. * busy Libevent loops where we keep ending up here and returning
  857. * 0 until we are no longer blocked on bandwidth.
  858. */
  859. if (connection_is_writing(conn)) {
  860. conn->write_blocked_on_bw = 1;
  861. connection_stop_writing(conn);
  862. }
  863. if (connection_is_reading(conn)) {
  864. /* XXXX024 We should make this code unreachable; if a connection is
  865. * marked for close and flushing, there is no point in reading to it
  866. * at all. Further, checking at this point is a bit of a hack: it
  867. * would make much more sense to react in
  868. * connection_handle_read_impl, or to just stop reading in
  869. * mark_and_flush */
  870. conn->read_blocked_on_bw = 1;
  871. connection_stop_reading(conn);
  872. }
  873. }
  874. return 0;
  875. }
  876. if (connection_wants_to_flush(conn)) {
  877. log_fn(LOG_INFO, LD_NET, "We stalled too much while trying to write %d "
  878. "bytes to address %s. If this happens a lot, either "
  879. "something is wrong with your network connection, or "
  880. "something is wrong with theirs. "
  881. "(fd %d, type %s, state %d, marked at %s:%d).",
  882. (int)connection_get_outbuf_len(conn),
  883. escaped_safe_str_client(conn->address),
  884. (int)conn->s, conn_type_to_string(conn->type), conn->state,
  885. conn->marked_for_close_file,
  886. conn->marked_for_close);
  887. }
  888. }
  889. #ifdef USE_BUFFEREVENTS
  890. unlink:
  891. #endif
  892. connection_unlink(conn); /* unlink, remove, free */
  893. return 1;
  894. }
  895. /** Implementation for directory_all_unreachable. This is done in a callback,
  896. * since otherwise it would complicate Tor's control-flow graph beyond all
  897. * reason.
  898. */
  899. static void
  900. directory_all_unreachable_cb(evutil_socket_t fd, short event, void *arg)
  901. {
  902. (void)fd;
  903. (void)event;
  904. (void)arg;
  905. connection_t *conn;
  906. while ((conn = connection_get_by_type_state(CONN_TYPE_AP,
  907. AP_CONN_STATE_CIRCUIT_WAIT))) {
  908. entry_connection_t *entry_conn = TO_ENTRY_CONN(conn);
  909. log_notice(LD_NET,
  910. "Is your network connection down? "
  911. "Failing connection to '%s:%d'.",
  912. safe_str_client(entry_conn->socks_request->address),
  913. entry_conn->socks_request->port);
  914. connection_mark_unattached_ap(entry_conn,
  915. END_STREAM_REASON_NET_UNREACHABLE);
  916. }
  917. control_event_general_error("DIR_ALL_UNREACHABLE");
  918. }
  919. static struct event *directory_all_unreachable_cb_event = NULL;
  920. /** We've just tried every dirserver we know about, and none of
  921. * them were reachable. Assume the network is down. Change state
  922. * so next time an application connection arrives we'll delay it
  923. * and try another directory fetch. Kill off all the circuit_wait
  924. * streams that are waiting now, since they will all timeout anyway.
  925. */
  926. void
  927. directory_all_unreachable(time_t now)
  928. {
  929. (void)now;
  930. stats_n_seconds_working=0; /* reset it */
  931. if (!directory_all_unreachable_cb_event) {
  932. directory_all_unreachable_cb_event =
  933. tor_event_new(tor_libevent_get_base(),
  934. -1, EV_READ, directory_all_unreachable_cb, NULL);
  935. tor_assert(directory_all_unreachable_cb_event);
  936. }
  937. event_active(directory_all_unreachable_cb_event, EV_READ, 1);
  938. }
  939. /** This function is called whenever we successfully pull down some new
  940. * network statuses or server descriptors. */
  941. void
  942. directory_info_has_arrived(time_t now, int from_cache, int suppress_logs)
  943. {
  944. const or_options_t *options = get_options();
  945. if (!router_have_minimum_dir_info()) {
  946. int quiet = suppress_logs || from_cache ||
  947. directory_too_idle_to_fetch_descriptors(options, now);
  948. tor_log(quiet ? LOG_INFO : LOG_NOTICE, LD_DIR,
  949. "I learned some more directory information, but not enough to "
  950. "build a circuit: %s", get_dir_info_status_string());
  951. update_all_descriptor_downloads(now);
  952. return;
  953. } else {
  954. if (directory_fetches_from_authorities(options)) {
  955. update_all_descriptor_downloads(now);
  956. }
  957. /* if we have enough dir info, then update our guard status with
  958. * whatever we just learned. */
  959. entry_guards_compute_status(options, now);
  960. /* Don't even bother trying to get extrainfo until the rest of our
  961. * directory info is up-to-date */
  962. if (options->DownloadExtraInfo)
  963. update_extrainfo_downloads(now);
  964. }
  965. if (server_mode(options) && !net_is_disabled() && !from_cache &&
  966. (have_completed_a_circuit() || !any_predicted_circuits(now)))
  967. consider_testing_reachability(1, 1);
  968. }
  969. /** Perform regular maintenance tasks for a single connection. This
  970. * function gets run once per second per connection by run_scheduled_events.
  971. */
  972. static void
  973. run_connection_housekeeping(int i, time_t now)
  974. {
  975. cell_t cell;
  976. connection_t *conn = smartlist_get(connection_array, i);
  977. const or_options_t *options = get_options();
  978. or_connection_t *or_conn;
  979. channel_t *chan = NULL;
  980. int have_any_circuits;
  981. int past_keepalive =
  982. now >= conn->timestamp_lastwritten + options->KeepalivePeriod;
  983. if (conn->outbuf && !connection_get_outbuf_len(conn) &&
  984. conn->type == CONN_TYPE_OR)
  985. TO_OR_CONN(conn)->timestamp_lastempty = now;
  986. if (conn->marked_for_close) {
  987. /* nothing to do here */
  988. return;
  989. }
  990. /* Expire any directory connections that haven't been active (sent
  991. * if a server or received if a client) for 5 min */
  992. if (conn->type == CONN_TYPE_DIR &&
  993. ((DIR_CONN_IS_SERVER(conn) &&
  994. conn->timestamp_lastwritten
  995. + options->TestingDirConnectionMaxStall < now) ||
  996. (!DIR_CONN_IS_SERVER(conn) &&
  997. conn->timestamp_lastread
  998. + options->TestingDirConnectionMaxStall < now))) {
  999. log_info(LD_DIR,"Expiring wedged directory conn (fd %d, purpose %d)",
  1000. (int)conn->s, conn->purpose);
  1001. /* This check is temporary; it's to let us know whether we should consider
  1002. * parsing partial serverdesc responses. */
  1003. if (conn->purpose == DIR_PURPOSE_FETCH_SERVERDESC &&
  1004. connection_get_inbuf_len(conn) >= 1024) {
  1005. log_info(LD_DIR,"Trying to extract information from wedged server desc "
  1006. "download.");
  1007. connection_dir_reached_eof(TO_DIR_CONN(conn));
  1008. } else {
  1009. connection_mark_for_close(conn);
  1010. }
  1011. return;
  1012. }
  1013. if (!connection_speaks_cells(conn))
  1014. return; /* we're all done here, the rest is just for OR conns */
  1015. /* If we haven't written to an OR connection for a while, then either nuke
  1016. the connection or send a keepalive, depending. */
  1017. or_conn = TO_OR_CONN(conn);
  1018. #ifdef USE_BUFFEREVENTS
  1019. tor_assert(conn->bufev);
  1020. #else
  1021. tor_assert(conn->outbuf);
  1022. #endif
  1023. chan = TLS_CHAN_TO_BASE(or_conn->chan);
  1024. tor_assert(chan);
  1025. if (channel_num_circuits(chan) != 0) {
  1026. have_any_circuits = 1;
  1027. chan->timestamp_last_had_circuits = now;
  1028. } else {
  1029. have_any_circuits = 0;
  1030. }
  1031. if (channel_is_bad_for_new_circs(TLS_CHAN_TO_BASE(or_conn->chan)) &&
  1032. ! have_any_circuits) {
  1033. /* It's bad for new circuits, and has no unmarked circuits on it:
  1034. * mark it now. */
  1035. log_info(LD_OR,
  1036. "Expiring non-used OR connection to fd %d (%s:%d) [Too old].",
  1037. (int)conn->s, conn->address, conn->port);
  1038. if (conn->state == OR_CONN_STATE_CONNECTING)
  1039. connection_or_connect_failed(TO_OR_CONN(conn),
  1040. END_OR_CONN_REASON_TIMEOUT,
  1041. "Tor gave up on the connection");
  1042. connection_or_close_normally(TO_OR_CONN(conn), 1);
  1043. } else if (!connection_state_is_open(conn)) {
  1044. if (past_keepalive) {
  1045. /* We never managed to actually get this connection open and happy. */
  1046. log_info(LD_OR,"Expiring non-open OR connection to fd %d (%s:%d).",
  1047. (int)conn->s,conn->address, conn->port);
  1048. connection_or_close_normally(TO_OR_CONN(conn), 0);
  1049. }
  1050. } else if (we_are_hibernating() &&
  1051. ! have_any_circuits &&
  1052. !connection_get_outbuf_len(conn)) {
  1053. /* We're hibernating, there's no circuits, and nothing to flush.*/
  1054. log_info(LD_OR,"Expiring non-used OR connection to fd %d (%s:%d) "
  1055. "[Hibernating or exiting].",
  1056. (int)conn->s,conn->address, conn->port);
  1057. connection_or_close_normally(TO_OR_CONN(conn), 1);
  1058. } else if (!have_any_circuits &&
  1059. now - or_conn->idle_timeout >=
  1060. chan->timestamp_last_had_circuits) {
  1061. log_info(LD_OR,"Expiring non-used OR connection to fd %d (%s:%d) "
  1062. "[no circuits for %d; timeout %d; %scanonical].",
  1063. (int)conn->s, conn->address, conn->port,
  1064. (int)(now - chan->timestamp_last_had_circuits),
  1065. or_conn->idle_timeout,
  1066. or_conn->is_canonical ? "" : "non");
  1067. connection_or_close_normally(TO_OR_CONN(conn), 0);
  1068. } else if (
  1069. now >= or_conn->timestamp_lastempty + options->KeepalivePeriod*10 &&
  1070. now >= conn->timestamp_lastwritten + options->KeepalivePeriod*10) {
  1071. log_fn(LOG_PROTOCOL_WARN,LD_PROTOCOL,
  1072. "Expiring stuck OR connection to fd %d (%s:%d). (%d bytes to "
  1073. "flush; %d seconds since last write)",
  1074. (int)conn->s, conn->address, conn->port,
  1075. (int)connection_get_outbuf_len(conn),
  1076. (int)(now-conn->timestamp_lastwritten));
  1077. connection_or_close_normally(TO_OR_CONN(conn), 0);
  1078. } else if (past_keepalive && !connection_get_outbuf_len(conn)) {
  1079. /* send a padding cell */
  1080. log_fn(LOG_DEBUG,LD_OR,"Sending keepalive to (%s:%d)",
  1081. conn->address, conn->port);
  1082. memset(&cell,0,sizeof(cell_t));
  1083. cell.command = CELL_PADDING;
  1084. connection_or_write_cell_to_buf(&cell, or_conn);
  1085. }
  1086. }
  1087. /** Honor a NEWNYM request: make future requests unlinkable to past
  1088. * requests. */
  1089. static void
  1090. signewnym_impl(time_t now)
  1091. {
  1092. const or_options_t *options = get_options();
  1093. if (!proxy_mode(options)) {
  1094. log_info(LD_CONTROL, "Ignoring SIGNAL NEWNYM because client functionality "
  1095. "is disabled.");
  1096. return;
  1097. }
  1098. circuit_mark_all_dirty_circs_as_unusable();
  1099. addressmap_clear_transient();
  1100. rend_client_purge_state();
  1101. time_of_last_signewnym = now;
  1102. signewnym_is_pending = 0;
  1103. ++newnym_epoch;
  1104. control_event_signal(SIGNEWNYM);
  1105. }
  1106. /** Return the number of times that signewnym has been called. */
  1107. unsigned
  1108. get_signewnym_epoch(void)
  1109. {
  1110. return newnym_epoch;
  1111. }
  1112. /** True iff we have initialized all the members of <b>periodic_events</b>.
  1113. * Used to prevent double-initialization. */
  1114. static int periodic_events_initialized = 0;
  1115. /* Declare all the timer callback functions... */
  1116. #undef CALLBACK
  1117. #define CALLBACK(name) \
  1118. static int name ## _callback(time_t, const or_options_t *)
  1119. CALLBACK(rotate_onion_key);
  1120. CALLBACK(check_ed_keys);
  1121. CALLBACK(launch_descriptor_fetches);
  1122. CALLBACK(reset_descriptor_failures);
  1123. CALLBACK(rotate_x509_certificate);
  1124. CALLBACK(add_entropy);
  1125. CALLBACK(launch_reachability_tests);
  1126. CALLBACK(downrate_stability);
  1127. CALLBACK(save_stability);
  1128. CALLBACK(check_authority_cert);
  1129. CALLBACK(check_expired_networkstatus);
  1130. CALLBACK(write_stats_file);
  1131. CALLBACK(record_bridge_stats);
  1132. CALLBACK(clean_caches);
  1133. CALLBACK(rend_cache_failure_clean);
  1134. CALLBACK(retry_dns);
  1135. CALLBACK(check_descriptor);
  1136. CALLBACK(check_for_reachability_bw);
  1137. CALLBACK(fetch_networkstatus);
  1138. CALLBACK(retry_listeners);
  1139. CALLBACK(expire_old_ciruits_serverside);
  1140. CALLBACK(check_dns_honesty);
  1141. CALLBACK(write_bridge_ns);
  1142. CALLBACK(check_fw_helper_app);
  1143. CALLBACK(heartbeat);
  1144. #undef CALLBACK
  1145. /* Now we declare an array of periodic_event_item_t for each periodic event */
  1146. #define CALLBACK(name) PERIODIC_EVENT(name)
  1147. static periodic_event_item_t periodic_events[] = {
  1148. CALLBACK(rotate_onion_key),
  1149. CALLBACK(check_ed_keys),
  1150. CALLBACK(launch_descriptor_fetches),
  1151. CALLBACK(reset_descriptor_failures),
  1152. CALLBACK(rotate_x509_certificate),
  1153. CALLBACK(add_entropy),
  1154. CALLBACK(launch_reachability_tests),
  1155. CALLBACK(downrate_stability),
  1156. CALLBACK(save_stability),
  1157. CALLBACK(check_authority_cert),
  1158. CALLBACK(check_expired_networkstatus),
  1159. CALLBACK(write_stats_file),
  1160. CALLBACK(record_bridge_stats),
  1161. CALLBACK(clean_caches),
  1162. CALLBACK(rend_cache_failure_clean),
  1163. CALLBACK(retry_dns),
  1164. CALLBACK(check_descriptor),
  1165. CALLBACK(check_for_reachability_bw),
  1166. CALLBACK(fetch_networkstatus),
  1167. CALLBACK(retry_listeners),
  1168. CALLBACK(expire_old_ciruits_serverside),
  1169. CALLBACK(check_dns_honesty),
  1170. CALLBACK(write_bridge_ns),
  1171. CALLBACK(check_fw_helper_app),
  1172. CALLBACK(heartbeat),
  1173. END_OF_PERIODIC_EVENTS
  1174. };
  1175. #undef CALLBACK
  1176. /* These are pointers to members of periodic_events[] that are used to
  1177. * implement particular callbacks. We keep them separate here so that we
  1178. * can access them by name. We also keep them inside periodic_events[]
  1179. * so that we can implement "reset all timers" in a reasonable way. */
  1180. static periodic_event_item_t *check_descriptor_event=NULL;
  1181. static periodic_event_item_t *fetch_networkstatus_event=NULL;
  1182. static periodic_event_item_t *launch_descriptor_fetches_event=NULL;
  1183. static periodic_event_item_t *check_dns_honesty_event=NULL;
  1184. /** Reset all the periodic events so we'll do all our actions again as if we
  1185. * just started up.
  1186. * Useful if our clock just moved back a long time from the future,
  1187. * so we don't wait until that future arrives again before acting.
  1188. */
  1189. void
  1190. reset_all_main_loop_timers(void)
  1191. {
  1192. int i;
  1193. for (i = 0; periodic_events[i].name; ++i) {
  1194. periodic_event_reschedule(&periodic_events[i]);
  1195. }
  1196. }
  1197. /** Return the member of periodic_events[] whose name is <b>name</b>.
  1198. * Return NULL if no such event is found.
  1199. */
  1200. static periodic_event_item_t *
  1201. find_periodic_event(const char *name)
  1202. {
  1203. int i;
  1204. for (i = 0; periodic_events[i].name; ++i) {
  1205. if (strcmp(name, periodic_events[i].name) == 0)
  1206. return &periodic_events[i];
  1207. }
  1208. return NULL;
  1209. }
  1210. /** Helper, run one second after setup:
  1211. * Initializes all members of periodic_events and starts them running.
  1212. *
  1213. * (We do this one second after setup for backward-compatibility reasons;
  1214. * it might not actually be necessary.) */
  1215. static void
  1216. initialize_periodic_events_cb(evutil_socket_t fd, short events, void *data)
  1217. {
  1218. (void) fd;
  1219. (void) events;
  1220. (void) data;
  1221. int i;
  1222. for (i = 0; periodic_events[i].name; ++i) {
  1223. periodic_event_launch(&periodic_events[i]);
  1224. }
  1225. }
  1226. /** Set up all the members of periodic_events[], and configure them all to be
  1227. * launched from a callback. */
  1228. STATIC void
  1229. initialize_periodic_events(void)
  1230. {
  1231. tor_assert(periodic_events_initialized == 0);
  1232. periodic_events_initialized = 1;
  1233. int i;
  1234. for (i = 0; periodic_events[i].name; ++i) {
  1235. periodic_event_setup(&periodic_events[i]);
  1236. }
  1237. #define NAMED_CALLBACK(name) \
  1238. STMT_BEGIN name ## _event = find_periodic_event( #name ); STMT_END
  1239. NAMED_CALLBACK(check_descriptor);
  1240. NAMED_CALLBACK(fetch_networkstatus);
  1241. NAMED_CALLBACK(launch_descriptor_fetches);
  1242. NAMED_CALLBACK(check_dns_honesty);
  1243. struct timeval one_second = { 1, 0 };
  1244. event_base_once(tor_libevent_get_base(), -1, EV_TIMEOUT,
  1245. initialize_periodic_events_cb, NULL,
  1246. &one_second);
  1247. }
  1248. STATIC void
  1249. teardown_periodic_events(void)
  1250. {
  1251. int i;
  1252. for (i = 0; periodic_events[i].name; ++i) {
  1253. periodic_event_destroy(&periodic_events[i]);
  1254. }
  1255. }
  1256. /**
  1257. * Update our schedule so that we'll check whether we need to update our
  1258. * descriptor immediately, rather than after up to CHECK_DESCRIPTOR_INTERVAL
  1259. * seconds.
  1260. */
  1261. void
  1262. reschedule_descriptor_update_check(void)
  1263. {
  1264. tor_assert(check_descriptor_event);
  1265. periodic_event_reschedule(check_descriptor_event);
  1266. }
  1267. /**
  1268. * Update our schedule so that we'll check whether we need to fetch directory
  1269. * info immediately.
  1270. */
  1271. void
  1272. reschedule_directory_downloads(void)
  1273. {
  1274. tor_assert(fetch_networkstatus_event);
  1275. tor_assert(launch_descriptor_fetches_event);
  1276. periodic_event_reschedule(fetch_networkstatus_event);
  1277. periodic_event_reschedule(launch_descriptor_fetches_event);
  1278. }
  1279. #define LONGEST_TIMER_PERIOD (30 * 86400)
  1280. /** Helper: Return the number of seconds between <b>now</b> and <b>next</b>,
  1281. * clipped to the range [1 second, LONGEST_TIMER_PERIOD]. */
  1282. static inline int
  1283. safe_timer_diff(time_t now, time_t next)
  1284. {
  1285. if (next > now) {
  1286. /* There were no computers at signed TIME_MIN (1902 on 32-bit systems),
  1287. * and nothing that could run Tor. It's a bug if 'next' is around then.
  1288. * On 64-bit systems with signed TIME_MIN, TIME_MIN is before the Big
  1289. * Bang. We cannot extrapolate past a singularity, but there was probably
  1290. * nothing that could run Tor then, either.
  1291. **/
  1292. tor_assert(next > TIME_MIN + LONGEST_TIMER_PERIOD);
  1293. if (next - LONGEST_TIMER_PERIOD > now)
  1294. return LONGEST_TIMER_PERIOD;
  1295. return (int)(next - now);
  1296. } else {
  1297. return 1;
  1298. }
  1299. }
  1300. /** Perform regular maintenance tasks. This function gets run once per
  1301. * second by second_elapsed_callback().
  1302. */
  1303. static void
  1304. run_scheduled_events(time_t now)
  1305. {
  1306. const or_options_t *options = get_options();
  1307. /* 0. See if we've been asked to shut down and our timeout has
  1308. * expired; or if our bandwidth limits are exhausted and we
  1309. * should hibernate; or if it's time to wake up from hibernation.
  1310. */
  1311. consider_hibernation(now);
  1312. /* 0b. If we've deferred a signewnym, make sure it gets handled
  1313. * eventually. */
  1314. if (signewnym_is_pending &&
  1315. time_of_last_signewnym + MAX_SIGNEWNYM_RATE <= now) {
  1316. log_info(LD_CONTROL, "Honoring delayed NEWNYM request");
  1317. signewnym_impl(now);
  1318. }
  1319. /* 0c. If we've deferred log messages for the controller, handle them now */
  1320. flush_pending_log_callbacks();
  1321. if (options->UseBridges && !options->DisableNetwork) {
  1322. fetch_bridge_descriptors(options, now);
  1323. }
  1324. if (accounting_is_enabled(options)) {
  1325. accounting_run_housekeeping(now);
  1326. }
  1327. if (authdir_mode_v3(options)) {
  1328. dirvote_act(options, now);
  1329. }
  1330. /* 3a. Every second, we examine pending circuits and prune the
  1331. * ones which have been pending for more than a few seconds.
  1332. * We do this before step 4, so it can try building more if
  1333. * it's not comfortable with the number of available circuits.
  1334. */
  1335. /* (If our circuit build timeout can ever become lower than a second (which
  1336. * it can't, currently), we should do this more often.) */
  1337. circuit_expire_building();
  1338. /* 3b. Also look at pending streams and prune the ones that 'began'
  1339. * a long time ago but haven't gotten a 'connected' yet.
  1340. * Do this before step 4, so we can put them back into pending
  1341. * state to be picked up by the new circuit.
  1342. */
  1343. connection_ap_expire_beginning();
  1344. /* 3c. And expire connections that we've held open for too long.
  1345. */
  1346. connection_expire_held_open();
  1347. /* 4. Every second, we try a new circuit if there are no valid
  1348. * circuits. Every NewCircuitPeriod seconds, we expire circuits
  1349. * that became dirty more than MaxCircuitDirtiness seconds ago,
  1350. * and we make a new circ if there are no clean circuits.
  1351. */
  1352. const int have_dir_info = router_have_minimum_dir_info();
  1353. if (have_dir_info && !net_is_disabled()) {
  1354. circuit_build_needed_circs(now);
  1355. } else {
  1356. circuit_expire_old_circs_as_needed(now);
  1357. }
  1358. /* 5. We do housekeeping for each connection... */
  1359. connection_or_set_bad_connections(NULL, 0);
  1360. int i;
  1361. for (i=0;i<smartlist_len(connection_array);i++) {
  1362. run_connection_housekeeping(i, now);
  1363. }
  1364. /* 6. And remove any marked circuits... */
  1365. circuit_close_all_marked();
  1366. /* 7. And upload service descriptors if necessary. */
  1367. if (have_completed_a_circuit() && !net_is_disabled()) {
  1368. rend_consider_services_upload(now);
  1369. rend_consider_descriptor_republication();
  1370. }
  1371. /* 8. and blow away any connections that need to die. have to do this now,
  1372. * because if we marked a conn for close and left its socket -1, then
  1373. * we'll pass it to poll/select and bad things will happen.
  1374. */
  1375. close_closeable_connections();
  1376. /* 8b. And if anything in our state is ready to get flushed to disk, we
  1377. * flush it. */
  1378. or_state_save(now);
  1379. /* 8c. Do channel cleanup just like for connections */
  1380. channel_run_cleanup();
  1381. channel_listener_run_cleanup();
  1382. /* 11b. check pending unconfigured managed proxies */
  1383. if (!net_is_disabled() && pt_proxies_configuration_pending())
  1384. pt_configure_remaining_proxies();
  1385. }
  1386. static int
  1387. rotate_onion_key_callback(time_t now, const or_options_t *options)
  1388. {
  1389. /* 1a. Every MIN_ONION_KEY_LIFETIME seconds, rotate the onion keys,
  1390. * shut down and restart all cpuworkers, and update the directory if
  1391. * necessary.
  1392. */
  1393. if (server_mode(options)) {
  1394. time_t rotation_time = get_onion_key_set_at()+MIN_ONION_KEY_LIFETIME;
  1395. if (rotation_time > now) {
  1396. return safe_timer_diff(now, rotation_time);
  1397. }
  1398. log_info(LD_GENERAL,"Rotating onion key.");
  1399. rotate_onion_key();
  1400. cpuworkers_rotate_keyinfo();
  1401. if (router_rebuild_descriptor(1)<0) {
  1402. log_info(LD_CONFIG, "Couldn't rebuild router descriptor");
  1403. }
  1404. if (advertised_server_mode() && !options->DisableNetwork)
  1405. router_upload_dir_desc_to_dirservers(0);
  1406. return MIN_ONION_KEY_LIFETIME;
  1407. }
  1408. return PERIODIC_EVENT_NO_UPDATE;
  1409. }
  1410. static int
  1411. check_ed_keys_callback(time_t now, const or_options_t *options)
  1412. {
  1413. if (server_mode(options)) {
  1414. if (should_make_new_ed_keys(options, now)) {
  1415. if (load_ed_keys(options, now) < 0 ||
  1416. generate_ed_link_cert(options, now)) {
  1417. log_err(LD_OR, "Unable to update Ed25519 keys! Exiting.");
  1418. tor_cleanup();
  1419. exit(0);
  1420. }
  1421. }
  1422. return 30;
  1423. }
  1424. return PERIODIC_EVENT_NO_UPDATE;
  1425. }
  1426. static int
  1427. launch_descriptor_fetches_callback(time_t now, const or_options_t *options)
  1428. {
  1429. if (should_delay_dir_fetches(options, NULL))
  1430. return PERIODIC_EVENT_NO_UPDATE;
  1431. update_all_descriptor_downloads(now);
  1432. update_extrainfo_downloads(now);
  1433. if (router_have_minimum_dir_info())
  1434. return LAZY_DESCRIPTOR_RETRY_INTERVAL;
  1435. else
  1436. return GREEDY_DESCRIPTOR_RETRY_INTERVAL;
  1437. }
  1438. static int
  1439. reset_descriptor_failures_callback(time_t now, const or_options_t *options)
  1440. {
  1441. (void)now;
  1442. (void)options;
  1443. router_reset_descriptor_download_failures();
  1444. return DESCRIPTOR_FAILURE_RESET_INTERVAL;
  1445. }
  1446. static int
  1447. rotate_x509_certificate_callback(time_t now, const or_options_t *options)
  1448. {
  1449. static int first = 1;
  1450. (void)now;
  1451. (void)options;
  1452. if (first) {
  1453. first = 0;
  1454. return MAX_SSL_KEY_LIFETIME_INTERNAL;
  1455. }
  1456. /* 1b. Every MAX_SSL_KEY_LIFETIME_INTERNAL seconds, we change our
  1457. * TLS context. */
  1458. log_info(LD_GENERAL,"Rotating tls context.");
  1459. if (router_initialize_tls_context() < 0) {
  1460. log_warn(LD_BUG, "Error reinitializing TLS context");
  1461. tor_assert(0);
  1462. }
  1463. /* We also make sure to rotate the TLS connections themselves if they've
  1464. * been up for too long -- but that's done via is_bad_for_new_circs in
  1465. * run_connection_housekeeping() above. */
  1466. return MAX_SSL_KEY_LIFETIME_INTERNAL;
  1467. }
  1468. static int
  1469. add_entropy_callback(time_t now, const or_options_t *options)
  1470. {
  1471. (void)now;
  1472. (void)options;
  1473. /* We already seeded once, so don't die on failure. */
  1474. if (crypto_seed_rng() < 0) {
  1475. log_warn(LD_GENERAL, "Tried to re-seed RNG, but failed. We already "
  1476. "seeded once, though, so we won't exit here.");
  1477. }
  1478. /** How often do we add more entropy to OpenSSL's RNG pool? */
  1479. #define ENTROPY_INTERVAL (60*60)
  1480. return ENTROPY_INTERVAL;
  1481. }
  1482. static int
  1483. launch_reachability_tests_callback(time_t now, const or_options_t *options)
  1484. {
  1485. if (authdir_mode_tests_reachability(options) &&
  1486. !net_is_disabled()) {
  1487. /* try to determine reachability of the other Tor relays */
  1488. dirserv_test_reachability(now);
  1489. }
  1490. return REACHABILITY_TEST_INTERVAL;
  1491. }
  1492. static int
  1493. downrate_stability_callback(time_t now, const or_options_t *options)
  1494. {
  1495. (void)options;
  1496. /* 1d. Periodically, we discount older stability information so that new
  1497. * stability info counts more, and save the stability information to disk as
  1498. * appropriate. */
  1499. time_t next = rep_hist_downrate_old_runs(now);
  1500. return safe_timer_diff(now, next);
  1501. }
  1502. static int
  1503. save_stability_callback(time_t now, const or_options_t *options)
  1504. {
  1505. if (authdir_mode_tests_reachability(options)) {
  1506. if (rep_hist_record_mtbf_data(now, 1)<0) {
  1507. log_warn(LD_GENERAL, "Couldn't store mtbf data.");
  1508. }
  1509. }
  1510. #define SAVE_STABILITY_INTERVAL (30*60)
  1511. return SAVE_STABILITY_INTERVAL;
  1512. }
  1513. static int
  1514. check_authority_cert_callback(time_t now, const or_options_t *options)
  1515. {
  1516. (void)now;
  1517. (void)options;
  1518. /* 1e. Periodically, if we're a v3 authority, we check whether our cert is
  1519. * close to expiring and warn the admin if it is. */
  1520. v3_authority_check_key_expiry();
  1521. #define CHECK_V3_CERTIFICATE_INTERVAL (5*60)
  1522. return CHECK_V3_CERTIFICATE_INTERVAL;
  1523. }
  1524. static int
  1525. check_expired_networkstatus_callback(time_t now, const or_options_t *options)
  1526. {
  1527. (void)options;
  1528. /* 1f. Check whether our networkstatus has expired.
  1529. */
  1530. networkstatus_t *ns = networkstatus_get_latest_consensus();
  1531. /*XXXX RD: This value needs to be the same as REASONABLY_LIVE_TIME in
  1532. * networkstatus_get_reasonably_live_consensus(), but that value is way
  1533. * way too high. Arma: is the bridge issue there resolved yet? -NM */
  1534. #define NS_EXPIRY_SLOP (24*60*60)
  1535. if (ns && ns->valid_until < now+NS_EXPIRY_SLOP &&
  1536. router_have_minimum_dir_info()) {
  1537. router_dir_info_changed();
  1538. }
  1539. #define CHECK_EXPIRED_NS_INTERVAL (2*60)
  1540. return CHECK_EXPIRED_NS_INTERVAL;
  1541. }
  1542. static int
  1543. write_stats_file_callback(time_t now, const or_options_t *options)
  1544. {
  1545. /* 1g. Check whether we should write statistics to disk.
  1546. */
  1547. #define CHECK_WRITE_STATS_INTERVAL (60*60)
  1548. time_t next_time_to_write_stats_files = now + CHECK_WRITE_STATS_INTERVAL;
  1549. if (options->CellStatistics) {
  1550. time_t next_write =
  1551. rep_hist_buffer_stats_write(now);
  1552. if (next_write && next_write < next_time_to_write_stats_files)
  1553. next_time_to_write_stats_files = next_write;
  1554. }
  1555. if (options->DirReqStatistics) {
  1556. time_t next_write = geoip_dirreq_stats_write(now);
  1557. if (next_write && next_write < next_time_to_write_stats_files)
  1558. next_time_to_write_stats_files = next_write;
  1559. }
  1560. if (options->EntryStatistics) {
  1561. time_t next_write = geoip_entry_stats_write(now);
  1562. if (next_write && next_write < next_time_to_write_stats_files)
  1563. next_time_to_write_stats_files = next_write;
  1564. }
  1565. if (options->HiddenServiceStatistics) {
  1566. time_t next_write = rep_hist_hs_stats_write(now);
  1567. if (next_write && next_write < next_time_to_write_stats_files)
  1568. next_time_to_write_stats_files = next_write;
  1569. }
  1570. if (options->ExitPortStatistics) {
  1571. time_t next_write = rep_hist_exit_stats_write(now);
  1572. if (next_write && next_write < next_time_to_write_stats_files)
  1573. next_time_to_write_stats_files = next_write;
  1574. }
  1575. if (options->ConnDirectionStatistics) {
  1576. time_t next_write = rep_hist_conn_stats_write(now);
  1577. if (next_write && next_write < next_time_to_write_stats_files)
  1578. next_time_to_write_stats_files = next_write;
  1579. }
  1580. if (options->BridgeAuthoritativeDir) {
  1581. time_t next_write = rep_hist_desc_stats_write(now);
  1582. if (next_write && next_write < next_time_to_write_stats_files)
  1583. next_time_to_write_stats_files = next_write;
  1584. }
  1585. return safe_timer_diff(now, next_time_to_write_stats_files);
  1586. }
  1587. static int
  1588. record_bridge_stats_callback(time_t now, const or_options_t *options)
  1589. {
  1590. static int should_init_bridge_stats = 1;
  1591. /* 1h. Check whether we should write bridge statistics to disk.
  1592. */
  1593. if (should_record_bridge_info(options)) {
  1594. if (should_init_bridge_stats) {
  1595. /* (Re-)initialize bridge statistics. */
  1596. geoip_bridge_stats_init(now);
  1597. should_init_bridge_stats = 0;
  1598. return WRITE_STATS_INTERVAL;
  1599. } else {
  1600. /* Possibly write bridge statistics to disk and ask when to write
  1601. * them next time. */
  1602. time_t next = geoip_bridge_stats_write(now);
  1603. return safe_timer_diff(now, next);
  1604. }
  1605. } else if (!should_init_bridge_stats) {
  1606. /* Bridge mode was turned off. Ensure that stats are re-initialized
  1607. * next time bridge mode is turned on. */
  1608. should_init_bridge_stats = 1;
  1609. }
  1610. return PERIODIC_EVENT_NO_UPDATE;
  1611. }
  1612. static int
  1613. clean_caches_callback(time_t now, const or_options_t *options)
  1614. {
  1615. /* Remove old information from rephist and the rend cache. */
  1616. rep_history_clean(now - options->RephistTrackTime);
  1617. rend_cache_clean(now, REND_CACHE_TYPE_CLIENT);
  1618. rend_cache_clean(now, REND_CACHE_TYPE_SERVICE);
  1619. rend_cache_clean_v2_descs_as_dir(now, 0);
  1620. microdesc_cache_rebuild(NULL, 0);
  1621. #define CLEAN_CACHES_INTERVAL (30*60)
  1622. return CLEAN_CACHES_INTERVAL;
  1623. }
  1624. static int
  1625. rend_cache_failure_clean_callback(time_t now, const or_options_t *options)
  1626. {
  1627. (void)options;
  1628. /* We don't keep entries that are more than five minutes old so we try to
  1629. * clean it as soon as we can since we want to make sure the client waits
  1630. * as little as possible for reachability reasons. */
  1631. rend_cache_failure_clean(now);
  1632. return 30;
  1633. }
  1634. static int
  1635. retry_dns_callback(time_t now, const or_options_t *options)
  1636. {
  1637. (void)now;
  1638. #define RETRY_DNS_INTERVAL (10*60)
  1639. /* If we're a server and initializing dns failed, retry periodically. */
  1640. if (server_mode(options) && has_dns_init_failed())
  1641. dns_init();
  1642. return RETRY_DNS_INTERVAL;
  1643. }
  1644. /* 2. Periodically, we consider force-uploading our descriptor
  1645. * (if we've passed our internal checks). */
  1646. static int
  1647. check_descriptor_callback(time_t now, const or_options_t *options)
  1648. {
  1649. /** How often do we check whether part of our router info has changed in a
  1650. * way that would require an upload? That includes checking whether our IP
  1651. * address has changed. */
  1652. #define CHECK_DESCRIPTOR_INTERVAL (60)
  1653. /* 2b. Once per minute, regenerate and upload the descriptor if the old
  1654. * one is inaccurate. */
  1655. if (!options->DisableNetwork) {
  1656. check_descriptor_bandwidth_changed(now);
  1657. check_descriptor_ipaddress_changed(now);
  1658. mark_my_descriptor_dirty_if_too_old(now);
  1659. consider_publishable_server(0);
  1660. /* If any networkstatus documents are no longer recent, we need to
  1661. * update all the descriptors' running status. */
  1662. /* Remove dead routers. */
  1663. /* XXXX This doesn't belong here, but it was here in the pre-
  1664. * XXXX refactoring code. */
  1665. routerlist_remove_old_routers();
  1666. }
  1667. return CHECK_DESCRIPTOR_INTERVAL;
  1668. }
  1669. static int
  1670. check_for_reachability_bw_callback(time_t now, const or_options_t *options)
  1671. {
  1672. /* XXXX This whole thing was stuck in the middle of what is now
  1673. * XXXX check_descriptor_callback. I'm not sure it's right. */
  1674. static int dirport_reachability_count = 0;
  1675. /* also, check religiously for reachability, if it's within the first
  1676. * 20 minutes of our uptime. */
  1677. if (server_mode(options) &&
  1678. (have_completed_a_circuit() || !any_predicted_circuits(now)) &&
  1679. !we_are_hibernating()) {
  1680. if (stats_n_seconds_working < TIMEOUT_UNTIL_UNREACHABILITY_COMPLAINT) {
  1681. consider_testing_reachability(1, dirport_reachability_count==0);
  1682. if (++dirport_reachability_count > 5)
  1683. dirport_reachability_count = 0;
  1684. return 1;
  1685. } else {
  1686. /* If we haven't checked for 12 hours and our bandwidth estimate is
  1687. * low, do another bandwidth test. This is especially important for
  1688. * bridges, since they might go long periods without much use. */
  1689. const routerinfo_t *me = router_get_my_routerinfo();
  1690. static int first_time = 1;
  1691. if (!first_time && me &&
  1692. me->bandwidthcapacity < me->bandwidthrate &&
  1693. me->bandwidthcapacity < 51200) {
  1694. reset_bandwidth_test();
  1695. }
  1696. first_time = 0;
  1697. #define BANDWIDTH_RECHECK_INTERVAL (12*60*60)
  1698. return BANDWIDTH_RECHECK_INTERVAL;
  1699. }
  1700. }
  1701. return CHECK_DESCRIPTOR_INTERVAL;
  1702. }
  1703. static int
  1704. fetch_networkstatus_callback(time_t now, const or_options_t *options)
  1705. {
  1706. /* 2c. Every minute (or every second if TestingTorNetwork, or during
  1707. * client bootstrap), check whether we want to download any networkstatus
  1708. * documents. */
  1709. /* How often do we check whether we should download network status
  1710. * documents? */
  1711. const int we_are_bootstrapping = networkstatus_consensus_is_bootstrapping(
  1712. now);
  1713. const int prefer_mirrors = !directory_fetches_from_authorities(
  1714. get_options());
  1715. int networkstatus_dl_check_interval = 60;
  1716. /* check more often when testing, or when bootstrapping from mirrors
  1717. * (connection limits prevent too many connections being made) */
  1718. if (options->TestingTorNetwork
  1719. || (we_are_bootstrapping && prefer_mirrors)) {
  1720. networkstatus_dl_check_interval = 1;
  1721. }
  1722. if (should_delay_dir_fetches(options, NULL))
  1723. return PERIODIC_EVENT_NO_UPDATE;
  1724. update_networkstatus_downloads(now);
  1725. return networkstatus_dl_check_interval;
  1726. }
  1727. static int
  1728. retry_listeners_callback(time_t now, const or_options_t *options)
  1729. {
  1730. (void)now;
  1731. (void)options;
  1732. /* 3d. And every 60 seconds, we relaunch listeners if any died. */
  1733. if (!net_is_disabled()) {
  1734. retry_all_listeners(NULL, NULL, 0);
  1735. return 60;
  1736. }
  1737. return PERIODIC_EVENT_NO_UPDATE;
  1738. }
  1739. static int
  1740. expire_old_ciruits_serverside_callback(time_t now, const or_options_t *options)
  1741. {
  1742. (void)options;
  1743. /* every 11 seconds, so not usually the same second as other such events */
  1744. circuit_expire_old_circuits_serverside(now);
  1745. return 11;
  1746. }
  1747. static int
  1748. check_dns_honesty_callback(time_t now, const or_options_t *options)
  1749. {
  1750. (void)now;
  1751. /* 9. and if we're an exit node, check whether our DNS is telling stories
  1752. * to us. */
  1753. if (net_is_disabled() ||
  1754. ! public_server_mode(options) ||
  1755. router_my_exit_policy_is_reject_star())
  1756. return PERIODIC_EVENT_NO_UPDATE;
  1757. static int first_time = 1;
  1758. if (first_time) {
  1759. /* Don't launch right when we start */
  1760. first_time = 0;
  1761. return crypto_rand_int_range(60, 180);
  1762. }
  1763. dns_launch_correctness_checks();
  1764. return 12*3600 + crypto_rand_int(12*3600);
  1765. }
  1766. static int
  1767. write_bridge_ns_callback(time_t now, const or_options_t *options)
  1768. {
  1769. /* 10. write bridge networkstatus file to disk */
  1770. if (options->BridgeAuthoritativeDir) {
  1771. networkstatus_dump_bridge_status_to_file(now);
  1772. #define BRIDGE_STATUSFILE_INTERVAL (30*60)
  1773. return BRIDGE_STATUSFILE_INTERVAL;
  1774. }
  1775. return PERIODIC_EVENT_NO_UPDATE;
  1776. }
  1777. static int
  1778. check_fw_helper_app_callback(time_t now, const or_options_t *options)
  1779. {
  1780. if (net_is_disabled() ||
  1781. ! server_mode(options) ||
  1782. ! options->PortForwarding) {
  1783. return PERIODIC_EVENT_NO_UPDATE;
  1784. }
  1785. /* 11. check the port forwarding app */
  1786. #define PORT_FORWARDING_CHECK_INTERVAL 5
  1787. smartlist_t *ports_to_forward = get_list_of_ports_to_forward();
  1788. if (ports_to_forward) {
  1789. tor_check_port_forwarding(options->PortForwardingHelper,
  1790. ports_to_forward,
  1791. now);
  1792. SMARTLIST_FOREACH(ports_to_forward, char *, cp, tor_free(cp));
  1793. smartlist_free(ports_to_forward);
  1794. }
  1795. return PORT_FORWARDING_CHECK_INTERVAL;
  1796. }
  1797. /** Callback to write heartbeat message in the logs. */
  1798. static int
  1799. heartbeat_callback(time_t now, const or_options_t *options)
  1800. {
  1801. static int first = 1;
  1802. /* Check if heartbeat is disabled */
  1803. if (!options->HeartbeatPeriod) {
  1804. return PERIODIC_EVENT_NO_UPDATE;
  1805. }
  1806. /* Write the heartbeat message */
  1807. if (first) {
  1808. first = 0; /* Skip the first one. */
  1809. } else {
  1810. log_heartbeat(now);
  1811. }
  1812. return options->HeartbeatPeriod;
  1813. }
  1814. /** Timer: used to invoke second_elapsed_callback() once per second. */
  1815. static periodic_timer_t *second_timer = NULL;
  1816. /** Number of libevent errors in the last second: we die if we get too many. */
  1817. static int n_libevent_errors = 0;
  1818. /** Libevent callback: invoked once every second. */
  1819. static void
  1820. second_elapsed_callback(periodic_timer_t *timer, void *arg)
  1821. {
  1822. /* XXXX This could be sensibly refactored into multiple callbacks, and we
  1823. * could use Libevent's timers for this rather than checking the current
  1824. * time against a bunch of timeouts every second. */
  1825. static time_t current_second = 0;
  1826. time_t now;
  1827. size_t bytes_written;
  1828. size_t bytes_read;
  1829. int seconds_elapsed;
  1830. const or_options_t *options = get_options();
  1831. (void)timer;
  1832. (void)arg;
  1833. n_libevent_errors = 0;
  1834. /* log_notice(LD_GENERAL, "Tick."); */
  1835. now = time(NULL);
  1836. update_approx_time(now);
  1837. /* the second has rolled over. check more stuff. */
  1838. seconds_elapsed = current_second ? (int)(now - current_second) : 0;
  1839. #ifdef USE_BUFFEREVENTS
  1840. {
  1841. uint64_t cur_read,cur_written;
  1842. connection_get_rate_limit_totals(&cur_read, &cur_written);
  1843. bytes_written = (size_t)(cur_written - stats_prev_n_written);
  1844. bytes_read = (size_t)(cur_read - stats_prev_n_read);
  1845. stats_n_bytes_read += bytes_read;
  1846. stats_n_bytes_written += bytes_written;
  1847. if (accounting_is_enabled(options) && seconds_elapsed >= 0)
  1848. accounting_add_bytes(bytes_read, bytes_written, seconds_elapsed);
  1849. stats_prev_n_written = cur_written;
  1850. stats_prev_n_read = cur_read;
  1851. }
  1852. #else
  1853. bytes_read = (size_t)(stats_n_bytes_read - stats_prev_n_read);
  1854. bytes_written = (size_t)(stats_n_bytes_written - stats_prev_n_written);
  1855. stats_prev_n_read = stats_n_bytes_read;
  1856. stats_prev_n_written = stats_n_bytes_written;
  1857. #endif
  1858. control_event_bandwidth_used((uint32_t)bytes_read,(uint32_t)bytes_written);
  1859. control_event_stream_bandwidth_used();
  1860. control_event_conn_bandwidth_used();
  1861. control_event_circ_bandwidth_used();
  1862. control_event_circuit_cell_stats();
  1863. if (server_mode(options) &&
  1864. !net_is_disabled() &&
  1865. seconds_elapsed > 0 &&
  1866. have_completed_a_circuit() &&
  1867. stats_n_seconds_working / TIMEOUT_UNTIL_UNREACHABILITY_COMPLAINT !=
  1868. (stats_n_seconds_working+seconds_elapsed) /
  1869. TIMEOUT_UNTIL_UNREACHABILITY_COMPLAINT) {
  1870. /* every 20 minutes, check and complain if necessary */
  1871. const routerinfo_t *me = router_get_my_routerinfo();
  1872. if (me && !check_whether_orport_reachable(options)) {
  1873. char *address = tor_dup_ip(me->addr);
  1874. log_warn(LD_CONFIG,"Your server (%s:%d) has not managed to confirm that "
  1875. "its ORPort is reachable. Relays do not publish descriptors "
  1876. "until their ORPort and DirPort are reachable. Please check "
  1877. "your firewalls, ports, address, /etc/hosts file, etc.",
  1878. address, me->or_port);
  1879. control_event_server_status(LOG_WARN,
  1880. "REACHABILITY_FAILED ORADDRESS=%s:%d",
  1881. address, me->or_port);
  1882. tor_free(address);
  1883. }
  1884. if (me && !check_whether_dirport_reachable(options)) {
  1885. char *address = tor_dup_ip(me->addr);
  1886. log_warn(LD_CONFIG,
  1887. "Your server (%s:%d) has not managed to confirm that its "
  1888. "DirPort is reachable. Relays do not publish descriptors "
  1889. "until their ORPort and DirPort are reachable. Please check "
  1890. "your firewalls, ports, address, /etc/hosts file, etc.",
  1891. address, me->dir_port);
  1892. control_event_server_status(LOG_WARN,
  1893. "REACHABILITY_FAILED DIRADDRESS=%s:%d",
  1894. address, me->dir_port);
  1895. tor_free(address);
  1896. }
  1897. }
  1898. /** If more than this many seconds have elapsed, probably the clock
  1899. * jumped: doesn't count. */
  1900. #define NUM_JUMPED_SECONDS_BEFORE_WARN 100
  1901. if (seconds_elapsed < -NUM_JUMPED_SECONDS_BEFORE_WARN ||
  1902. seconds_elapsed >= NUM_JUMPED_SECONDS_BEFORE_WARN) {
  1903. circuit_note_clock_jumped(seconds_elapsed);
  1904. } else if (seconds_elapsed > 0)
  1905. stats_n_seconds_working += seconds_elapsed;
  1906. run_scheduled_events(now);
  1907. current_second = now; /* remember which second it is, for next time */
  1908. }
  1909. #ifdef HAVE_SYSTEMD_209
  1910. static periodic_timer_t *systemd_watchdog_timer = NULL;
  1911. /** Libevent callback: invoked to reset systemd watchdog. */
  1912. static void
  1913. systemd_watchdog_callback(periodic_timer_t *timer, void *arg)
  1914. {
  1915. (void)timer;
  1916. (void)arg;
  1917. sd_notify(0, "WATCHDOG=1");
  1918. }
  1919. #endif
  1920. #ifndef USE_BUFFEREVENTS
  1921. /** Timer: used to invoke refill_callback(). */
  1922. static periodic_timer_t *refill_timer = NULL;
  1923. /** Libevent callback: invoked periodically to refill token buckets
  1924. * and count r/w bytes. It is only used when bufferevents are disabled. */
  1925. static void
  1926. refill_callback(periodic_timer_t *timer, void *arg)
  1927. {
  1928. static struct timeval current_millisecond;
  1929. struct timeval now;
  1930. size_t bytes_written;
  1931. size_t bytes_read;
  1932. int milliseconds_elapsed = 0;
  1933. int seconds_rolled_over = 0;
  1934. const or_options_t *options = get_options();
  1935. (void)timer;
  1936. (void)arg;
  1937. tor_gettimeofday(&now);
  1938. /* If this is our first time, no time has passed. */
  1939. if (current_millisecond.tv_sec) {
  1940. long mdiff = tv_mdiff(&current_millisecond, &now);
  1941. if (mdiff > INT_MAX)
  1942. mdiff = INT_MAX;
  1943. milliseconds_elapsed = (int)mdiff;
  1944. seconds_rolled_over = (int)(now.tv_sec - current_millisecond.tv_sec);
  1945. }
  1946. bytes_written = stats_prev_global_write_bucket - global_write_bucket;
  1947. bytes_read = stats_prev_global_read_bucket - global_read_bucket;
  1948. stats_n_bytes_read += bytes_read;
  1949. stats_n_bytes_written += bytes_written;
  1950. if (accounting_is_enabled(options) && milliseconds_elapsed >= 0)
  1951. accounting_add_bytes(bytes_read, bytes_written, seconds_rolled_over);
  1952. if (milliseconds_elapsed > 0)
  1953. connection_bucket_refill(milliseconds_elapsed, (time_t)now.tv_sec);
  1954. stats_prev_global_read_bucket = global_read_bucket;
  1955. stats_prev_global_write_bucket = global_write_bucket;
  1956. current_millisecond = now; /* remember what time it is, for next time */
  1957. }
  1958. #endif
  1959. #ifndef _WIN32
  1960. /** Called when a possibly ignorable libevent error occurs; ensures that we
  1961. * don't get into an infinite loop by ignoring too many errors from
  1962. * libevent. */
  1963. static int
  1964. got_libevent_error(void)
  1965. {
  1966. if (++n_libevent_errors > 8) {
  1967. log_err(LD_NET, "Too many libevent errors in one second; dying");
  1968. return -1;
  1969. }
  1970. return 0;
  1971. }
  1972. #endif
  1973. #define UPTIME_CUTOFF_FOR_NEW_BANDWIDTH_TEST (6*60*60)
  1974. /** Called when our IP address seems to have changed. <b>at_interface</b>
  1975. * should be true if we detected a change in our interface, and false if we
  1976. * detected a change in our published address. */
  1977. void
  1978. ip_address_changed(int at_interface)
  1979. {
  1980. const or_options_t *options = get_options();
  1981. int server = server_mode(options);
  1982. int exit_reject_private = (server && options->ExitRelay
  1983. && options->ExitPolicyRejectPrivate);
  1984. if (at_interface) {
  1985. if (! server) {
  1986. /* Okay, change our keys. */
  1987. if (init_keys_client() < 0)
  1988. log_warn(LD_GENERAL, "Unable to rotate keys after IP change!");
  1989. }
  1990. } else {
  1991. if (server) {
  1992. if (stats_n_seconds_working > UPTIME_CUTOFF_FOR_NEW_BANDWIDTH_TEST)
  1993. reset_bandwidth_test();
  1994. stats_n_seconds_working = 0;
  1995. router_reset_reachability();
  1996. }
  1997. }
  1998. /* Exit relays incorporate interface addresses in their exit policies when
  1999. * ExitPolicyRejectPrivate is set */
  2000. if (exit_reject_private || (server && !at_interface)) {
  2001. mark_my_descriptor_dirty("IP address changed");
  2002. }
  2003. dns_servers_relaunch_checks();
  2004. }
  2005. /** Forget what we've learned about the correctness of our DNS servers, and
  2006. * start learning again. */
  2007. void
  2008. dns_servers_relaunch_checks(void)
  2009. {
  2010. if (server_mode(get_options())) {
  2011. dns_reset_correctness_checks();
  2012. if (periodic_events_initialized) {
  2013. tor_assert(check_dns_honesty_event);
  2014. periodic_event_reschedule(check_dns_honesty_event);
  2015. }
  2016. }
  2017. }
  2018. /** Called when we get a SIGHUP: reload configuration files and keys,
  2019. * retry all connections, and so on. */
  2020. static int
  2021. do_hup(void)
  2022. {
  2023. const or_options_t *options = get_options();
  2024. #ifdef USE_DMALLOC
  2025. dmalloc_log_stats();
  2026. dmalloc_log_changed(0, 1, 0, 0);
  2027. #endif
  2028. log_notice(LD_GENERAL,"Received reload signal (hup). Reloading config and "
  2029. "resetting internal state.");
  2030. if (accounting_is_enabled(options))
  2031. accounting_record_bandwidth_usage(time(NULL), get_or_state());
  2032. router_reset_warnings();
  2033. routerlist_reset_warnings();
  2034. /* first, reload config variables, in case they've changed */
  2035. if (options->ReloadTorrcOnSIGHUP) {
  2036. /* no need to provide argc/v, they've been cached in init_from_config */
  2037. if (options_init_from_torrc(0, NULL) < 0) {
  2038. log_err(LD_CONFIG,"Reading config failed--see warnings above. "
  2039. "For usage, try -h.");
  2040. return -1;
  2041. }
  2042. options = get_options(); /* they have changed now */
  2043. /* Logs are only truncated the first time they are opened, but were
  2044. probably intended to be cleaned up on signal. */
  2045. if (options->TruncateLogFile)
  2046. truncate_logs();
  2047. } else {
  2048. char *msg = NULL;
  2049. log_notice(LD_GENERAL, "Not reloading config file: the controller told "
  2050. "us not to.");
  2051. /* Make stuff get rescanned, reloaded, etc. */
  2052. if (set_options((or_options_t*)options, &msg) < 0) {
  2053. if (!msg)
  2054. msg = tor_strdup("Unknown error");
  2055. log_warn(LD_GENERAL, "Unable to re-set previous options: %s", msg);
  2056. tor_free(msg);
  2057. }
  2058. }
  2059. if (authdir_mode_handles_descs(options, -1)) {
  2060. /* reload the approved-routers file */
  2061. if (dirserv_load_fingerprint_file() < 0) {
  2062. /* warnings are logged from dirserv_load_fingerprint_file() directly */
  2063. log_info(LD_GENERAL, "Error reloading fingerprints. "
  2064. "Continuing with old list.");
  2065. }
  2066. }
  2067. /* Rotate away from the old dirty circuits. This has to be done
  2068. * after we've read the new options, but before we start using
  2069. * circuits for directory fetches. */
  2070. circuit_mark_all_dirty_circs_as_unusable();
  2071. /* retry appropriate downloads */
  2072. router_reset_status_download_failures();
  2073. router_reset_descriptor_download_failures();
  2074. if (!options->DisableNetwork)
  2075. update_networkstatus_downloads(time(NULL));
  2076. /* We'll retry routerstatus downloads in about 10 seconds; no need to
  2077. * force a retry there. */
  2078. if (server_mode(options)) {
  2079. /* Maybe we've been given a new ed25519 key or certificate?
  2080. */
  2081. time_t now = approx_time();
  2082. if (load_ed_keys(options, now) < 0 ||
  2083. generate_ed_link_cert(options, now)) {
  2084. log_warn(LD_OR, "Problem reloading Ed25519 keys; still using old keys.");
  2085. }
  2086. /* Update cpuworker and dnsworker processes, so they get up-to-date
  2087. * configuration options. */
  2088. cpuworkers_rotate_keyinfo();
  2089. dns_reset();
  2090. }
  2091. return 0;
  2092. }
  2093. /** Tor main loop. */
  2094. int
  2095. do_main_loop(void)
  2096. {
  2097. time_t now;
  2098. /* initialize the periodic events first, so that code that depends on the
  2099. * events being present does not assert.
  2100. */
  2101. if (! periodic_events_initialized) {
  2102. initialize_periodic_events();
  2103. }
  2104. /* initialize dns resolve map, spawn workers if needed */
  2105. if (dns_init() < 0) {
  2106. if (get_options()->ServerDNSAllowBrokenConfig)
  2107. log_warn(LD_GENERAL, "Couldn't set up any working nameservers. "
  2108. "Network not up yet? Will try again soon.");
  2109. else {
  2110. log_err(LD_GENERAL,"Error initializing dns subsystem; exiting. To "
  2111. "retry instead, set the ServerDNSAllowBrokenResolvConf option.");
  2112. }
  2113. }
  2114. #ifdef USE_BUFFEREVENTS
  2115. log_warn(LD_GENERAL, "Tor was compiled with the --enable-bufferevents "
  2116. "option. This is still experimental, and might cause strange "
  2117. "bugs. If you want a more stable Tor, be sure to build without "
  2118. "--enable-bufferevents.");
  2119. #endif
  2120. handle_signals(1);
  2121. /* load the private keys, if we're supposed to have them, and set up the
  2122. * TLS context. */
  2123. if (! client_identity_key_is_set()) {
  2124. if (init_keys() < 0) {
  2125. log_err(LD_OR, "Error initializing keys; exiting");
  2126. return -1;
  2127. }
  2128. }
  2129. /* Set up our buckets */
  2130. connection_bucket_init();
  2131. #ifndef USE_BUFFEREVENTS
  2132. stats_prev_global_read_bucket = global_read_bucket;
  2133. stats_prev_global_write_bucket = global_write_bucket;
  2134. #endif
  2135. /* initialize the bootstrap status events to know we're starting up */
  2136. control_event_bootstrap(BOOTSTRAP_STATUS_STARTING, 0);
  2137. /* Initialize the keypinning log. */
  2138. if (authdir_mode_v3(get_options())) {
  2139. char *fname = get_datadir_fname("key-pinning-journal");
  2140. int r = 0;
  2141. if (keypin_load_journal(fname)<0) {
  2142. log_err(LD_DIR, "Error loading key-pinning journal: %s",strerror(errno));
  2143. r = -1;
  2144. }
  2145. if (keypin_open_journal(fname)<0) {
  2146. log_err(LD_DIR, "Error opening key-pinning journal: %s",strerror(errno));
  2147. r = -1;
  2148. }
  2149. tor_free(fname);
  2150. if (r)
  2151. return r;
  2152. }
  2153. {
  2154. /* This is the old name for key-pinning-journal. These got corrupted
  2155. * in a couple of cases by #16530, so we started over. See #16580 for
  2156. * the rationale and for other options we didn't take. We can remove
  2157. * this code once all the authorities that ran 0.2.7.1-alpha-dev are
  2158. * upgraded.
  2159. */
  2160. char *fname = get_datadir_fname("key-pinning-entries");
  2161. unlink(fname);
  2162. tor_free(fname);
  2163. }
  2164. if (trusted_dirs_reload_certs()) {
  2165. log_warn(LD_DIR,
  2166. "Couldn't load all cached v3 certificates. Starting anyway.");
  2167. }
  2168. if (router_reload_consensus_networkstatus()) {
  2169. return -1;
  2170. }
  2171. /* load the routers file, or assign the defaults. */
  2172. if (router_reload_router_list()) {
  2173. return -1;
  2174. }
  2175. /* load the networkstatuses. (This launches a download for new routers as
  2176. * appropriate.)
  2177. */
  2178. now = time(NULL);
  2179. directory_info_has_arrived(now, 1, 0);
  2180. if (server_mode(get_options())) {
  2181. /* launch cpuworkers. Need to do this *after* we've read the onion key. */
  2182. cpu_init();
  2183. }
  2184. /* set up once-a-second callback. */
  2185. if (! second_timer) {
  2186. struct timeval one_second;
  2187. one_second.tv_sec = 1;
  2188. one_second.tv_usec = 0;
  2189. second_timer = periodic_timer_new(tor_libevent_get_base(),
  2190. &one_second,
  2191. second_elapsed_callback,
  2192. NULL);
  2193. tor_assert(second_timer);
  2194. }
  2195. #ifdef HAVE_SYSTEMD_209
  2196. uint64_t watchdog_delay;
  2197. /* set up systemd watchdog notification. */
  2198. if (sd_watchdog_enabled(1, &watchdog_delay) > 0) {
  2199. if (! systemd_watchdog_timer) {
  2200. struct timeval watchdog;
  2201. /* The manager will "act on" us if we don't send them a notification
  2202. * every 'watchdog_delay' microseconds. So, send notifications twice
  2203. * that often. */
  2204. watchdog_delay /= 2;
  2205. watchdog.tv_sec = watchdog_delay / 1000000;
  2206. watchdog.tv_usec = watchdog_delay % 1000000;
  2207. systemd_watchdog_timer = periodic_timer_new(tor_libevent_get_base(),
  2208. &watchdog,
  2209. systemd_watchdog_callback,
  2210. NULL);
  2211. tor_assert(systemd_watchdog_timer);
  2212. }
  2213. }
  2214. #endif
  2215. #ifndef USE_BUFFEREVENTS
  2216. if (!refill_timer) {
  2217. struct timeval refill_interval;
  2218. int msecs = get_options()->TokenBucketRefillInterval;
  2219. refill_interval.tv_sec = msecs/1000;
  2220. refill_interval.tv_usec = (msecs%1000)*1000;
  2221. refill_timer = periodic_timer_new(tor_libevent_get_base(),
  2222. &refill_interval,
  2223. refill_callback,
  2224. NULL);
  2225. tor_assert(refill_timer);
  2226. }
  2227. #endif
  2228. #ifdef HAVE_SYSTEMD
  2229. {
  2230. const int r = sd_notify(0, "READY=1");
  2231. if (r < 0) {
  2232. log_warn(LD_GENERAL, "Unable to send readiness to systemd: %s",
  2233. strerror(r));
  2234. } else if (r > 0) {
  2235. log_notice(LD_GENERAL, "Signaled readiness to systemd");
  2236. } else {
  2237. log_info(LD_GENERAL, "Systemd NOTIFY_SOCKET not present.");
  2238. }
  2239. }
  2240. #endif
  2241. return run_main_loop_until_done();
  2242. }
  2243. /**
  2244. * Run the main loop a single time. Return 0 for "exit"; -1 for "exit with
  2245. * error", and 1 for "run this again."
  2246. */
  2247. static int
  2248. run_main_loop_once(void)
  2249. {
  2250. int loop_result;
  2251. if (nt_service_is_stopping())
  2252. return 0;
  2253. #ifndef _WIN32
  2254. /* Make it easier to tell whether libevent failure is our fault or not. */
  2255. errno = 0;
  2256. #endif
  2257. /* All active linked conns should get their read events activated. */
  2258. SMARTLIST_FOREACH(active_linked_connection_lst, connection_t *, conn,
  2259. event_active(conn->read_event, EV_READ, 1));
  2260. called_loop_once = smartlist_len(active_linked_connection_lst) ? 1 : 0;
  2261. update_approx_time(time(NULL));
  2262. /* poll until we have an event, or the second ends, or until we have
  2263. * some active linked connections to trigger events for. */
  2264. loop_result = event_base_loop(tor_libevent_get_base(),
  2265. called_loop_once ? EVLOOP_ONCE : 0);
  2266. /* let catch() handle things like ^c, and otherwise don't worry about it */
  2267. if (loop_result < 0) {
  2268. int e = tor_socket_errno(-1);
  2269. /* let the program survive things like ^z */
  2270. if (e != EINTR && !ERRNO_IS_EINPROGRESS(e)) {
  2271. log_err(LD_NET,"libevent call with %s failed: %s [%d]",
  2272. tor_libevent_get_method(), tor_socket_strerror(e), e);
  2273. return -1;
  2274. #ifndef _WIN32
  2275. } else if (e == EINVAL) {
  2276. log_warn(LD_NET, "EINVAL from libevent: should you upgrade libevent?");
  2277. if (got_libevent_error())
  2278. return -1;
  2279. #endif
  2280. } else {
  2281. if (ERRNO_IS_EINPROGRESS(e))
  2282. log_warn(LD_BUG,
  2283. "libevent call returned EINPROGRESS? Please report.");
  2284. log_debug(LD_NET,"libevent call interrupted.");
  2285. /* You can't trust the results of this poll(). Go back to the
  2286. * top of the big for loop. */
  2287. return 1;
  2288. }
  2289. }
  2290. /* This will be pretty fast if nothing new is pending. Note that this gets
  2291. * called once per libevent loop, which will make it happen once per group
  2292. * of events that fire, or once per second. */
  2293. connection_ap_attach_pending(0);
  2294. return 1;
  2295. }
  2296. /** Run the run_main_loop_once() function until it declares itself done,
  2297. * and return its final return value.
  2298. *
  2299. * Shadow won't invoke this function, so don't fill it up with things.
  2300. */
  2301. static int
  2302. run_main_loop_until_done(void)
  2303. {
  2304. int loop_result = 1;
  2305. do {
  2306. loop_result = run_main_loop_once();
  2307. } while (loop_result == 1);
  2308. return loop_result;
  2309. }
  2310. /** Libevent callback: invoked when we get a signal.
  2311. */
  2312. static void
  2313. signal_callback(evutil_socket_t fd, short events, void *arg)
  2314. {
  2315. const int *sigptr = arg;
  2316. const int sig = *sigptr;
  2317. (void)fd;
  2318. (void)events;
  2319. process_signal(sig);
  2320. }
  2321. /** Do the work of acting on a signal received in <b>sig</b> */
  2322. static void
  2323. process_signal(int sig)
  2324. {
  2325. switch (sig)
  2326. {
  2327. case SIGTERM:
  2328. log_notice(LD_GENERAL,"Catching signal TERM, exiting cleanly.");
  2329. tor_cleanup();
  2330. exit(0);
  2331. break;
  2332. case SIGINT:
  2333. if (!server_mode(get_options())) { /* do it now */
  2334. log_notice(LD_GENERAL,"Interrupt: exiting cleanly.");
  2335. tor_cleanup();
  2336. exit(0);
  2337. }
  2338. #ifdef HAVE_SYSTEMD
  2339. sd_notify(0, "STOPPING=1");
  2340. #endif
  2341. hibernate_begin_shutdown();
  2342. break;
  2343. #ifdef SIGPIPE
  2344. case SIGPIPE:
  2345. log_debug(LD_GENERAL,"Caught SIGPIPE. Ignoring.");
  2346. break;
  2347. #endif
  2348. case SIGUSR1:
  2349. /* prefer to log it at INFO, but make sure we always see it */
  2350. dumpstats(get_min_log_level()<LOG_INFO ? get_min_log_level() : LOG_INFO);
  2351. control_event_signal(sig);
  2352. break;
  2353. case SIGUSR2:
  2354. switch_logs_debug();
  2355. log_debug(LD_GENERAL,"Caught USR2, going to loglevel debug. "
  2356. "Send HUP to change back.");
  2357. control_event_signal(sig);
  2358. break;
  2359. case SIGHUP:
  2360. #ifdef HAVE_SYSTEMD
  2361. sd_notify(0, "RELOADING=1");
  2362. #endif
  2363. if (do_hup() < 0) {
  2364. log_warn(LD_CONFIG,"Restart failed (config error?). Exiting.");
  2365. tor_cleanup();
  2366. exit(1);
  2367. }
  2368. #ifdef HAVE_SYSTEMD
  2369. sd_notify(0, "READY=1");
  2370. #endif
  2371. control_event_signal(sig);
  2372. break;
  2373. #ifdef SIGCHLD
  2374. case SIGCHLD:
  2375. notify_pending_waitpid_callbacks();
  2376. break;
  2377. #endif
  2378. case SIGNEWNYM: {
  2379. time_t now = time(NULL);
  2380. if (time_of_last_signewnym + MAX_SIGNEWNYM_RATE > now) {
  2381. signewnym_is_pending = 1;
  2382. log_notice(LD_CONTROL,
  2383. "Rate limiting NEWNYM request: delaying by %d second(s)",
  2384. (int)(MAX_SIGNEWNYM_RATE+time_of_last_signewnym-now));
  2385. } else {
  2386. signewnym_impl(now);
  2387. }
  2388. break;
  2389. }
  2390. case SIGCLEARDNSCACHE:
  2391. addressmap_clear_transient();
  2392. control_event_signal(sig);
  2393. break;
  2394. case SIGHEARTBEAT:
  2395. log_heartbeat(time(NULL));
  2396. control_event_signal(sig);
  2397. break;
  2398. }
  2399. }
  2400. /** Returns Tor's uptime. */
  2401. MOCK_IMPL(long,
  2402. get_uptime,(void))
  2403. {
  2404. return stats_n_seconds_working;
  2405. }
  2406. extern uint64_t rephist_total_alloc;
  2407. extern uint32_t rephist_total_num;
  2408. /**
  2409. * Write current memory usage information to the log.
  2410. */
  2411. static void
  2412. dumpmemusage(int severity)
  2413. {
  2414. connection_dump_buffer_mem_stats(severity);
  2415. tor_log(severity, LD_GENERAL, "In rephist: "U64_FORMAT" used by %d Tors.",
  2416. U64_PRINTF_ARG(rephist_total_alloc), rephist_total_num);
  2417. dump_routerlist_mem_usage(severity);
  2418. dump_cell_pool_usage(severity);
  2419. dump_dns_mem_usage(severity);
  2420. tor_log_mallinfo(severity);
  2421. }
  2422. /** Write all statistics to the log, with log level <b>severity</b>. Called
  2423. * in response to a SIGUSR1. */
  2424. static void
  2425. dumpstats(int severity)
  2426. {
  2427. time_t now = time(NULL);
  2428. time_t elapsed;
  2429. size_t rbuf_cap, wbuf_cap, rbuf_len, wbuf_len;
  2430. tor_log(severity, LD_GENERAL, "Dumping stats:");
  2431. SMARTLIST_FOREACH_BEGIN(connection_array, connection_t *, conn) {
  2432. int i = conn_sl_idx;
  2433. tor_log(severity, LD_GENERAL,
  2434. "Conn %d (socket %d) type %d (%s), state %d (%s), created %d secs ago",
  2435. i, (int)conn->s, conn->type, conn_type_to_string(conn->type),
  2436. conn->state, conn_state_to_string(conn->type, conn->state),
  2437. (int)(now - conn->timestamp_created));
  2438. if (!connection_is_listener(conn)) {
  2439. tor_log(severity,LD_GENERAL,
  2440. "Conn %d is to %s:%d.", i,
  2441. safe_str_client(conn->address),
  2442. conn->port);
  2443. tor_log(severity,LD_GENERAL,
  2444. "Conn %d: %d bytes waiting on inbuf (len %d, last read %d secs ago)",
  2445. i,
  2446. (int)connection_get_inbuf_len(conn),
  2447. (int)buf_allocation(conn->inbuf),
  2448. (int)(now - conn->timestamp_lastread));
  2449. tor_log(severity,LD_GENERAL,
  2450. "Conn %d: %d bytes waiting on outbuf "
  2451. "(len %d, last written %d secs ago)",i,
  2452. (int)connection_get_outbuf_len(conn),
  2453. (int)buf_allocation(conn->outbuf),
  2454. (int)(now - conn->timestamp_lastwritten));
  2455. if (conn->type == CONN_TYPE_OR) {
  2456. or_connection_t *or_conn = TO_OR_CONN(conn);
  2457. if (or_conn->tls) {
  2458. if (tor_tls_get_buffer_sizes(or_conn->tls, &rbuf_cap, &rbuf_len,
  2459. &wbuf_cap, &wbuf_len) == 0) {
  2460. tor_log(severity, LD_GENERAL,
  2461. "Conn %d: %d/%d bytes used on OpenSSL read buffer; "
  2462. "%d/%d bytes used on write buffer.",
  2463. i, (int)rbuf_len, (int)rbuf_cap, (int)wbuf_len, (int)wbuf_cap);
  2464. }
  2465. }
  2466. }
  2467. }
  2468. circuit_dump_by_conn(conn, severity); /* dump info about all the circuits
  2469. * using this conn */
  2470. } SMARTLIST_FOREACH_END(conn);
  2471. channel_dumpstats(severity);
  2472. channel_listener_dumpstats(severity);
  2473. tor_log(severity, LD_NET,
  2474. "Cells processed: "U64_FORMAT" padding\n"
  2475. " "U64_FORMAT" create\n"
  2476. " "U64_FORMAT" created\n"
  2477. " "U64_FORMAT" relay\n"
  2478. " ("U64_FORMAT" relayed)\n"
  2479. " ("U64_FORMAT" delivered)\n"
  2480. " "U64_FORMAT" destroy",
  2481. U64_PRINTF_ARG(stats_n_padding_cells_processed),
  2482. U64_PRINTF_ARG(stats_n_create_cells_processed),
  2483. U64_PRINTF_ARG(stats_n_created_cells_processed),
  2484. U64_PRINTF_ARG(stats_n_relay_cells_processed),
  2485. U64_PRINTF_ARG(stats_n_relay_cells_relayed),
  2486. U64_PRINTF_ARG(stats_n_relay_cells_delivered),
  2487. U64_PRINTF_ARG(stats_n_destroy_cells_processed));
  2488. if (stats_n_data_cells_packaged)
  2489. tor_log(severity,LD_NET,"Average packaged cell fullness: %2.3f%%",
  2490. 100*(U64_TO_DBL(stats_n_data_bytes_packaged) /
  2491. U64_TO_DBL(stats_n_data_cells_packaged*RELAY_PAYLOAD_SIZE)) );
  2492. if (stats_n_data_cells_received)
  2493. tor_log(severity,LD_NET,"Average delivered cell fullness: %2.3f%%",
  2494. 100*(U64_TO_DBL(stats_n_data_bytes_received) /
  2495. U64_TO_DBL(stats_n_data_cells_received*RELAY_PAYLOAD_SIZE)) );
  2496. cpuworker_log_onionskin_overhead(severity, ONION_HANDSHAKE_TYPE_TAP, "TAP");
  2497. cpuworker_log_onionskin_overhead(severity, ONION_HANDSHAKE_TYPE_NTOR,"ntor");
  2498. if (now - time_of_process_start >= 0)
  2499. elapsed = now - time_of_process_start;
  2500. else
  2501. elapsed = 0;
  2502. if (elapsed) {
  2503. tor_log(severity, LD_NET,
  2504. "Average bandwidth: "U64_FORMAT"/%d = %d bytes/sec reading",
  2505. U64_PRINTF_ARG(stats_n_bytes_read),
  2506. (int)elapsed,
  2507. (int) (stats_n_bytes_read/elapsed));
  2508. tor_log(severity, LD_NET,
  2509. "Average bandwidth: "U64_FORMAT"/%d = %d bytes/sec writing",
  2510. U64_PRINTF_ARG(stats_n_bytes_written),
  2511. (int)elapsed,
  2512. (int) (stats_n_bytes_written/elapsed));
  2513. }
  2514. tor_log(severity, LD_NET, "--------------- Dumping memory information:");
  2515. dumpmemusage(severity);
  2516. rep_hist_dump_stats(now,severity);
  2517. rend_service_dump_stats(severity);
  2518. dump_pk_ops(severity);
  2519. dump_distinct_digest_count(severity);
  2520. }
  2521. /** Called by exit() as we shut down the process.
  2522. */
  2523. static void
  2524. exit_function(void)
  2525. {
  2526. /* NOTE: If we ever daemonize, this gets called immediately. That's
  2527. * okay for now, because we only use this on Windows. */
  2528. #ifdef _WIN32
  2529. WSACleanup();
  2530. #endif
  2531. }
  2532. #ifdef _WIN32
  2533. #define UNIX_ONLY 0
  2534. #else
  2535. #define UNIX_ONLY 1
  2536. #endif
  2537. static struct {
  2538. int signal_value;
  2539. int try_to_register;
  2540. struct event *signal_event;
  2541. } signal_handlers[] = {
  2542. #ifdef SIGINT
  2543. { SIGINT, UNIX_ONLY, NULL }, /* do a controlled slow shutdown */
  2544. #endif
  2545. #ifdef SIGTERM
  2546. { SIGTERM, UNIX_ONLY, NULL }, /* to terminate now */
  2547. #endif
  2548. #ifdef SIGPIPE
  2549. { SIGPIPE, UNIX_ONLY, NULL }, /* otherwise SIGPIPE kills us */
  2550. #endif
  2551. #ifdef SIGUSR1
  2552. { SIGUSR1, UNIX_ONLY, NULL }, /* dump stats */
  2553. #endif
  2554. #ifdef SIGUSR2
  2555. { SIGUSR2, UNIX_ONLY, NULL }, /* go to loglevel debug */
  2556. #endif
  2557. #ifdef SIGHUP
  2558. { SIGHUP, UNIX_ONLY, NULL }, /* to reload config, retry conns, etc */
  2559. #endif
  2560. #ifdef SIGXFSZ
  2561. { SIGXFSZ, UNIX_ONLY, NULL }, /* handle file-too-big resource exhaustion */
  2562. #endif
  2563. #ifdef SIGCHLD
  2564. { SIGCHLD, UNIX_ONLY, NULL }, /* handle dns/cpu workers that exit */
  2565. #endif
  2566. /* These are controller-only */
  2567. { SIGNEWNYM, 0, NULL },
  2568. { SIGCLEARDNSCACHE, 0, NULL },
  2569. { SIGHEARTBEAT, 0, NULL },
  2570. { -1, -1, NULL }
  2571. };
  2572. /** Set up the signal handlers for either parent or child process */
  2573. void
  2574. handle_signals(int is_parent)
  2575. {
  2576. int i;
  2577. if (is_parent) {
  2578. for (i = 0; signal_handlers[i].signal_value >= 0; ++i) {
  2579. if (signal_handlers[i].try_to_register) {
  2580. signal_handlers[i].signal_event =
  2581. tor_evsignal_new(tor_libevent_get_base(),
  2582. signal_handlers[i].signal_value,
  2583. signal_callback,
  2584. &signal_handlers[i].signal_value);
  2585. if (event_add(signal_handlers[i].signal_event, NULL))
  2586. log_warn(LD_BUG, "Error from libevent when adding "
  2587. "event for signal %d",
  2588. signal_handlers[i].signal_value);
  2589. } else {
  2590. signal_handlers[i].signal_event =
  2591. tor_event_new(tor_libevent_get_base(), -1,
  2592. EV_SIGNAL, signal_callback,
  2593. &signal_handlers[i].signal_value);
  2594. }
  2595. }
  2596. } else {
  2597. #ifndef _WIN32
  2598. struct sigaction action;
  2599. action.sa_flags = 0;
  2600. sigemptyset(&action.sa_mask);
  2601. action.sa_handler = SIG_IGN;
  2602. sigaction(SIGINT, &action, NULL);
  2603. sigaction(SIGTERM, &action, NULL);
  2604. sigaction(SIGPIPE, &action, NULL);
  2605. sigaction(SIGUSR1, &action, NULL);
  2606. sigaction(SIGUSR2, &action, NULL);
  2607. sigaction(SIGHUP, &action, NULL);
  2608. #ifdef SIGXFSZ
  2609. sigaction(SIGXFSZ, &action, NULL);
  2610. #endif
  2611. #endif
  2612. }
  2613. }
  2614. /* Make sure the signal handler for signal_num will be called. */
  2615. void
  2616. activate_signal(int signal_num)
  2617. {
  2618. int i;
  2619. for (i = 0; signal_handlers[i].signal_value >= 0; ++i) {
  2620. if (signal_handlers[i].signal_value == signal_num) {
  2621. event_active(signal_handlers[i].signal_event, EV_SIGNAL, 1);
  2622. return;
  2623. }
  2624. }
  2625. }
  2626. /** Main entry point for the Tor command-line client.
  2627. */
  2628. int
  2629. tor_init(int argc, char *argv[])
  2630. {
  2631. char progname[256];
  2632. int quiet = 0;
  2633. time_of_process_start = time(NULL);
  2634. init_connection_lists();
  2635. /* Have the log set up with our application name. */
  2636. tor_snprintf(progname, sizeof(progname), "Tor %s", get_version());
  2637. log_set_application_name(progname);
  2638. /* Set up the crypto nice and early */
  2639. if (crypto_early_init() < 0) {
  2640. log_err(LD_GENERAL, "Unable to initialize the crypto subsystem!");
  2641. return -1;
  2642. }
  2643. /* Initialize the history structures. */
  2644. rep_hist_init();
  2645. /* Initialize the service cache. */
  2646. rend_cache_init();
  2647. addressmap_init(); /* Init the client dns cache. Do it always, since it's
  2648. * cheap. */
  2649. {
  2650. /* We search for the "quiet" option first, since it decides whether we
  2651. * will log anything at all to the command line. */
  2652. config_line_t *opts = NULL, *cmdline_opts = NULL;
  2653. const config_line_t *cl;
  2654. (void) config_parse_commandline(argc, argv, 1, &opts, &cmdline_opts);
  2655. for (cl = cmdline_opts; cl; cl = cl->next) {
  2656. if (!strcmp(cl->key, "--hush"))
  2657. quiet = 1;
  2658. if (!strcmp(cl->key, "--quiet") ||
  2659. !strcmp(cl->key, "--dump-config"))
  2660. quiet = 2;
  2661. /* The following options imply --hush */
  2662. if (!strcmp(cl->key, "--version") || !strcmp(cl->key, "--digests") ||
  2663. !strcmp(cl->key, "--list-torrc-options") ||
  2664. !strcmp(cl->key, "--library-versions") ||
  2665. !strcmp(cl->key, "--hash-password") ||
  2666. !strcmp(cl->key, "-h") || !strcmp(cl->key, "--help")) {
  2667. if (quiet < 1)
  2668. quiet = 1;
  2669. }
  2670. }
  2671. config_free_lines(opts);
  2672. config_free_lines(cmdline_opts);
  2673. }
  2674. /* give it somewhere to log to initially */
  2675. switch (quiet) {
  2676. case 2:
  2677. /* no initial logging */
  2678. break;
  2679. case 1:
  2680. add_temp_log(LOG_WARN);
  2681. break;
  2682. default:
  2683. add_temp_log(LOG_NOTICE);
  2684. }
  2685. quiet_level = quiet;
  2686. {
  2687. const char *version = get_version();
  2688. const char *bev_str =
  2689. #ifdef USE_BUFFEREVENTS
  2690. "(with bufferevents) ";
  2691. #else
  2692. "";
  2693. #endif
  2694. log_notice(LD_GENERAL, "Tor v%s %srunning on %s with Libevent %s, "
  2695. "OpenSSL %s and Zlib %s.", version, bev_str,
  2696. get_uname(),
  2697. tor_libevent_get_version_str(),
  2698. crypto_openssl_get_version_str(),
  2699. tor_zlib_get_version_str());
  2700. log_notice(LD_GENERAL, "Tor can't help you if you use it wrong! "
  2701. "Learn how to be safe at "
  2702. "https://www.torproject.org/download/download#warning");
  2703. if (strstr(version, "alpha") || strstr(version, "beta"))
  2704. log_notice(LD_GENERAL, "This version is not a stable Tor release. "
  2705. "Expect more bugs than usual.");
  2706. }
  2707. #ifdef NON_ANONYMOUS_MODE_ENABLED
  2708. log_warn(LD_GENERAL, "This copy of Tor was compiled to run in a "
  2709. "non-anonymous mode. It will provide NO ANONYMITY.");
  2710. #endif
  2711. if (network_init()<0) {
  2712. log_err(LD_BUG,"Error initializing network; exiting.");
  2713. return -1;
  2714. }
  2715. atexit(exit_function);
  2716. if (options_init_from_torrc(argc,argv) < 0) {
  2717. log_err(LD_CONFIG,"Reading config failed--see warnings above.");
  2718. return -1;
  2719. }
  2720. #ifndef _WIN32
  2721. if (geteuid()==0)
  2722. log_warn(LD_GENERAL,"You are running Tor as root. You don't need to, "
  2723. "and you probably shouldn't.");
  2724. #endif
  2725. if (crypto_global_init(get_options()->HardwareAccel,
  2726. get_options()->AccelName,
  2727. get_options()->AccelDir)) {
  2728. log_err(LD_BUG, "Unable to initialize OpenSSL. Exiting.");
  2729. return -1;
  2730. }
  2731. stream_choice_seed_weak_rng();
  2732. if (tor_init_libevent_rng() < 0) {
  2733. log_warn(LD_NET, "Problem initializing libevent RNG.");
  2734. }
  2735. return 0;
  2736. }
  2737. /** A lockfile structure, used to prevent two Tors from messing with the
  2738. * data directory at once. If this variable is non-NULL, we're holding
  2739. * the lockfile. */
  2740. static tor_lockfile_t *lockfile = NULL;
  2741. /** Try to grab the lock file described in <b>options</b>, if we do not
  2742. * already have it. If <b>err_if_locked</b> is true, warn if somebody else is
  2743. * holding the lock, and exit if we can't get it after waiting. Otherwise,
  2744. * return -1 if we can't get the lockfile. Return 0 on success.
  2745. */
  2746. int
  2747. try_locking(const or_options_t *options, int err_if_locked)
  2748. {
  2749. if (lockfile)
  2750. return 0;
  2751. else {
  2752. char *fname = options_get_datadir_fname2_suffix(options, "lock",NULL,NULL);
  2753. int already_locked = 0;
  2754. tor_lockfile_t *lf = tor_lockfile_lock(fname, 0, &already_locked);
  2755. tor_free(fname);
  2756. if (!lf) {
  2757. if (err_if_locked && already_locked) {
  2758. int r;
  2759. log_warn(LD_GENERAL, "It looks like another Tor process is running "
  2760. "with the same data directory. Waiting 5 seconds to see "
  2761. "if it goes away.");
  2762. #ifndef _WIN32
  2763. sleep(5);
  2764. #else
  2765. Sleep(5000);
  2766. #endif
  2767. r = try_locking(options, 0);
  2768. if (r<0) {
  2769. log_err(LD_GENERAL, "No, it's still there. Exiting.");
  2770. exit(0);
  2771. }
  2772. return r;
  2773. }
  2774. return -1;
  2775. }
  2776. lockfile = lf;
  2777. return 0;
  2778. }
  2779. }
  2780. /** Return true iff we've successfully acquired the lock file. */
  2781. int
  2782. have_lockfile(void)
  2783. {
  2784. return lockfile != NULL;
  2785. }
  2786. /** If we have successfully acquired the lock file, release it. */
  2787. void
  2788. release_lockfile(void)
  2789. {
  2790. if (lockfile) {
  2791. tor_lockfile_unlock(lockfile);
  2792. lockfile = NULL;
  2793. }
  2794. }
  2795. /** Free all memory that we might have allocated somewhere.
  2796. * If <b>postfork</b>, we are a worker process and we want to free
  2797. * only the parts of memory that we won't touch. If !<b>postfork</b>,
  2798. * Tor is shutting down and we should free everything.
  2799. *
  2800. * Helps us find the real leaks with dmalloc and the like. Also valgrind
  2801. * should then report 0 reachable in its leak report (in an ideal world --
  2802. * in practice libevent, SSL, libc etc never quite free everything). */
  2803. void
  2804. tor_free_all(int postfork)
  2805. {
  2806. if (!postfork) {
  2807. evdns_shutdown(1);
  2808. }
  2809. geoip_free_all();
  2810. dirvote_free_all();
  2811. routerlist_free_all();
  2812. networkstatus_free_all();
  2813. addressmap_free_all();
  2814. dirserv_free_all();
  2815. rend_service_free_all();
  2816. rend_cache_free_all();
  2817. rend_service_authorization_free_all();
  2818. rep_hist_free_all();
  2819. dns_free_all();
  2820. clear_pending_onions();
  2821. circuit_free_all();
  2822. entry_guards_free_all();
  2823. pt_free_all();
  2824. channel_tls_free_all();
  2825. channel_free_all();
  2826. connection_free_all();
  2827. connection_edge_free_all();
  2828. scheduler_free_all();
  2829. nodelist_free_all();
  2830. microdesc_free_all();
  2831. ext_orport_free_all();
  2832. control_free_all();
  2833. sandbox_free_getaddrinfo_cache();
  2834. if (!postfork) {
  2835. config_free_all();
  2836. or_state_free_all();
  2837. router_free_all();
  2838. routerkeys_free_all();
  2839. policies_free_all();
  2840. }
  2841. if (!postfork) {
  2842. tor_tls_free_all();
  2843. #ifndef _WIN32
  2844. tor_getpwnam(NULL);
  2845. #endif
  2846. }
  2847. /* stuff in main.c */
  2848. smartlist_free(connection_array);
  2849. smartlist_free(closeable_connection_lst);
  2850. smartlist_free(active_linked_connection_lst);
  2851. periodic_timer_free(second_timer);
  2852. teardown_periodic_events();
  2853. #ifndef USE_BUFFEREVENTS
  2854. periodic_timer_free(refill_timer);
  2855. #endif
  2856. if (!postfork) {
  2857. release_lockfile();
  2858. }
  2859. /* Stuff in util.c and address.c*/
  2860. if (!postfork) {
  2861. escaped(NULL);
  2862. esc_router_info(NULL);
  2863. logs_free_all(); /* free log strings. do this last so logs keep working. */
  2864. }
  2865. }
  2866. /** Do whatever cleanup is necessary before shutting Tor down. */
  2867. void
  2868. tor_cleanup(void)
  2869. {
  2870. const or_options_t *options = get_options();
  2871. if (options->command == CMD_RUN_TOR) {
  2872. time_t now = time(NULL);
  2873. /* Remove our pid file. We don't care if there was an error when we
  2874. * unlink, nothing we could do about it anyways. */
  2875. if (options->PidFile) {
  2876. if (unlink(options->PidFile) != 0) {
  2877. log_warn(LD_FS, "Couldn't unlink pid file %s: %s",
  2878. options->PidFile, strerror(errno));
  2879. }
  2880. }
  2881. if (options->ControlPortWriteToFile) {
  2882. if (unlink(options->ControlPortWriteToFile) != 0) {
  2883. log_warn(LD_FS, "Couldn't unlink control port file %s: %s",
  2884. options->ControlPortWriteToFile,
  2885. strerror(errno));
  2886. }
  2887. }
  2888. if (accounting_is_enabled(options))
  2889. accounting_record_bandwidth_usage(now, get_or_state());
  2890. or_state_mark_dirty(get_or_state(), 0); /* force an immediate save. */
  2891. or_state_save(now);
  2892. if (authdir_mode_tests_reachability(options))
  2893. rep_hist_record_mtbf_data(now, 0);
  2894. keypin_close_journal();
  2895. }
  2896. #ifdef USE_DMALLOC
  2897. dmalloc_log_stats();
  2898. #endif
  2899. tor_free_all(0); /* We could move tor_free_all back into the ifdef below
  2900. later, if it makes shutdown unacceptably slow. But for
  2901. now, leave it here: it's helped us catch bugs in the
  2902. past. */
  2903. crypto_global_cleanup();
  2904. #ifdef USE_DMALLOC
  2905. dmalloc_log_unfreed();
  2906. dmalloc_shutdown();
  2907. #endif
  2908. }
  2909. /** Read/create keys as needed, and echo our fingerprint to stdout. */
  2910. static int
  2911. do_list_fingerprint(void)
  2912. {
  2913. char buf[FINGERPRINT_LEN+1];
  2914. crypto_pk_t *k;
  2915. const char *nickname = get_options()->Nickname;
  2916. sandbox_disable_getaddrinfo_cache();
  2917. if (!server_mode(get_options())) {
  2918. log_err(LD_GENERAL,
  2919. "Clients don't have long-term identity keys. Exiting.");
  2920. return -1;
  2921. }
  2922. tor_assert(nickname);
  2923. if (init_keys() < 0) {
  2924. log_err(LD_GENERAL,"Error initializing keys; exiting.");
  2925. return -1;
  2926. }
  2927. if (!(k = get_server_identity_key())) {
  2928. log_err(LD_GENERAL,"Error: missing identity key.");
  2929. return -1;
  2930. }
  2931. if (crypto_pk_get_fingerprint(k, buf, 1)<0) {
  2932. log_err(LD_BUG, "Error computing fingerprint");
  2933. return -1;
  2934. }
  2935. printf("%s %s\n", nickname, buf);
  2936. return 0;
  2937. }
  2938. /** Entry point for password hashing: take the desired password from
  2939. * the command line, and print its salted hash to stdout. **/
  2940. static void
  2941. do_hash_password(void)
  2942. {
  2943. char output[256];
  2944. char key[S2K_RFC2440_SPECIFIER_LEN+DIGEST_LEN];
  2945. crypto_rand(key, S2K_RFC2440_SPECIFIER_LEN-1);
  2946. key[S2K_RFC2440_SPECIFIER_LEN-1] = (uint8_t)96; /* Hash 64 K of data. */
  2947. secret_to_key_rfc2440(key+S2K_RFC2440_SPECIFIER_LEN, DIGEST_LEN,
  2948. get_options()->command_arg, strlen(get_options()->command_arg),
  2949. key);
  2950. base16_encode(output, sizeof(output), key, sizeof(key));
  2951. printf("16:%s\n",output);
  2952. }
  2953. /** Entry point for configuration dumping: write the configuration to
  2954. * stdout. */
  2955. static int
  2956. do_dump_config(void)
  2957. {
  2958. const or_options_t *options = get_options();
  2959. const char *arg = options->command_arg;
  2960. int how;
  2961. char *opts;
  2962. if (!strcmp(arg, "short")) {
  2963. how = OPTIONS_DUMP_MINIMAL;
  2964. } else if (!strcmp(arg, "non-builtin")) {
  2965. how = OPTIONS_DUMP_DEFAULTS;
  2966. } else if (!strcmp(arg, "full")) {
  2967. how = OPTIONS_DUMP_ALL;
  2968. } else {
  2969. fprintf(stderr, "No valid argument to --dump-config found!\n");
  2970. fprintf(stderr, "Please select 'short', 'non-builtin', or 'full'.\n");
  2971. return -1;
  2972. }
  2973. opts = options_dump(options, how);
  2974. printf("%s", opts);
  2975. tor_free(opts);
  2976. return 0;
  2977. }
  2978. static void
  2979. init_addrinfo(void)
  2980. {
  2981. if (! server_mode(get_options()) ||
  2982. (get_options()->Address && strlen(get_options()->Address) > 0)) {
  2983. /* We don't need to seed our own hostname, because we won't be calling
  2984. * resolve_my_address on it.
  2985. */
  2986. return;
  2987. }
  2988. char hname[256];
  2989. // host name to sandbox
  2990. gethostname(hname, sizeof(hname));
  2991. sandbox_add_addrinfo(hname);
  2992. }
  2993. static sandbox_cfg_t*
  2994. sandbox_init_filter(void)
  2995. {
  2996. const or_options_t *options = get_options();
  2997. sandbox_cfg_t *cfg = sandbox_cfg_new();
  2998. int i;
  2999. sandbox_cfg_allow_openat_filename(&cfg,
  3000. get_datadir_fname("cached-status"));
  3001. #define OPEN(name) \
  3002. sandbox_cfg_allow_open_filename(&cfg, tor_strdup(name))
  3003. #define OPEN_DATADIR(name) \
  3004. sandbox_cfg_allow_open_filename(&cfg, get_datadir_fname(name))
  3005. #define OPEN_DATADIR2(name, name2) \
  3006. sandbox_cfg_allow_open_filename(&cfg, get_datadir_fname2((name), (name2)))
  3007. #define OPEN_DATADIR_SUFFIX(name, suffix) do { \
  3008. OPEN_DATADIR(name); \
  3009. OPEN_DATADIR(name suffix); \
  3010. } while (0)
  3011. #define OPEN_DATADIR2_SUFFIX(name, name2, suffix) do { \
  3012. OPEN_DATADIR2(name, name2); \
  3013. OPEN_DATADIR2(name, name2 suffix); \
  3014. } while (0)
  3015. OPEN(options->DataDirectory);
  3016. OPEN_DATADIR("keys");
  3017. OPEN_DATADIR_SUFFIX("cached-certs", ".tmp");
  3018. OPEN_DATADIR_SUFFIX("cached-consensus", ".tmp");
  3019. OPEN_DATADIR_SUFFIX("unverified-consensus", ".tmp");
  3020. OPEN_DATADIR_SUFFIX("unverified-microdesc-consensus", ".tmp");
  3021. OPEN_DATADIR_SUFFIX("cached-microdesc-consensus", ".tmp");
  3022. OPEN_DATADIR_SUFFIX("cached-microdescs", ".tmp");
  3023. OPEN_DATADIR_SUFFIX("cached-microdescs.new", ".tmp");
  3024. OPEN_DATADIR_SUFFIX("cached-descriptors", ".tmp");
  3025. OPEN_DATADIR_SUFFIX("cached-descriptors.new", ".tmp");
  3026. OPEN_DATADIR("cached-descriptors.tmp.tmp");
  3027. OPEN_DATADIR_SUFFIX("cached-extrainfo", ".tmp");
  3028. OPEN_DATADIR_SUFFIX("cached-extrainfo.new", ".tmp");
  3029. OPEN_DATADIR("cached-extrainfo.tmp.tmp");
  3030. OPEN_DATADIR_SUFFIX("state", ".tmp");
  3031. OPEN_DATADIR_SUFFIX("unparseable-desc", ".tmp");
  3032. OPEN_DATADIR_SUFFIX("v3-status-votes", ".tmp");
  3033. OPEN_DATADIR("key-pinning-journal");
  3034. OPEN("/dev/srandom");
  3035. OPEN("/dev/urandom");
  3036. OPEN("/dev/random");
  3037. OPEN("/etc/hosts");
  3038. OPEN("/proc/meminfo");
  3039. if (options->BridgeAuthoritativeDir)
  3040. OPEN_DATADIR_SUFFIX("networkstatus-bridges", ".tmp");
  3041. if (authdir_mode_handles_descs(options, -1))
  3042. OPEN_DATADIR("approved-routers");
  3043. if (options->ServerDNSResolvConfFile)
  3044. sandbox_cfg_allow_open_filename(&cfg,
  3045. tor_strdup(options->ServerDNSResolvConfFile));
  3046. else
  3047. sandbox_cfg_allow_open_filename(&cfg, tor_strdup("/etc/resolv.conf"));
  3048. for (i = 0; i < 2; ++i) {
  3049. if (get_torrc_fname(i)) {
  3050. sandbox_cfg_allow_open_filename(&cfg, tor_strdup(get_torrc_fname(i)));
  3051. }
  3052. }
  3053. #define RENAME_SUFFIX(name, suffix) \
  3054. sandbox_cfg_allow_rename(&cfg, \
  3055. get_datadir_fname(name suffix), \
  3056. get_datadir_fname(name))
  3057. #define RENAME_SUFFIX2(prefix, name, suffix) \
  3058. sandbox_cfg_allow_rename(&cfg, \
  3059. get_datadir_fname2(prefix, name suffix), \
  3060. get_datadir_fname2(prefix, name))
  3061. RENAME_SUFFIX("cached-certs", ".tmp");
  3062. RENAME_SUFFIX("cached-consensus", ".tmp");
  3063. RENAME_SUFFIX("unverified-consensus", ".tmp");
  3064. RENAME_SUFFIX("unverified-microdesc-consensus", ".tmp");
  3065. RENAME_SUFFIX("cached-microdesc-consensus", ".tmp");
  3066. RENAME_SUFFIX("cached-microdescs", ".tmp");
  3067. RENAME_SUFFIX("cached-microdescs", ".new");
  3068. RENAME_SUFFIX("cached-microdescs.new", ".tmp");
  3069. RENAME_SUFFIX("cached-descriptors", ".tmp");
  3070. RENAME_SUFFIX("cached-descriptors", ".new");
  3071. RENAME_SUFFIX("cached-descriptors.new", ".tmp");
  3072. RENAME_SUFFIX("cached-extrainfo", ".tmp");
  3073. RENAME_SUFFIX("cached-extrainfo", ".new");
  3074. RENAME_SUFFIX("cached-extrainfo.new", ".tmp");
  3075. RENAME_SUFFIX("state", ".tmp");
  3076. RENAME_SUFFIX("unparseable-desc", ".tmp");
  3077. RENAME_SUFFIX("v3-status-votes", ".tmp");
  3078. if (options->BridgeAuthoritativeDir)
  3079. RENAME_SUFFIX("networkstatus-bridges", ".tmp");
  3080. #define STAT_DATADIR(name) \
  3081. sandbox_cfg_allow_stat_filename(&cfg, get_datadir_fname(name))
  3082. #define STAT_DATADIR2(name, name2) \
  3083. sandbox_cfg_allow_stat_filename(&cfg, get_datadir_fname2((name), (name2)))
  3084. STAT_DATADIR(NULL);
  3085. STAT_DATADIR("lock");
  3086. STAT_DATADIR("state");
  3087. STAT_DATADIR("router-stability");
  3088. STAT_DATADIR("cached-extrainfo.new");
  3089. {
  3090. smartlist_t *files = smartlist_new();
  3091. tor_log_get_logfile_names(files);
  3092. SMARTLIST_FOREACH(files, char *, file_name, {
  3093. /* steals reference */
  3094. sandbox_cfg_allow_open_filename(&cfg, file_name);
  3095. });
  3096. smartlist_free(files);
  3097. }
  3098. {
  3099. smartlist_t *files = smartlist_new();
  3100. smartlist_t *dirs = smartlist_new();
  3101. rend_services_add_filenames_to_lists(files, dirs);
  3102. SMARTLIST_FOREACH(files, char *, file_name, {
  3103. char *tmp_name = NULL;
  3104. tor_asprintf(&tmp_name, "%s.tmp", file_name);
  3105. sandbox_cfg_allow_rename(&cfg,
  3106. tor_strdup(tmp_name), tor_strdup(file_name));
  3107. /* steals references */
  3108. sandbox_cfg_allow_open_filename(&cfg, file_name);
  3109. sandbox_cfg_allow_open_filename(&cfg, tmp_name);
  3110. });
  3111. SMARTLIST_FOREACH(dirs, char *, dir, {
  3112. /* steals reference */
  3113. sandbox_cfg_allow_stat_filename(&cfg, dir);
  3114. });
  3115. smartlist_free(files);
  3116. smartlist_free(dirs);
  3117. }
  3118. {
  3119. char *fname;
  3120. if ((fname = get_controller_cookie_file_name())) {
  3121. sandbox_cfg_allow_open_filename(&cfg, fname);
  3122. }
  3123. if ((fname = get_ext_or_auth_cookie_file_name())) {
  3124. sandbox_cfg_allow_open_filename(&cfg, fname);
  3125. }
  3126. }
  3127. SMARTLIST_FOREACH_BEGIN(get_configured_ports(), port_cfg_t *, port) {
  3128. if (!port->is_unix_addr)
  3129. continue;
  3130. /* When we open an AF_UNIX address, we want permission to open the
  3131. * directory that holds it. */
  3132. char *dirname = tor_strdup(port->unix_addr);
  3133. if (get_parent_directory(dirname) == 0) {
  3134. OPEN(dirname);
  3135. }
  3136. tor_free(dirname);
  3137. sandbox_cfg_allow_chmod_filename(&cfg, tor_strdup(port->unix_addr));
  3138. sandbox_cfg_allow_chown_filename(&cfg, tor_strdup(port->unix_addr));
  3139. } SMARTLIST_FOREACH_END(port);
  3140. if (options->DirPortFrontPage) {
  3141. sandbox_cfg_allow_open_filename(&cfg,
  3142. tor_strdup(options->DirPortFrontPage));
  3143. }
  3144. // orport
  3145. if (server_mode(get_options())) {
  3146. OPEN_DATADIR2_SUFFIX("keys", "secret_id_key", ".tmp");
  3147. OPEN_DATADIR2_SUFFIX("keys", "secret_onion_key", ".tmp");
  3148. OPEN_DATADIR2_SUFFIX("keys", "secret_onion_key_ntor", ".tmp");
  3149. OPEN_DATADIR2("keys", "secret_id_key.old");
  3150. OPEN_DATADIR2("keys", "secret_onion_key.old");
  3151. OPEN_DATADIR2("keys", "secret_onion_key_ntor.old");
  3152. OPEN_DATADIR2_SUFFIX("keys", "ed25519_master_id_secret_key", ".tmp");
  3153. OPEN_DATADIR2_SUFFIX("keys", "ed25519_master_id_secret_key_encrypted",
  3154. ".tmp");
  3155. OPEN_DATADIR2_SUFFIX("keys", "ed25519_master_id_public_key", ".tmp");
  3156. OPEN_DATADIR2_SUFFIX("keys", "ed25519_signing_secret_key", ".tmp");
  3157. OPEN_DATADIR2_SUFFIX("keys", "ed25519_signing_secret_key_encrypted",
  3158. ".tmp");
  3159. OPEN_DATADIR2_SUFFIX("keys", "ed25519_signing_public_key", ".tmp");
  3160. OPEN_DATADIR2_SUFFIX("keys", "ed25519_signing_cert", ".tmp");
  3161. OPEN_DATADIR2_SUFFIX("stats", "bridge-stats", ".tmp");
  3162. OPEN_DATADIR2_SUFFIX("stats", "dirreq-stats", ".tmp");
  3163. OPEN_DATADIR2_SUFFIX("stats", "entry-stats", ".tmp");
  3164. OPEN_DATADIR2_SUFFIX("stats", "exit-stats", ".tmp");
  3165. OPEN_DATADIR2_SUFFIX("stats", "buffer-stats", ".tmp");
  3166. OPEN_DATADIR2_SUFFIX("stats", "conn-stats", ".tmp");
  3167. OPEN_DATADIR2_SUFFIX("stats", "hidserv-stats", ".tmp");
  3168. OPEN_DATADIR("approved-routers");
  3169. OPEN_DATADIR_SUFFIX("fingerprint", ".tmp");
  3170. OPEN_DATADIR_SUFFIX("hashed-fingerprint", ".tmp");
  3171. OPEN_DATADIR_SUFFIX("router-stability", ".tmp");
  3172. OPEN("/etc/resolv.conf");
  3173. RENAME_SUFFIX("fingerprint", ".tmp");
  3174. RENAME_SUFFIX2("keys", "secret_onion_key_ntor", ".tmp");
  3175. RENAME_SUFFIX2("keys", "secret_id_key", ".tmp");
  3176. RENAME_SUFFIX2("keys", "secret_id_key.old", ".tmp");
  3177. RENAME_SUFFIX2("keys", "secret_onion_key", ".tmp");
  3178. RENAME_SUFFIX2("keys", "secret_onion_key.old", ".tmp");
  3179. RENAME_SUFFIX2("stats", "bridge-stats", ".tmp");
  3180. RENAME_SUFFIX2("stats", "dirreq-stats", ".tmp");
  3181. RENAME_SUFFIX2("stats", "entry-stats", ".tmp");
  3182. RENAME_SUFFIX2("stats", "exit-stats", ".tmp");
  3183. RENAME_SUFFIX2("stats", "buffer-stats", ".tmp");
  3184. RENAME_SUFFIX2("stats", "conn-stats", ".tmp");
  3185. RENAME_SUFFIX2("stats", "hidserv-stats", ".tmp");
  3186. RENAME_SUFFIX("hashed-fingerprint", ".tmp");
  3187. RENAME_SUFFIX("router-stability", ".tmp");
  3188. RENAME_SUFFIX2("keys", "ed25519_master_id_secret_key", ".tmp");
  3189. RENAME_SUFFIX2("keys", "ed25519_master_id_secret_key_encrypted", ".tmp");
  3190. RENAME_SUFFIX2("keys", "ed25519_master_id_public_key", ".tmp");
  3191. RENAME_SUFFIX2("keys", "ed25519_signing_secret_key", ".tmp");
  3192. RENAME_SUFFIX2("keys", "ed25519_signing_cert", ".tmp");
  3193. sandbox_cfg_allow_rename(&cfg,
  3194. get_datadir_fname2("keys", "secret_onion_key"),
  3195. get_datadir_fname2("keys", "secret_onion_key.old"));
  3196. sandbox_cfg_allow_rename(&cfg,
  3197. get_datadir_fname2("keys", "secret_onion_key_ntor"),
  3198. get_datadir_fname2("keys", "secret_onion_key_ntor.old"));
  3199. STAT_DATADIR("keys");
  3200. OPEN_DATADIR("stats");
  3201. STAT_DATADIR("stats");
  3202. STAT_DATADIR2("stats", "dirreq-stats");
  3203. }
  3204. init_addrinfo();
  3205. return cfg;
  3206. }
  3207. /** Main entry point for the Tor process. Called from main(). */
  3208. /* This function is distinct from main() only so we can link main.c into
  3209. * the unittest binary without conflicting with the unittests' main. */
  3210. int
  3211. tor_main(int argc, char *argv[])
  3212. {
  3213. int result = 0;
  3214. #ifdef _WIN32
  3215. /* Call SetProcessDEPPolicy to permanently enable DEP.
  3216. The function will not resolve on earlier versions of Windows,
  3217. and failure is not dangerous. */
  3218. HMODULE hMod = GetModuleHandleA("Kernel32.dll");
  3219. if (hMod) {
  3220. typedef BOOL (WINAPI *PSETDEP)(DWORD);
  3221. PSETDEP setdeppolicy = (PSETDEP)GetProcAddress(hMod,
  3222. "SetProcessDEPPolicy");
  3223. if (setdeppolicy) setdeppolicy(1); /* PROCESS_DEP_ENABLE */
  3224. }
  3225. #endif
  3226. configure_backtrace_handler(get_version());
  3227. update_approx_time(time(NULL));
  3228. tor_threads_init();
  3229. init_logging(0);
  3230. #ifdef USE_DMALLOC
  3231. {
  3232. /* Instruct OpenSSL to use our internal wrappers for malloc,
  3233. realloc and free. */
  3234. int r = CRYPTO_set_mem_ex_functions(tor_malloc_, tor_realloc_, tor_free_);
  3235. tor_assert(r);
  3236. }
  3237. #endif
  3238. #ifdef NT_SERVICE
  3239. {
  3240. int done = 0;
  3241. result = nt_service_parse_options(argc, argv, &done);
  3242. if (done) return result;
  3243. }
  3244. #endif
  3245. if (tor_init(argc, argv)<0)
  3246. return -1;
  3247. if (get_options()->Sandbox && get_options()->command == CMD_RUN_TOR) {
  3248. sandbox_cfg_t* cfg = sandbox_init_filter();
  3249. if (sandbox_init(cfg)) {
  3250. log_err(LD_BUG,"Failed to create syscall sandbox filter");
  3251. return -1;
  3252. }
  3253. // registering libevent rng
  3254. #ifdef HAVE_EVUTIL_SECURE_RNG_SET_URANDOM_DEVICE_FILE
  3255. evutil_secure_rng_set_urandom_device_file(
  3256. (char*) sandbox_intern_string("/dev/urandom"));
  3257. #endif
  3258. }
  3259. switch (get_options()->command) {
  3260. case CMD_RUN_TOR:
  3261. #ifdef NT_SERVICE
  3262. nt_service_set_state(SERVICE_RUNNING);
  3263. #endif
  3264. result = do_main_loop();
  3265. break;
  3266. case CMD_KEYGEN:
  3267. result = load_ed_keys(get_options(), time(NULL));
  3268. break;
  3269. case CMD_LIST_FINGERPRINT:
  3270. result = do_list_fingerprint();
  3271. break;
  3272. case CMD_HASH_PASSWORD:
  3273. do_hash_password();
  3274. result = 0;
  3275. break;
  3276. case CMD_VERIFY_CONFIG:
  3277. if (quiet_level == 0)
  3278. printf("Configuration was valid\n");
  3279. result = 0;
  3280. break;
  3281. case CMD_DUMP_CONFIG:
  3282. result = do_dump_config();
  3283. break;
  3284. case CMD_RUN_UNITTESTS: /* only set by test.c */
  3285. default:
  3286. log_warn(LD_BUG,"Illegal command number %d: internal error.",
  3287. get_options()->command);
  3288. result = -1;
  3289. }
  3290. tor_cleanup();
  3291. return result;
  3292. }