main.c 116 KB

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