main.c 132 KB

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