main.c 125 KB

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