main.c 93 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840
  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-2013, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  6. /**
  7. * \file main.c
  8. * \brief Toplevel module. Handles signals, multiplexes between
  9. * connections, implements main loop, and drives scheduled events.
  10. **/
  11. #define MAIN_PRIVATE
  12. #include "or.h"
  13. #include "addressmap.h"
  14. #include "buffers.h"
  15. #include "channel.h"
  16. #include "channeltls.h"
  17. #include "circuitbuild.h"
  18. #include "circuitlist.h"
  19. #include "circuituse.h"
  20. #include "command.h"
  21. #include "config.h"
  22. #include "connection.h"
  23. #include "connection_edge.h"
  24. #include "connection_or.h"
  25. #include "control.h"
  26. #include "cpuworker.h"
  27. #include "directory.h"
  28. #include "dirserv.h"
  29. #include "dirvote.h"
  30. #include "dns.h"
  31. #include "dnsserv.h"
  32. #include "entrynodes.h"
  33. #include "geoip.h"
  34. #include "hibernate.h"
  35. #include "main.h"
  36. #include "microdesc.h"
  37. #include "networkstatus.h"
  38. #include "nodelist.h"
  39. #include "ntmain.h"
  40. #include "onion.h"
  41. #include "policies.h"
  42. #include "transports.h"
  43. #include "relay.h"
  44. #include "rendclient.h"
  45. #include "rendcommon.h"
  46. #include "rendservice.h"
  47. #include "rephist.h"
  48. #include "router.h"
  49. #include "routerlist.h"
  50. #include "routerparse.h"
  51. #include "statefile.h"
  52. #include "status.h"
  53. #ifdef USE_DMALLOC
  54. #include <dmalloc.h>
  55. #include <openssl/crypto.h>
  56. #endif
  57. #include "memarea.h"
  58. #include "../common/sandbox.h"
  59. #ifdef HAVE_EVENT2_EVENT_H
  60. #include <event2/event.h>
  61. #else
  62. #include <event.h>
  63. #endif
  64. #ifdef USE_BUFFEREVENTS
  65. #include <event2/bufferevent.h>
  66. #endif
  67. void evdns_shutdown(int);
  68. /********* PROTOTYPES **********/
  69. static void dumpmemusage(int severity);
  70. static void dumpstats(int severity); /* log stats */
  71. static void conn_read_callback(evutil_socket_t fd, short event, void *_conn);
  72. static void conn_write_callback(evutil_socket_t fd, short event, void *_conn);
  73. static void second_elapsed_callback(periodic_timer_t *timer, void *args);
  74. static int conn_close_if_marked(int i);
  75. static void connection_start_reading_from_linked_conn(connection_t *conn);
  76. static int connection_should_read_from_linked_conn(connection_t *conn);
  77. /********* START VARIABLES **********/
  78. #ifndef USE_BUFFEREVENTS
  79. int global_read_bucket; /**< Max number of bytes I can read this second. */
  80. int global_write_bucket; /**< Max number of bytes I can write this second. */
  81. /** Max number of relayed (bandwidth class 1) bytes I can read this second. */
  82. int global_relayed_read_bucket;
  83. /** Max number of relayed (bandwidth class 1) bytes I can write this second. */
  84. int global_relayed_write_bucket;
  85. /** What was the read bucket before the last second_elapsed_callback() call?
  86. * (used to determine how many bytes we've read). */
  87. static int stats_prev_global_read_bucket;
  88. /** What was the write bucket before the last second_elapsed_callback() call?
  89. * (used to determine how many bytes we've written). */
  90. static int stats_prev_global_write_bucket;
  91. #endif
  92. /* DOCDOC stats_prev_n_read */
  93. static uint64_t stats_prev_n_read = 0;
  94. /* DOCDOC stats_prev_n_written */
  95. static uint64_t stats_prev_n_written = 0;
  96. /* XXX we might want to keep stats about global_relayed_*_bucket too. Or not.*/
  97. /** How many bytes have we read since we started the process? */
  98. static uint64_t stats_n_bytes_read = 0;
  99. /** How many bytes have we written since we started the process? */
  100. static uint64_t stats_n_bytes_written = 0;
  101. /** What time did this process start up? */
  102. time_t time_of_process_start = 0;
  103. /** How many seconds have we been running? */
  104. long stats_n_seconds_working = 0;
  105. /** When do we next launch DNS wildcarding checks? */
  106. static time_t time_to_check_for_correct_dns = 0;
  107. /** How often will we honor SIGNEWNYM requests? */
  108. #define MAX_SIGNEWNYM_RATE 10
  109. /** When did we last process a SIGNEWNYM request? */
  110. static time_t time_of_last_signewnym = 0;
  111. /** Is there a signewnym request we're currently waiting to handle? */
  112. static int signewnym_is_pending = 0;
  113. /** How many times have we called newnym? */
  114. static unsigned newnym_epoch = 0;
  115. /** Smartlist of all open connections. */
  116. static smartlist_t *connection_array = NULL;
  117. /** List of connections that have been marked for close and need to be freed
  118. * and removed from connection_array. */
  119. static smartlist_t *closeable_connection_lst = NULL;
  120. /** List of linked connections that are currently reading data into their
  121. * inbuf from their partner's outbuf. */
  122. static smartlist_t *active_linked_connection_lst = NULL;
  123. /** Flag: Set to true iff we entered the current libevent main loop via
  124. * <b>loop_once</b>. If so, there's no need to trigger a loopexit in order
  125. * to handle linked connections. */
  126. static int called_loop_once = 0;
  127. /** We set this to 1 when we've opened a circuit, so we can print a log
  128. * entry to inform the user that Tor is working. We set it to 0 when
  129. * we think the fact that we once opened a circuit doesn't mean we can do so
  130. * any longer (a big time jump happened, when we notice our directory is
  131. * heinously out-of-date, etc.
  132. */
  133. int can_complete_circuit=0;
  134. /** How often do we check for router descriptors that we should download
  135. * when we have too little directory info? */
  136. #define GREEDY_DESCRIPTOR_RETRY_INTERVAL (10)
  137. /** How often do we check for router descriptors that we should download
  138. * when we have enough directory info? */
  139. #define LAZY_DESCRIPTOR_RETRY_INTERVAL (60)
  140. /** How often do we 'forgive' undownloadable router descriptors and attempt
  141. * to download them again? */
  142. #define DESCRIPTOR_FAILURE_RESET_INTERVAL (60*60)
  143. /** Decides our behavior when no logs are configured/before any
  144. * logs have been configured. For 0, we log notice to stdout as normal.
  145. * For 1, we log warnings only. For 2, we log nothing.
  146. */
  147. int quiet_level = 0;
  148. /********* END VARIABLES ************/
  149. /****************************************************************************
  150. *
  151. * This section contains accessors and other methods on the connection_array
  152. * variables (which are global within this file and unavailable outside it).
  153. *
  154. ****************************************************************************/
  155. #if 0 && defined(USE_BUFFEREVENTS)
  156. static void
  157. free_old_inbuf(connection_t *conn)
  158. {
  159. if (! conn->inbuf)
  160. return;
  161. tor_assert(conn->outbuf);
  162. tor_assert(buf_datalen(conn->inbuf) == 0);
  163. tor_assert(buf_datalen(conn->outbuf) == 0);
  164. buf_free(conn->inbuf);
  165. buf_free(conn->outbuf);
  166. conn->inbuf = conn->outbuf = NULL;
  167. if (conn->read_event) {
  168. event_del(conn->read_event);
  169. tor_event_free(conn->read_event);
  170. }
  171. if (conn->write_event) {
  172. event_del(conn->read_event);
  173. tor_event_free(conn->write_event);
  174. }
  175. conn->read_event = conn->write_event = NULL;
  176. }
  177. #endif
  178. #if defined(_WIN32) && defined(USE_BUFFEREVENTS)
  179. /** Remove the kernel-space send and receive buffers for <b>s</b>. For use
  180. * with IOCP only. */
  181. static int
  182. set_buffer_lengths_to_zero(tor_socket_t s)
  183. {
  184. int zero = 0;
  185. int r = 0;
  186. if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, (void*)&zero, sizeof(zero))) {
  187. log_warn(LD_NET, "Unable to clear SO_SNDBUF");
  188. r = -1;
  189. }
  190. if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, (void*)&zero, sizeof(zero))) {
  191. log_warn(LD_NET, "Unable to clear SO_RCVBUF");
  192. r = -1;
  193. }
  194. return r;
  195. }
  196. #endif
  197. /** Add <b>conn</b> to the array of connections that we can poll on. The
  198. * connection's socket must be set; the connection starts out
  199. * non-reading and non-writing.
  200. */
  201. int
  202. connection_add_impl(connection_t *conn, int is_connecting)
  203. {
  204. tor_assert(conn);
  205. tor_assert(SOCKET_OK(conn->s) ||
  206. conn->linked ||
  207. (conn->type == CONN_TYPE_AP &&
  208. TO_EDGE_CONN(conn)->is_dns_request));
  209. tor_assert(conn->conn_array_index == -1); /* can only connection_add once */
  210. conn->conn_array_index = smartlist_len(connection_array);
  211. smartlist_add(connection_array, conn);
  212. #ifdef USE_BUFFEREVENTS
  213. if (connection_type_uses_bufferevent(conn)) {
  214. if (SOCKET_OK(conn->s) && !conn->linked) {
  215. #ifdef _WIN32
  216. if (tor_libevent_using_iocp_bufferevents() &&
  217. get_options()->UserspaceIOCPBuffers) {
  218. set_buffer_lengths_to_zero(conn->s);
  219. }
  220. #endif
  221. conn->bufev = bufferevent_socket_new(
  222. tor_libevent_get_base(),
  223. conn->s,
  224. BEV_OPT_DEFER_CALLBACKS);
  225. if (!conn->bufev) {
  226. log_warn(LD_BUG, "Unable to create socket bufferevent");
  227. smartlist_del(connection_array, conn->conn_array_index);
  228. conn->conn_array_index = -1;
  229. return -1;
  230. }
  231. if (is_connecting) {
  232. /* Put the bufferevent into a "connecting" state so that we'll get
  233. * a "connected" event callback on successful write. */
  234. bufferevent_socket_connect(conn->bufev, NULL, 0);
  235. }
  236. connection_configure_bufferevent_callbacks(conn);
  237. } else if (conn->linked && conn->linked_conn &&
  238. connection_type_uses_bufferevent(conn->linked_conn)) {
  239. tor_assert(!(SOCKET_OK(conn->s)));
  240. if (!conn->bufev) {
  241. struct bufferevent *pair[2] = { NULL, NULL };
  242. if (bufferevent_pair_new(tor_libevent_get_base(),
  243. BEV_OPT_DEFER_CALLBACKS,
  244. pair) < 0) {
  245. log_warn(LD_BUG, "Unable to create bufferevent pair");
  246. smartlist_del(connection_array, conn->conn_array_index);
  247. conn->conn_array_index = -1;
  248. return -1;
  249. }
  250. tor_assert(pair[0]);
  251. conn->bufev = pair[0];
  252. conn->linked_conn->bufev = pair[1];
  253. } /* else the other side already was added, and got a bufferevent_pair */
  254. connection_configure_bufferevent_callbacks(conn);
  255. } else {
  256. tor_assert(!conn->linked);
  257. }
  258. if (conn->bufev)
  259. tor_assert(conn->inbuf == NULL);
  260. if (conn->linked_conn && conn->linked_conn->bufev)
  261. tor_assert(conn->linked_conn->inbuf == NULL);
  262. }
  263. #else
  264. (void) is_connecting;
  265. #endif
  266. if (!HAS_BUFFEREVENT(conn) && (SOCKET_OK(conn->s) || conn->linked)) {
  267. conn->read_event = tor_event_new(tor_libevent_get_base(),
  268. conn->s, EV_READ|EV_PERSIST, conn_read_callback, conn);
  269. conn->write_event = tor_event_new(tor_libevent_get_base(),
  270. conn->s, EV_WRITE|EV_PERSIST, conn_write_callback, conn);
  271. /* XXXX CHECK FOR NULL RETURN! */
  272. }
  273. log_debug(LD_NET,"new conn type %s, socket %d, address %s, n_conns %d.",
  274. conn_type_to_string(conn->type), (int)conn->s, conn->address,
  275. smartlist_len(connection_array));
  276. return 0;
  277. }
  278. /** Tell libevent that we don't care about <b>conn</b> any more. */
  279. void
  280. connection_unregister_events(connection_t *conn)
  281. {
  282. if (conn->read_event) {
  283. if (event_del(conn->read_event))
  284. log_warn(LD_BUG, "Error removing read event for %d", (int)conn->s);
  285. tor_free(conn->read_event);
  286. }
  287. if (conn->write_event) {
  288. if (event_del(conn->write_event))
  289. log_warn(LD_BUG, "Error removing write event for %d", (int)conn->s);
  290. tor_free(conn->write_event);
  291. }
  292. #ifdef USE_BUFFEREVENTS
  293. if (conn->bufev) {
  294. bufferevent_free(conn->bufev);
  295. conn->bufev = NULL;
  296. }
  297. #endif
  298. if (conn->type == CONN_TYPE_AP_DNS_LISTENER) {
  299. dnsserv_close_listener(conn);
  300. }
  301. }
  302. /** Remove the connection from the global list, and remove the
  303. * corresponding poll entry. Calling this function will shift the last
  304. * connection (if any) into the position occupied by conn.
  305. */
  306. int
  307. connection_remove(connection_t *conn)
  308. {
  309. int current_index;
  310. connection_t *tmp;
  311. tor_assert(conn);
  312. log_debug(LD_NET,"removing socket %d (type %s), n_conns now %d",
  313. (int)conn->s, conn_type_to_string(conn->type),
  314. smartlist_len(connection_array));
  315. tor_assert(conn->conn_array_index >= 0);
  316. current_index = conn->conn_array_index;
  317. connection_unregister_events(conn); /* This is redundant, but cheap. */
  318. if (current_index == smartlist_len(connection_array)-1) { /* at the end */
  319. smartlist_del(connection_array, current_index);
  320. return 0;
  321. }
  322. /* replace this one with the one at the end */
  323. smartlist_del(connection_array, current_index);
  324. tmp = smartlist_get(connection_array, current_index);
  325. tmp->conn_array_index = current_index;
  326. return 0;
  327. }
  328. /** If <b>conn</b> is an edge conn, remove it from the list
  329. * of conn's on this circuit. If it's not on an edge,
  330. * flush and send destroys for all circuits on this conn.
  331. *
  332. * Remove it from connection_array (if applicable) and
  333. * from closeable_connection_list.
  334. *
  335. * Then free it.
  336. */
  337. static void
  338. connection_unlink(connection_t *conn)
  339. {
  340. connection_about_to_close_connection(conn);
  341. if (conn->conn_array_index >= 0) {
  342. connection_remove(conn);
  343. }
  344. if (conn->linked_conn) {
  345. conn->linked_conn->linked_conn = NULL;
  346. if (! conn->linked_conn->marked_for_close &&
  347. conn->linked_conn->reading_from_linked_conn)
  348. connection_start_reading(conn->linked_conn);
  349. conn->linked_conn = NULL;
  350. }
  351. smartlist_remove(closeable_connection_lst, conn);
  352. smartlist_remove(active_linked_connection_lst, conn);
  353. if (conn->type == CONN_TYPE_EXIT) {
  354. assert_connection_edge_not_dns_pending(TO_EDGE_CONN(conn));
  355. }
  356. if (conn->type == CONN_TYPE_OR) {
  357. if (!tor_digest_is_zero(TO_OR_CONN(conn)->identity_digest))
  358. connection_or_remove_from_identity_map(TO_OR_CONN(conn));
  359. /* connection_unlink() can only get called if the connection
  360. * was already on the closeable list, and it got there by
  361. * connection_mark_for_close(), which was called from
  362. * connection_or_close_normally() or
  363. * connection_or_close_for_error(), so the channel should
  364. * already be in CHANNEL_STATE_CLOSING, and then the
  365. * connection_about_to_close_connection() goes to
  366. * connection_or_about_to_close(), which calls channel_closed()
  367. * to notify the channel_t layer, and closed the channel, so
  368. * nothing more to do here to deal with the channel associated
  369. * with an orconn.
  370. */
  371. }
  372. connection_free(conn);
  373. }
  374. /** Schedule <b>conn</b> to be closed. **/
  375. void
  376. add_connection_to_closeable_list(connection_t *conn)
  377. {
  378. tor_assert(!smartlist_contains(closeable_connection_lst, conn));
  379. tor_assert(conn->marked_for_close);
  380. assert_connection_ok(conn, time(NULL));
  381. smartlist_add(closeable_connection_lst, conn);
  382. }
  383. /** Return 1 if conn is on the closeable list, else return 0. */
  384. int
  385. connection_is_on_closeable_list(connection_t *conn)
  386. {
  387. return smartlist_contains(closeable_connection_lst, conn);
  388. }
  389. /** Return true iff conn is in the current poll array. */
  390. int
  391. connection_in_array(connection_t *conn)
  392. {
  393. return smartlist_contains(connection_array, conn);
  394. }
  395. /** Set <b>*array</b> to an array of all connections, and <b>*n</b>
  396. * to the length of the array. <b>*array</b> and <b>*n</b> must not
  397. * be modified.
  398. */
  399. smartlist_t *
  400. get_connection_array(void)
  401. {
  402. if (!connection_array)
  403. connection_array = smartlist_new();
  404. return connection_array;
  405. }
  406. /** Provides the traffic read and written over the life of the process. */
  407. uint64_t
  408. get_bytes_read(void)
  409. {
  410. return stats_n_bytes_read;
  411. }
  412. /* DOCDOC get_bytes_written */
  413. uint64_t
  414. get_bytes_written(void)
  415. {
  416. return stats_n_bytes_written;
  417. }
  418. /** Set the event mask on <b>conn</b> to <b>events</b>. (The event
  419. * mask is a bitmask whose bits are READ_EVENT and WRITE_EVENT)
  420. */
  421. void
  422. connection_watch_events(connection_t *conn, watchable_events_t events)
  423. {
  424. IF_HAS_BUFFEREVENT(conn, {
  425. short ev = ((short)events) & (EV_READ|EV_WRITE);
  426. short old_ev = bufferevent_get_enabled(conn->bufev);
  427. if ((ev & ~old_ev) != 0) {
  428. bufferevent_enable(conn->bufev, ev);
  429. }
  430. if ((old_ev & ~ev) != 0) {
  431. bufferevent_disable(conn->bufev, old_ev & ~ev);
  432. }
  433. return;
  434. });
  435. if (events & READ_EVENT)
  436. connection_start_reading(conn);
  437. else
  438. connection_stop_reading(conn);
  439. if (events & WRITE_EVENT)
  440. connection_start_writing(conn);
  441. else
  442. connection_stop_writing(conn);
  443. }
  444. /** Return true iff <b>conn</b> is listening for read events. */
  445. int
  446. connection_is_reading(connection_t *conn)
  447. {
  448. tor_assert(conn);
  449. IF_HAS_BUFFEREVENT(conn,
  450. return (bufferevent_get_enabled(conn->bufev) & EV_READ) != 0;
  451. );
  452. return conn->reading_from_linked_conn ||
  453. (conn->read_event && event_pending(conn->read_event, EV_READ, NULL));
  454. }
  455. /** Tell the main loop to stop notifying <b>conn</b> of any read events. */
  456. void
  457. connection_stop_reading(connection_t *conn)
  458. {
  459. tor_assert(conn);
  460. IF_HAS_BUFFEREVENT(conn, {
  461. bufferevent_disable(conn->bufev, EV_READ);
  462. return;
  463. });
  464. tor_assert(conn->read_event);
  465. if (conn->linked) {
  466. conn->reading_from_linked_conn = 0;
  467. connection_stop_reading_from_linked_conn(conn);
  468. } else {
  469. if (event_del(conn->read_event))
  470. log_warn(LD_NET, "Error from libevent setting read event state for %d "
  471. "to unwatched: %s",
  472. (int)conn->s,
  473. tor_socket_strerror(tor_socket_errno(conn->s)));
  474. }
  475. }
  476. /** Tell the main loop to start notifying <b>conn</b> of any read events. */
  477. void
  478. connection_start_reading(connection_t *conn)
  479. {
  480. tor_assert(conn);
  481. IF_HAS_BUFFEREVENT(conn, {
  482. bufferevent_enable(conn->bufev, EV_READ);
  483. return;
  484. });
  485. tor_assert(conn->read_event);
  486. if (conn->linked) {
  487. conn->reading_from_linked_conn = 1;
  488. if (connection_should_read_from_linked_conn(conn))
  489. connection_start_reading_from_linked_conn(conn);
  490. } else {
  491. if (event_add(conn->read_event, NULL))
  492. log_warn(LD_NET, "Error from libevent setting read event state for %d "
  493. "to watched: %s",
  494. (int)conn->s,
  495. tor_socket_strerror(tor_socket_errno(conn->s)));
  496. }
  497. }
  498. /** Return true iff <b>conn</b> is listening for write events. */
  499. int
  500. connection_is_writing(connection_t *conn)
  501. {
  502. tor_assert(conn);
  503. IF_HAS_BUFFEREVENT(conn,
  504. return (bufferevent_get_enabled(conn->bufev) & EV_WRITE) != 0;
  505. );
  506. return conn->writing_to_linked_conn ||
  507. (conn->write_event && event_pending(conn->write_event, EV_WRITE, NULL));
  508. }
  509. /** Tell the main loop to stop notifying <b>conn</b> of any write events. */
  510. void
  511. connection_stop_writing(connection_t *conn)
  512. {
  513. tor_assert(conn);
  514. IF_HAS_BUFFEREVENT(conn, {
  515. bufferevent_disable(conn->bufev, EV_WRITE);
  516. return;
  517. });
  518. tor_assert(conn->write_event);
  519. if (conn->linked) {
  520. conn->writing_to_linked_conn = 0;
  521. if (conn->linked_conn)
  522. connection_stop_reading_from_linked_conn(conn->linked_conn);
  523. } else {
  524. if (event_del(conn->write_event))
  525. log_warn(LD_NET, "Error from libevent setting write event state for %d "
  526. "to unwatched: %s",
  527. (int)conn->s,
  528. tor_socket_strerror(tor_socket_errno(conn->s)));
  529. }
  530. }
  531. /** Tell the main loop to start notifying <b>conn</b> of any write events. */
  532. void
  533. connection_start_writing(connection_t *conn)
  534. {
  535. tor_assert(conn);
  536. IF_HAS_BUFFEREVENT(conn, {
  537. bufferevent_enable(conn->bufev, EV_WRITE);
  538. return;
  539. });
  540. tor_assert(conn->write_event);
  541. if (conn->linked) {
  542. conn->writing_to_linked_conn = 1;
  543. if (conn->linked_conn &&
  544. connection_should_read_from_linked_conn(conn->linked_conn))
  545. connection_start_reading_from_linked_conn(conn->linked_conn);
  546. } else {
  547. if (event_add(conn->write_event, NULL))
  548. log_warn(LD_NET, "Error from libevent setting write event state for %d "
  549. "to watched: %s",
  550. (int)conn->s,
  551. tor_socket_strerror(tor_socket_errno(conn->s)));
  552. }
  553. }
  554. /** Return true iff <b>conn</b> is linked conn, and reading from the conn
  555. * linked to it would be good and feasible. (Reading is "feasible" if the
  556. * other conn exists and has data in its outbuf, and is "good" if we have our
  557. * reading_from_linked_conn flag set and the other conn has its
  558. * writing_to_linked_conn flag set.)*/
  559. static int
  560. connection_should_read_from_linked_conn(connection_t *conn)
  561. {
  562. if (conn->linked && conn->reading_from_linked_conn) {
  563. if (! conn->linked_conn ||
  564. (conn->linked_conn->writing_to_linked_conn &&
  565. buf_datalen(conn->linked_conn->outbuf)))
  566. return 1;
  567. }
  568. return 0;
  569. }
  570. /** Helper: Tell the main loop to begin reading bytes into <b>conn</b> from
  571. * its linked connection, if it is not doing so already. Called by
  572. * connection_start_reading and connection_start_writing as appropriate. */
  573. static void
  574. connection_start_reading_from_linked_conn(connection_t *conn)
  575. {
  576. tor_assert(conn);
  577. tor_assert(conn->linked == 1);
  578. if (!conn->active_on_link) {
  579. conn->active_on_link = 1;
  580. smartlist_add(active_linked_connection_lst, conn);
  581. if (!called_loop_once) {
  582. /* This is the first event on the list; we won't be in LOOP_ONCE mode,
  583. * so we need to make sure that the event_base_loop() actually exits at
  584. * the end of its run through the current connections and lets us
  585. * activate read events for linked connections. */
  586. struct timeval tv = { 0, 0 };
  587. tor_event_base_loopexit(tor_libevent_get_base(), &tv);
  588. }
  589. } else {
  590. tor_assert(smartlist_contains(active_linked_connection_lst, conn));
  591. }
  592. }
  593. /** Tell the main loop to stop reading bytes into <b>conn</b> from its linked
  594. * connection, if is currently doing so. Called by connection_stop_reading,
  595. * connection_stop_writing, and connection_read. */
  596. void
  597. connection_stop_reading_from_linked_conn(connection_t *conn)
  598. {
  599. tor_assert(conn);
  600. tor_assert(conn->linked == 1);
  601. if (conn->active_on_link) {
  602. conn->active_on_link = 0;
  603. /* FFFF We could keep an index here so we can smartlist_del
  604. * cleanly. On the other hand, this doesn't show up on profiles,
  605. * so let's leave it alone for now. */
  606. smartlist_remove(active_linked_connection_lst, conn);
  607. } else {
  608. tor_assert(!smartlist_contains(active_linked_connection_lst, conn));
  609. }
  610. }
  611. /** Close all connections that have been scheduled to get closed. */
  612. static void
  613. close_closeable_connections(void)
  614. {
  615. int i;
  616. for (i = 0; i < smartlist_len(closeable_connection_lst); ) {
  617. connection_t *conn = smartlist_get(closeable_connection_lst, i);
  618. if (conn->conn_array_index < 0) {
  619. connection_unlink(conn); /* blow it away right now */
  620. } else {
  621. if (!conn_close_if_marked(conn->conn_array_index))
  622. ++i;
  623. }
  624. }
  625. }
  626. /** Libevent callback: this gets invoked when (connection_t*)<b>conn</b> has
  627. * some data to read. */
  628. static void
  629. conn_read_callback(evutil_socket_t fd, short event, void *_conn)
  630. {
  631. connection_t *conn = _conn;
  632. (void)fd;
  633. (void)event;
  634. log_debug(LD_NET,"socket %d wants to read.",(int)conn->s);
  635. /* assert_connection_ok(conn, time(NULL)); */
  636. if (connection_handle_read(conn) < 0) {
  637. if (!conn->marked_for_close) {
  638. #ifndef _WIN32
  639. log_warn(LD_BUG,"Unhandled error on read for %s connection "
  640. "(fd %d); removing",
  641. conn_type_to_string(conn->type), (int)conn->s);
  642. tor_fragile_assert();
  643. #endif
  644. if (CONN_IS_EDGE(conn))
  645. connection_edge_end_errno(TO_EDGE_CONN(conn));
  646. connection_mark_for_close(conn);
  647. }
  648. }
  649. assert_connection_ok(conn, time(NULL));
  650. if (smartlist_len(closeable_connection_lst))
  651. close_closeable_connections();
  652. }
  653. /** Libevent callback: this gets invoked when (connection_t*)<b>conn</b> has
  654. * some data to write. */
  655. static void
  656. conn_write_callback(evutil_socket_t fd, short events, void *_conn)
  657. {
  658. connection_t *conn = _conn;
  659. (void)fd;
  660. (void)events;
  661. LOG_FN_CONN(conn, (LOG_DEBUG, LD_NET, "socket %d wants to write.",
  662. (int)conn->s));
  663. /* assert_connection_ok(conn, time(NULL)); */
  664. if (connection_handle_write(conn, 0) < 0) {
  665. if (!conn->marked_for_close) {
  666. /* this connection is broken. remove it. */
  667. log_fn(LOG_WARN,LD_BUG,
  668. "unhandled error on write for %s connection (fd %d); removing",
  669. conn_type_to_string(conn->type), (int)conn->s);
  670. tor_fragile_assert();
  671. if (CONN_IS_EDGE(conn)) {
  672. /* otherwise we cry wolf about duplicate close */
  673. edge_connection_t *edge_conn = TO_EDGE_CONN(conn);
  674. if (!edge_conn->end_reason)
  675. edge_conn->end_reason = END_STREAM_REASON_INTERNAL;
  676. edge_conn->edge_has_sent_end = 1;
  677. }
  678. connection_close_immediate(conn); /* So we don't try to flush. */
  679. connection_mark_for_close(conn);
  680. }
  681. }
  682. assert_connection_ok(conn, time(NULL));
  683. if (smartlist_len(closeable_connection_lst))
  684. close_closeable_connections();
  685. }
  686. /** If the connection at connection_array[i] is marked for close, then:
  687. * - If it has data that it wants to flush, try to flush it.
  688. * - If it _still_ has data to flush, and conn->hold_open_until_flushed is
  689. * true, then leave the connection open and return.
  690. * - Otherwise, remove the connection from connection_array and from
  691. * all other lists, close it, and free it.
  692. * Returns 1 if the connection was closed, 0 otherwise.
  693. */
  694. static int
  695. conn_close_if_marked(int i)
  696. {
  697. connection_t *conn;
  698. int retval;
  699. time_t now;
  700. conn = smartlist_get(connection_array, i);
  701. if (!conn->marked_for_close)
  702. return 0; /* nothing to see here, move along */
  703. now = time(NULL);
  704. assert_connection_ok(conn, now);
  705. /* assert_all_pending_dns_resolves_ok(); */
  706. #ifdef USE_BUFFEREVENTS
  707. if (conn->bufev) {
  708. if (conn->hold_open_until_flushed &&
  709. evbuffer_get_length(bufferevent_get_output(conn->bufev))) {
  710. /* don't close yet. */
  711. return 0;
  712. }
  713. if (conn->linked_conn && ! conn->linked_conn->marked_for_close) {
  714. /* We need to do this explicitly so that the linked connection
  715. * notices that there was an EOF. */
  716. bufferevent_flush(conn->bufev, EV_WRITE, BEV_FINISHED);
  717. }
  718. }
  719. #endif
  720. log_debug(LD_NET,"Cleaning up connection (fd "TOR_SOCKET_T_FORMAT").",
  721. conn->s);
  722. /* If the connection we are about to close was trying to connect to
  723. a proxy server and failed, the client won't be able to use that
  724. proxy. We should warn the user about this. */
  725. if (conn->proxy_state == PROXY_INFANT)
  726. log_failed_proxy_connection(conn);
  727. IF_HAS_BUFFEREVENT(conn, goto unlink);
  728. if ((SOCKET_OK(conn->s) || conn->linked_conn) &&
  729. connection_wants_to_flush(conn)) {
  730. /* s == -1 means it's an incomplete edge connection, or that the socket
  731. * has already been closed as unflushable. */
  732. ssize_t sz = connection_bucket_write_limit(conn, now);
  733. if (!conn->hold_open_until_flushed)
  734. log_info(LD_NET,
  735. "Conn (addr %s, fd %d, type %s, state %d) marked, but wants "
  736. "to flush %d bytes. (Marked at %s:%d)",
  737. escaped_safe_str_client(conn->address),
  738. (int)conn->s, conn_type_to_string(conn->type), conn->state,
  739. (int)conn->outbuf_flushlen,
  740. conn->marked_for_close_file, conn->marked_for_close);
  741. if (conn->linked_conn) {
  742. retval = move_buf_to_buf(conn->linked_conn->inbuf, conn->outbuf,
  743. &conn->outbuf_flushlen);
  744. if (retval >= 0) {
  745. /* The linked conn will notice that it has data when it notices that
  746. * we're gone. */
  747. connection_start_reading_from_linked_conn(conn->linked_conn);
  748. }
  749. log_debug(LD_GENERAL, "Flushed last %d bytes from a linked conn; "
  750. "%d left; flushlen %d; wants-to-flush==%d", retval,
  751. (int)connection_get_outbuf_len(conn),
  752. (int)conn->outbuf_flushlen,
  753. connection_wants_to_flush(conn));
  754. } else if (connection_speaks_cells(conn)) {
  755. if (conn->state == OR_CONN_STATE_OPEN) {
  756. retval = flush_buf_tls(TO_OR_CONN(conn)->tls, conn->outbuf, sz,
  757. &conn->outbuf_flushlen);
  758. } else
  759. retval = -1; /* never flush non-open broken tls connections */
  760. } else {
  761. retval = flush_buf(conn->s, conn->outbuf, sz, &conn->outbuf_flushlen);
  762. }
  763. if (retval >= 0 && /* Technically, we could survive things like
  764. TLS_WANT_WRITE here. But don't bother for now. */
  765. conn->hold_open_until_flushed && connection_wants_to_flush(conn)) {
  766. if (retval > 0) {
  767. LOG_FN_CONN(conn, (LOG_INFO,LD_NET,
  768. "Holding conn (fd %d) open for more flushing.",
  769. (int)conn->s));
  770. conn->timestamp_lastwritten = now; /* reset so we can flush more */
  771. } else if (sz == 0) {
  772. /* Also, retval==0. If we get here, we didn't want to write anything
  773. * (because of rate-limiting) and we didn't. */
  774. /* Connection must flush before closing, but it's being rate-limited.
  775. * Let's remove from Libevent, and mark it as blocked on bandwidth
  776. * so it will be re-added on next token bucket refill. Prevents
  777. * busy Libevent loops where we keep ending up here and returning
  778. * 0 until we are no longer blocked on bandwidth.
  779. */
  780. if (connection_is_writing(conn)) {
  781. conn->write_blocked_on_bw = 1;
  782. connection_stop_writing(conn);
  783. }
  784. if (connection_is_reading(conn)) {
  785. /* XXXX024 We should make this code unreachable; if a connection is
  786. * marked for close and flushing, there is no point in reading to it
  787. * at all. Further, checking at this point is a bit of a hack: it
  788. * would make much more sense to react in
  789. * connection_handle_read_impl, or to just stop reading in
  790. * mark_and_flush */
  791. #if 0
  792. #define MARKED_READING_RATE 180
  793. static ratelim_t marked_read_lim = RATELIM_INIT(MARKED_READING_RATE);
  794. char *m;
  795. if ((m = rate_limit_log(&marked_read_lim, now))) {
  796. log_warn(LD_BUG, "Marked connection (fd %d, type %s, state %s) "
  797. "is still reading; that shouldn't happen.%s",
  798. (int)conn->s, conn_type_to_string(conn->type),
  799. conn_state_to_string(conn->type, conn->state), m);
  800. tor_free(m);
  801. }
  802. #endif
  803. conn->read_blocked_on_bw = 1;
  804. connection_stop_reading(conn);
  805. }
  806. }
  807. return 0;
  808. }
  809. if (connection_wants_to_flush(conn)) {
  810. int severity;
  811. if (conn->type == CONN_TYPE_EXIT ||
  812. (conn->type == CONN_TYPE_OR && server_mode(get_options())) ||
  813. (conn->type == CONN_TYPE_DIR && conn->purpose == DIR_PURPOSE_SERVER))
  814. severity = LOG_INFO;
  815. else
  816. severity = LOG_NOTICE;
  817. /* XXXX Maybe allow this to happen a certain amount per hour; it usually
  818. * is meaningless. */
  819. log_fn(severity, LD_NET, "We stalled too much while trying to write %d "
  820. "bytes to address %s. If this happens a lot, either "
  821. "something is wrong with your network connection, or "
  822. "something is wrong with theirs. "
  823. "(fd %d, type %s, state %d, marked at %s:%d).",
  824. (int)connection_get_outbuf_len(conn),
  825. escaped_safe_str_client(conn->address),
  826. (int)conn->s, conn_type_to_string(conn->type), conn->state,
  827. conn->marked_for_close_file,
  828. conn->marked_for_close);
  829. }
  830. }
  831. #ifdef USE_BUFFEREVENTS
  832. unlink:
  833. #endif
  834. connection_unlink(conn); /* unlink, remove, free */
  835. return 1;
  836. }
  837. /** We've just tried every dirserver we know about, and none of
  838. * them were reachable. Assume the network is down. Change state
  839. * so next time an application connection arrives we'll delay it
  840. * and try another directory fetch. Kill off all the circuit_wait
  841. * streams that are waiting now, since they will all timeout anyway.
  842. */
  843. void
  844. directory_all_unreachable(time_t now)
  845. {
  846. connection_t *conn;
  847. (void)now;
  848. stats_n_seconds_working=0; /* reset it */
  849. while ((conn = connection_get_by_type_state(CONN_TYPE_AP,
  850. AP_CONN_STATE_CIRCUIT_WAIT))) {
  851. entry_connection_t *entry_conn = TO_ENTRY_CONN(conn);
  852. log_notice(LD_NET,
  853. "Is your network connection down? "
  854. "Failing connection to '%s:%d'.",
  855. safe_str_client(entry_conn->socks_request->address),
  856. entry_conn->socks_request->port);
  857. connection_mark_unattached_ap(entry_conn,
  858. END_STREAM_REASON_NET_UNREACHABLE);
  859. }
  860. control_event_general_status(LOG_ERR, "DIR_ALL_UNREACHABLE");
  861. }
  862. /** This function is called whenever we successfully pull down some new
  863. * network statuses or server descriptors. */
  864. void
  865. directory_info_has_arrived(time_t now, int from_cache)
  866. {
  867. const or_options_t *options = get_options();
  868. if (!router_have_minimum_dir_info()) {
  869. int quiet = from_cache ||
  870. directory_too_idle_to_fetch_descriptors(options, now);
  871. tor_log(quiet ? LOG_INFO : LOG_NOTICE, LD_DIR,
  872. "I learned some more directory information, but not enough to "
  873. "build a circuit: %s", get_dir_info_status_string());
  874. update_all_descriptor_downloads(now);
  875. return;
  876. } else {
  877. if (directory_fetches_from_authorities(options)) {
  878. update_all_descriptor_downloads(now);
  879. }
  880. /* if we have enough dir info, then update our guard status with
  881. * whatever we just learned. */
  882. entry_guards_compute_status(options, now);
  883. /* Don't even bother trying to get extrainfo until the rest of our
  884. * directory info is up-to-date */
  885. if (options->DownloadExtraInfo)
  886. update_extrainfo_downloads(now);
  887. }
  888. if (server_mode(options) && !net_is_disabled() && !from_cache &&
  889. (can_complete_circuit || !any_predicted_circuits(now)))
  890. consider_testing_reachability(1, 1);
  891. }
  892. /** How long do we wait before killing OR connections with no circuits?
  893. * In Tor versions up to 0.2.1.25 and 0.2.2.12-alpha, we waited 15 minutes
  894. * before cancelling these connections, which caused fast relays to accrue
  895. * many many idle connections. Hopefully 3 minutes is low enough that
  896. * it kills most idle connections, without being so low that we cause
  897. * clients to bounce on and off.
  898. */
  899. #define IDLE_OR_CONN_TIMEOUT 180
  900. /** Perform regular maintenance tasks for a single connection. This
  901. * function gets run once per second per connection by run_scheduled_events.
  902. */
  903. static void
  904. run_connection_housekeeping(int i, time_t now)
  905. {
  906. cell_t cell;
  907. connection_t *conn = smartlist_get(connection_array, i);
  908. const or_options_t *options = get_options();
  909. or_connection_t *or_conn;
  910. int past_keepalive =
  911. now >= conn->timestamp_lastwritten + options->KeepalivePeriod;
  912. if (conn->outbuf && !connection_get_outbuf_len(conn) &&
  913. conn->type == CONN_TYPE_OR)
  914. TO_OR_CONN(conn)->timestamp_lastempty = now;
  915. if (conn->marked_for_close) {
  916. /* nothing to do here */
  917. return;
  918. }
  919. /* Expire any directory connections that haven't been active (sent
  920. * if a server or received if a client) for 5 min */
  921. if (conn->type == CONN_TYPE_DIR &&
  922. ((DIR_CONN_IS_SERVER(conn) &&
  923. conn->timestamp_lastwritten
  924. + options->TestingDirConnectionMaxStall < now) ||
  925. (!DIR_CONN_IS_SERVER(conn) &&
  926. conn->timestamp_lastread
  927. + options->TestingDirConnectionMaxStall < now))) {
  928. log_info(LD_DIR,"Expiring wedged directory conn (fd %d, purpose %d)",
  929. (int)conn->s, conn->purpose);
  930. /* This check is temporary; it's to let us know whether we should consider
  931. * parsing partial serverdesc responses. */
  932. if (conn->purpose == DIR_PURPOSE_FETCH_SERVERDESC &&
  933. connection_get_inbuf_len(conn) >= 1024) {
  934. log_info(LD_DIR,"Trying to extract information from wedged server desc "
  935. "download.");
  936. connection_dir_reached_eof(TO_DIR_CONN(conn));
  937. } else {
  938. connection_mark_for_close(conn);
  939. }
  940. return;
  941. }
  942. if (!connection_speaks_cells(conn))
  943. return; /* we're all done here, the rest is just for OR conns */
  944. /* If we haven't written to an OR connection for a while, then either nuke
  945. the connection or send a keepalive, depending. */
  946. or_conn = TO_OR_CONN(conn);
  947. #ifdef USE_BUFFEREVENTS
  948. tor_assert(conn->bufev);
  949. #else
  950. tor_assert(conn->outbuf);
  951. #endif
  952. if (channel_is_bad_for_new_circs(TLS_CHAN_TO_BASE(or_conn->chan)) &&
  953. !connection_or_get_num_circuits(or_conn)) {
  954. /* It's bad for new circuits, and has no unmarked circuits on it:
  955. * mark it now. */
  956. log_info(LD_OR,
  957. "Expiring non-used OR connection to fd %d (%s:%d) [Too old].",
  958. (int)conn->s, conn->address, conn->port);
  959. if (conn->state == OR_CONN_STATE_CONNECTING)
  960. connection_or_connect_failed(TO_OR_CONN(conn),
  961. END_OR_CONN_REASON_TIMEOUT,
  962. "Tor gave up on the connection");
  963. connection_or_close_normally(TO_OR_CONN(conn), 1);
  964. } else if (!connection_state_is_open(conn)) {
  965. if (past_keepalive) {
  966. /* We never managed to actually get this connection open and happy. */
  967. log_info(LD_OR,"Expiring non-open OR connection to fd %d (%s:%d).",
  968. (int)conn->s,conn->address, conn->port);
  969. connection_or_close_normally(TO_OR_CONN(conn), 0);
  970. }
  971. } else if (we_are_hibernating() &&
  972. !connection_or_get_num_circuits(or_conn) &&
  973. !connection_get_outbuf_len(conn)) {
  974. /* We're hibernating, there's no circuits, and nothing to flush.*/
  975. log_info(LD_OR,"Expiring non-used OR connection to fd %d (%s:%d) "
  976. "[Hibernating or exiting].",
  977. (int)conn->s,conn->address, conn->port);
  978. connection_or_close_normally(TO_OR_CONN(conn), 1);
  979. } else if (!connection_or_get_num_circuits(or_conn) &&
  980. now >= or_conn->timestamp_last_added_nonpadding +
  981. IDLE_OR_CONN_TIMEOUT) {
  982. log_info(LD_OR,"Expiring non-used OR connection to fd %d (%s:%d) "
  983. "[idle %d].", (int)conn->s,conn->address, conn->port,
  984. (int)(now - or_conn->timestamp_last_added_nonpadding));
  985. connection_or_close_normally(TO_OR_CONN(conn), 0);
  986. } else if (
  987. now >= or_conn->timestamp_lastempty + options->KeepalivePeriod*10 &&
  988. now >= conn->timestamp_lastwritten + options->KeepalivePeriod*10) {
  989. log_fn(LOG_PROTOCOL_WARN,LD_PROTOCOL,
  990. "Expiring stuck OR connection to fd %d (%s:%d). (%d bytes to "
  991. "flush; %d seconds since last write)",
  992. (int)conn->s, conn->address, conn->port,
  993. (int)connection_get_outbuf_len(conn),
  994. (int)(now-conn->timestamp_lastwritten));
  995. connection_or_close_normally(TO_OR_CONN(conn), 0);
  996. } else if (past_keepalive && !connection_get_outbuf_len(conn)) {
  997. /* send a padding cell */
  998. log_fn(LOG_DEBUG,LD_OR,"Sending keepalive to (%s:%d)",
  999. conn->address, conn->port);
  1000. memset(&cell,0,sizeof(cell_t));
  1001. cell.command = CELL_PADDING;
  1002. connection_or_write_cell_to_buf(&cell, or_conn);
  1003. }
  1004. }
  1005. /** Honor a NEWNYM request: make future requests unlinkable to past
  1006. * requests. */
  1007. static void
  1008. signewnym_impl(time_t now)
  1009. {
  1010. const or_options_t *options = get_options();
  1011. if (!proxy_mode(options)) {
  1012. log_info(LD_CONTROL, "Ignoring SIGNAL NEWNYM because client functionality "
  1013. "is disabled.");
  1014. return;
  1015. }
  1016. circuit_mark_all_dirty_circs_as_unusable();
  1017. addressmap_clear_transient();
  1018. rend_client_purge_state();
  1019. time_of_last_signewnym = now;
  1020. signewnym_is_pending = 0;
  1021. ++newnym_epoch;
  1022. control_event_signal(SIGNEWNYM);
  1023. }
  1024. /** Return the number of times that signewnym has been called. */
  1025. unsigned
  1026. get_signewnym_epoch(void)
  1027. {
  1028. return newnym_epoch;
  1029. }
  1030. /** Perform regular maintenance tasks. This function gets run once per
  1031. * second by second_elapsed_callback().
  1032. */
  1033. static void
  1034. run_scheduled_events(time_t now)
  1035. {
  1036. static time_t last_rotated_x509_certificate = 0;
  1037. static time_t time_to_check_v3_certificate = 0;
  1038. static time_t time_to_check_listeners = 0;
  1039. static time_t time_to_check_descriptor = 0;
  1040. static time_t time_to_download_networkstatus = 0;
  1041. static time_t time_to_shrink_memory = 0;
  1042. static time_t time_to_try_getting_descriptors = 0;
  1043. static time_t time_to_reset_descriptor_failures = 0;
  1044. static time_t time_to_add_entropy = 0;
  1045. static time_t time_to_write_bridge_status_file = 0;
  1046. static time_t time_to_downrate_stability = 0;
  1047. static time_t time_to_save_stability = 0;
  1048. static time_t time_to_clean_caches = 0;
  1049. static time_t time_to_recheck_bandwidth = 0;
  1050. static time_t time_to_check_for_expired_networkstatus = 0;
  1051. static time_t time_to_write_stats_files = 0;
  1052. static time_t time_to_write_bridge_stats = 0;
  1053. static time_t time_to_check_port_forwarding = 0;
  1054. static time_t time_to_launch_reachability_tests = 0;
  1055. static int should_init_bridge_stats = 1;
  1056. static time_t time_to_retry_dns_init = 0;
  1057. static time_t time_to_next_heartbeat = 0;
  1058. const or_options_t *options = get_options();
  1059. int is_server = server_mode(options);
  1060. int i;
  1061. int have_dir_info;
  1062. /** 0. See if we've been asked to shut down and our timeout has
  1063. * expired; or if our bandwidth limits are exhausted and we
  1064. * should hibernate; or if it's time to wake up from hibernation.
  1065. */
  1066. consider_hibernation(now);
  1067. #if 0
  1068. {
  1069. static time_t nl_check_time = 0;
  1070. if (nl_check_time <= now) {
  1071. nodelist_assert_ok();
  1072. nl_check_time = now + 30;
  1073. }
  1074. }
  1075. #endif
  1076. /* 0b. If we've deferred a signewnym, make sure it gets handled
  1077. * eventually. */
  1078. if (signewnym_is_pending &&
  1079. time_of_last_signewnym + MAX_SIGNEWNYM_RATE <= now) {
  1080. log_info(LD_CONTROL, "Honoring delayed NEWNYM request");
  1081. signewnym_impl(now);
  1082. }
  1083. /* 0c. If we've deferred log messages for the controller, handle them now */
  1084. flush_pending_log_callbacks();
  1085. /** 1a. Every MIN_ONION_KEY_LIFETIME seconds, rotate the onion keys,
  1086. * shut down and restart all cpuworkers, and update the directory if
  1087. * necessary.
  1088. */
  1089. if (is_server &&
  1090. get_onion_key_set_at()+MIN_ONION_KEY_LIFETIME < now) {
  1091. log_info(LD_GENERAL,"Rotating onion key.");
  1092. rotate_onion_key();
  1093. cpuworkers_rotate();
  1094. if (router_rebuild_descriptor(1)<0) {
  1095. log_info(LD_CONFIG, "Couldn't rebuild router descriptor");
  1096. }
  1097. if (advertised_server_mode() && !options->DisableNetwork)
  1098. router_upload_dir_desc_to_dirservers(0);
  1099. }
  1100. if (!options->DisableNetwork && time_to_try_getting_descriptors < now) {
  1101. update_all_descriptor_downloads(now);
  1102. update_extrainfo_downloads(now);
  1103. if (router_have_minimum_dir_info())
  1104. time_to_try_getting_descriptors = now + LAZY_DESCRIPTOR_RETRY_INTERVAL;
  1105. else
  1106. time_to_try_getting_descriptors = now + GREEDY_DESCRIPTOR_RETRY_INTERVAL;
  1107. }
  1108. if (time_to_reset_descriptor_failures < now) {
  1109. router_reset_descriptor_download_failures();
  1110. time_to_reset_descriptor_failures =
  1111. now + DESCRIPTOR_FAILURE_RESET_INTERVAL;
  1112. }
  1113. if (options->UseBridges)
  1114. fetch_bridge_descriptors(options, now);
  1115. /** 1b. Every MAX_SSL_KEY_LIFETIME_INTERNAL seconds, we change our
  1116. * TLS context. */
  1117. if (!last_rotated_x509_certificate)
  1118. last_rotated_x509_certificate = now;
  1119. if (last_rotated_x509_certificate+MAX_SSL_KEY_LIFETIME_INTERNAL < now) {
  1120. log_info(LD_GENERAL,"Rotating tls context.");
  1121. if (router_initialize_tls_context() < 0) {
  1122. log_warn(LD_BUG, "Error reinitializing TLS context");
  1123. /* XXX is it a bug here, that we just keep going? -RD */
  1124. }
  1125. last_rotated_x509_certificate = now;
  1126. /* We also make sure to rotate the TLS connections themselves if they've
  1127. * been up for too long -- but that's done via is_bad_for_new_circs in
  1128. * connection_run_housekeeping() above. */
  1129. }
  1130. if (time_to_add_entropy < now) {
  1131. if (time_to_add_entropy) {
  1132. /* We already seeded once, so don't die on failure. */
  1133. crypto_seed_rng(0);
  1134. }
  1135. /** How often do we add more entropy to OpenSSL's RNG pool? */
  1136. #define ENTROPY_INTERVAL (60*60)
  1137. time_to_add_entropy = now + ENTROPY_INTERVAL;
  1138. }
  1139. /** 1c. If we have to change the accounting interval or record
  1140. * bandwidth used in this accounting interval, do so. */
  1141. if (accounting_is_enabled(options))
  1142. accounting_run_housekeeping(now);
  1143. if (time_to_launch_reachability_tests < now &&
  1144. (authdir_mode_tests_reachability(options)) &&
  1145. !net_is_disabled()) {
  1146. time_to_launch_reachability_tests = now + REACHABILITY_TEST_INTERVAL;
  1147. /* try to determine reachability of the other Tor relays */
  1148. dirserv_test_reachability(now);
  1149. }
  1150. /** 1d. Periodically, we discount older stability information so that new
  1151. * stability info counts more, and save the stability information to disk as
  1152. * appropriate. */
  1153. if (time_to_downrate_stability < now)
  1154. time_to_downrate_stability = rep_hist_downrate_old_runs(now);
  1155. if (authdir_mode_tests_reachability(options)) {
  1156. if (time_to_save_stability < now) {
  1157. if (time_to_save_stability && rep_hist_record_mtbf_data(now, 1)<0) {
  1158. log_warn(LD_GENERAL, "Couldn't store mtbf data.");
  1159. }
  1160. #define SAVE_STABILITY_INTERVAL (30*60)
  1161. time_to_save_stability = now + SAVE_STABILITY_INTERVAL;
  1162. }
  1163. }
  1164. /* 1e. Periodically, if we're a v3 authority, we check whether our cert is
  1165. * close to expiring and warn the admin if it is. */
  1166. if (time_to_check_v3_certificate < now) {
  1167. v3_authority_check_key_expiry();
  1168. #define CHECK_V3_CERTIFICATE_INTERVAL (5*60)
  1169. time_to_check_v3_certificate = now + CHECK_V3_CERTIFICATE_INTERVAL;
  1170. }
  1171. /* 1f. Check whether our networkstatus has expired.
  1172. */
  1173. if (time_to_check_for_expired_networkstatus < now) {
  1174. networkstatus_t *ns = networkstatus_get_latest_consensus();
  1175. /*XXXX RD: This value needs to be the same as REASONABLY_LIVE_TIME in
  1176. * networkstatus_get_reasonably_live_consensus(), but that value is way
  1177. * way too high. Arma: is the bridge issue there resolved yet? -NM */
  1178. #define NS_EXPIRY_SLOP (24*60*60)
  1179. if (ns && ns->valid_until < now+NS_EXPIRY_SLOP &&
  1180. router_have_minimum_dir_info()) {
  1181. router_dir_info_changed();
  1182. }
  1183. #define CHECK_EXPIRED_NS_INTERVAL (2*60)
  1184. time_to_check_for_expired_networkstatus = now + CHECK_EXPIRED_NS_INTERVAL;
  1185. }
  1186. /* 1g. Check whether we should write statistics to disk.
  1187. */
  1188. if (time_to_write_stats_files < now) {
  1189. #define CHECK_WRITE_STATS_INTERVAL (60*60)
  1190. time_t next_time_to_write_stats_files = (time_to_write_stats_files > 0 ?
  1191. time_to_write_stats_files : now) + CHECK_WRITE_STATS_INTERVAL;
  1192. if (options->CellStatistics) {
  1193. time_t next_write =
  1194. rep_hist_buffer_stats_write(time_to_write_stats_files);
  1195. if (next_write && next_write < next_time_to_write_stats_files)
  1196. next_time_to_write_stats_files = next_write;
  1197. }
  1198. if (options->DirReqStatistics) {
  1199. time_t next_write = geoip_dirreq_stats_write(time_to_write_stats_files);
  1200. if (next_write && next_write < next_time_to_write_stats_files)
  1201. next_time_to_write_stats_files = next_write;
  1202. }
  1203. if (options->EntryStatistics) {
  1204. time_t next_write = geoip_entry_stats_write(time_to_write_stats_files);
  1205. if (next_write && next_write < next_time_to_write_stats_files)
  1206. next_time_to_write_stats_files = next_write;
  1207. }
  1208. if (options->ExitPortStatistics) {
  1209. time_t next_write = rep_hist_exit_stats_write(time_to_write_stats_files);
  1210. if (next_write && next_write < next_time_to_write_stats_files)
  1211. next_time_to_write_stats_files = next_write;
  1212. }
  1213. if (options->ConnDirectionStatistics) {
  1214. time_t next_write = rep_hist_conn_stats_write(time_to_write_stats_files);
  1215. if (next_write && next_write < next_time_to_write_stats_files)
  1216. next_time_to_write_stats_files = next_write;
  1217. }
  1218. if (options->BridgeAuthoritativeDir) {
  1219. time_t next_write = rep_hist_desc_stats_write(time_to_write_stats_files);
  1220. if (next_write && next_write < next_time_to_write_stats_files)
  1221. next_time_to_write_stats_files = next_write;
  1222. }
  1223. time_to_write_stats_files = next_time_to_write_stats_files;
  1224. }
  1225. /* 1h. Check whether we should write bridge statistics to disk.
  1226. */
  1227. if (should_record_bridge_info(options)) {
  1228. if (time_to_write_bridge_stats < now) {
  1229. if (should_init_bridge_stats) {
  1230. /* (Re-)initialize bridge statistics. */
  1231. geoip_bridge_stats_init(now);
  1232. time_to_write_bridge_stats = now + WRITE_STATS_INTERVAL;
  1233. should_init_bridge_stats = 0;
  1234. } else {
  1235. /* Possibly write bridge statistics to disk and ask when to write
  1236. * them next time. */
  1237. time_to_write_bridge_stats = geoip_bridge_stats_write(
  1238. time_to_write_bridge_stats);
  1239. }
  1240. }
  1241. } else if (!should_init_bridge_stats) {
  1242. /* Bridge mode was turned off. Ensure that stats are re-initialized
  1243. * next time bridge mode is turned on. */
  1244. should_init_bridge_stats = 1;
  1245. }
  1246. /* Remove old information from rephist and the rend cache. */
  1247. if (time_to_clean_caches < now) {
  1248. rep_history_clean(now - options->RephistTrackTime);
  1249. rend_cache_clean(now);
  1250. rend_cache_clean_v2_descs_as_dir(now);
  1251. microdesc_cache_rebuild(NULL, 0);
  1252. #define CLEAN_CACHES_INTERVAL (30*60)
  1253. time_to_clean_caches = now + CLEAN_CACHES_INTERVAL;
  1254. }
  1255. #define RETRY_DNS_INTERVAL (10*60)
  1256. /* If we're a server and initializing dns failed, retry periodically. */
  1257. if (time_to_retry_dns_init < now) {
  1258. time_to_retry_dns_init = now + RETRY_DNS_INTERVAL;
  1259. if (is_server && has_dns_init_failed())
  1260. dns_init();
  1261. }
  1262. /** 2. Periodically, we consider force-uploading our descriptor
  1263. * (if we've passed our internal checks). */
  1264. /** How often do we check whether part of our router info has changed in a
  1265. * way that would require an upload? That includes checking whether our IP
  1266. * address has changed. */
  1267. #define CHECK_DESCRIPTOR_INTERVAL (60)
  1268. /* 2b. Once per minute, regenerate and upload the descriptor if the old
  1269. * one is inaccurate. */
  1270. if (time_to_check_descriptor < now && !options->DisableNetwork) {
  1271. static int dirport_reachability_count = 0;
  1272. time_to_check_descriptor = now + CHECK_DESCRIPTOR_INTERVAL;
  1273. check_descriptor_bandwidth_changed(now);
  1274. check_descriptor_ipaddress_changed(now);
  1275. mark_my_descriptor_dirty_if_too_old(now);
  1276. consider_publishable_server(0);
  1277. /* also, check religiously for reachability, if it's within the first
  1278. * 20 minutes of our uptime. */
  1279. if (is_server &&
  1280. (can_complete_circuit || !any_predicted_circuits(now)) &&
  1281. !we_are_hibernating()) {
  1282. if (stats_n_seconds_working < TIMEOUT_UNTIL_UNREACHABILITY_COMPLAINT) {
  1283. consider_testing_reachability(1, dirport_reachability_count==0);
  1284. if (++dirport_reachability_count > 5)
  1285. dirport_reachability_count = 0;
  1286. } else if (time_to_recheck_bandwidth < now) {
  1287. /* If we haven't checked for 12 hours and our bandwidth estimate is
  1288. * low, do another bandwidth test. This is especially important for
  1289. * bridges, since they might go long periods without much use. */
  1290. const routerinfo_t *me = router_get_my_routerinfo();
  1291. if (time_to_recheck_bandwidth && me &&
  1292. me->bandwidthcapacity < me->bandwidthrate &&
  1293. me->bandwidthcapacity < 51200) {
  1294. reset_bandwidth_test();
  1295. }
  1296. #define BANDWIDTH_RECHECK_INTERVAL (12*60*60)
  1297. time_to_recheck_bandwidth = now + BANDWIDTH_RECHECK_INTERVAL;
  1298. }
  1299. }
  1300. /* If any networkstatus documents are no longer recent, we need to
  1301. * update all the descriptors' running status. */
  1302. /* purge obsolete entries */
  1303. networkstatus_v2_list_clean(now);
  1304. /* Remove dead routers. */
  1305. routerlist_remove_old_routers();
  1306. }
  1307. /* 2c. Every minute (or every second if TestingTorNetwork), check
  1308. * whether we want to download any networkstatus documents. */
  1309. /* How often do we check whether we should download network status
  1310. * documents? */
  1311. #define networkstatus_dl_check_interval(o) ((o)->TestingTorNetwork ? 1 : 60)
  1312. if (time_to_download_networkstatus < now && !options->DisableNetwork) {
  1313. time_to_download_networkstatus =
  1314. now + networkstatus_dl_check_interval(options);
  1315. update_networkstatus_downloads(now);
  1316. }
  1317. /** 2c. Let directory voting happen. */
  1318. if (authdir_mode_v3(options))
  1319. dirvote_act(options, now);
  1320. /** 3a. Every second, we examine pending circuits and prune the
  1321. * ones which have been pending for more than a few seconds.
  1322. * We do this before step 4, so it can try building more if
  1323. * it's not comfortable with the number of available circuits.
  1324. */
  1325. /* (If our circuit build timeout can ever become lower than a second (which
  1326. * it can't, currently), we should do this more often.) */
  1327. circuit_expire_building();
  1328. /** 3b. Also look at pending streams and prune the ones that 'began'
  1329. * a long time ago but haven't gotten a 'connected' yet.
  1330. * Do this before step 4, so we can put them back into pending
  1331. * state to be picked up by the new circuit.
  1332. */
  1333. connection_ap_expire_beginning();
  1334. /** 3c. And expire connections that we've held open for too long.
  1335. */
  1336. connection_expire_held_open();
  1337. /** 3d. And every 60 seconds, we relaunch listeners if any died. */
  1338. if (!net_is_disabled() && time_to_check_listeners < now) {
  1339. retry_all_listeners(NULL, NULL, 0);
  1340. time_to_check_listeners = now+60;
  1341. }
  1342. /** 4. Every second, we try a new circuit if there are no valid
  1343. * circuits. Every NewCircuitPeriod seconds, we expire circuits
  1344. * that became dirty more than MaxCircuitDirtiness seconds ago,
  1345. * and we make a new circ if there are no clean circuits.
  1346. */
  1347. have_dir_info = router_have_minimum_dir_info();
  1348. if (have_dir_info && !net_is_disabled())
  1349. circuit_build_needed_circs(now);
  1350. /* every 10 seconds, but not at the same second as other such events */
  1351. if (now % 10 == 5)
  1352. circuit_expire_old_circuits_serverside(now);
  1353. /** 5. We do housekeeping for each connection... */
  1354. connection_or_set_bad_connections(NULL, 0);
  1355. for (i=0;i<smartlist_len(connection_array);i++) {
  1356. run_connection_housekeeping(i, now);
  1357. }
  1358. if (time_to_shrink_memory < now) {
  1359. SMARTLIST_FOREACH(connection_array, connection_t *, conn, {
  1360. if (conn->outbuf)
  1361. buf_shrink(conn->outbuf);
  1362. if (conn->inbuf)
  1363. buf_shrink(conn->inbuf);
  1364. });
  1365. clean_cell_pool();
  1366. buf_shrink_freelists(0);
  1367. /** How often do we check buffers and pools for empty space that can be
  1368. * deallocated? */
  1369. #define MEM_SHRINK_INTERVAL (60)
  1370. time_to_shrink_memory = now + MEM_SHRINK_INTERVAL;
  1371. }
  1372. /** 6. And remove any marked circuits... */
  1373. circuit_close_all_marked();
  1374. /** 7. And upload service descriptors if necessary. */
  1375. if (can_complete_circuit && !net_is_disabled()) {
  1376. rend_consider_services_upload(now);
  1377. rend_consider_descriptor_republication();
  1378. }
  1379. /** 8. and blow away any connections that need to die. have to do this now,
  1380. * because if we marked a conn for close and left its socket -1, then
  1381. * we'll pass it to poll/select and bad things will happen.
  1382. */
  1383. close_closeable_connections();
  1384. /** 8b. And if anything in our state is ready to get flushed to disk, we
  1385. * flush it. */
  1386. or_state_save(now);
  1387. /** 8c. Do channel cleanup just like for connections */
  1388. channel_run_cleanup();
  1389. channel_listener_run_cleanup();
  1390. /** 9. and if we're a server, check whether our DNS is telling stories to
  1391. * us. */
  1392. if (!net_is_disabled() &&
  1393. public_server_mode(options) && time_to_check_for_correct_dns < now) {
  1394. if (!time_to_check_for_correct_dns) {
  1395. time_to_check_for_correct_dns = now + 60 + crypto_rand_int(120);
  1396. } else {
  1397. dns_launch_correctness_checks();
  1398. time_to_check_for_correct_dns = now + 12*3600 +
  1399. crypto_rand_int(12*3600);
  1400. }
  1401. }
  1402. /** 10. write bridge networkstatus file to disk */
  1403. if (options->BridgeAuthoritativeDir &&
  1404. time_to_write_bridge_status_file < now) {
  1405. networkstatus_dump_bridge_status_to_file(now);
  1406. #define BRIDGE_STATUSFILE_INTERVAL (30*60)
  1407. time_to_write_bridge_status_file = now+BRIDGE_STATUSFILE_INTERVAL;
  1408. }
  1409. /** 11. check the port forwarding app */
  1410. if (!net_is_disabled() &&
  1411. time_to_check_port_forwarding < now &&
  1412. options->PortForwarding &&
  1413. is_server) {
  1414. #define PORT_FORWARDING_CHECK_INTERVAL 5
  1415. smartlist_t *ports_to_forward = get_list_of_ports_to_forward();
  1416. if (ports_to_forward) {
  1417. tor_check_port_forwarding(options->PortForwardingHelper,
  1418. ports_to_forward,
  1419. now);
  1420. SMARTLIST_FOREACH(ports_to_forward, char *, cp, tor_free(cp));
  1421. smartlist_free(ports_to_forward);
  1422. }
  1423. time_to_check_port_forwarding = now+PORT_FORWARDING_CHECK_INTERVAL;
  1424. }
  1425. /** 11b. check pending unconfigured managed proxies */
  1426. if (!net_is_disabled() && pt_proxies_configuration_pending())
  1427. pt_configure_remaining_proxies();
  1428. /** 12. write the heartbeat message */
  1429. if (options->HeartbeatPeriod &&
  1430. time_to_next_heartbeat <= now) {
  1431. if (time_to_next_heartbeat) /* don't log the first heartbeat */
  1432. log_heartbeat(now);
  1433. time_to_next_heartbeat = now+options->HeartbeatPeriod;
  1434. }
  1435. }
  1436. /** Timer: used to invoke second_elapsed_callback() once per second. */
  1437. static periodic_timer_t *second_timer = NULL;
  1438. /** Number of libevent errors in the last second: we die if we get too many. */
  1439. static int n_libevent_errors = 0;
  1440. /** Libevent callback: invoked once every second. */
  1441. static void
  1442. second_elapsed_callback(periodic_timer_t *timer, void *arg)
  1443. {
  1444. /* XXXX This could be sensibly refactored into multiple callbacks, and we
  1445. * could use Libevent's timers for this rather than checking the current
  1446. * time against a bunch of timeouts every second. */
  1447. static time_t current_second = 0;
  1448. time_t now;
  1449. size_t bytes_written;
  1450. size_t bytes_read;
  1451. int seconds_elapsed;
  1452. const or_options_t *options = get_options();
  1453. (void)timer;
  1454. (void)arg;
  1455. n_libevent_errors = 0;
  1456. /* log_notice(LD_GENERAL, "Tick."); */
  1457. now = time(NULL);
  1458. update_approx_time(now);
  1459. /* the second has rolled over. check more stuff. */
  1460. seconds_elapsed = current_second ? (int)(now - current_second) : 0;
  1461. #ifdef USE_BUFFEREVENTS
  1462. {
  1463. uint64_t cur_read,cur_written;
  1464. connection_get_rate_limit_totals(&cur_read, &cur_written);
  1465. bytes_written = (size_t)(cur_written - stats_prev_n_written);
  1466. bytes_read = (size_t)(cur_read - stats_prev_n_read);
  1467. stats_n_bytes_read += bytes_read;
  1468. stats_n_bytes_written += bytes_written;
  1469. if (accounting_is_enabled(options) && seconds_elapsed >= 0)
  1470. accounting_add_bytes(bytes_read, bytes_written, seconds_elapsed);
  1471. stats_prev_n_written = cur_written;
  1472. stats_prev_n_read = cur_read;
  1473. }
  1474. #else
  1475. bytes_read = (size_t)(stats_n_bytes_read - stats_prev_n_read);
  1476. bytes_written = (size_t)(stats_n_bytes_written - stats_prev_n_written);
  1477. stats_prev_n_read = stats_n_bytes_read;
  1478. stats_prev_n_written = stats_n_bytes_written;
  1479. #endif
  1480. control_event_bandwidth_used((uint32_t)bytes_read,(uint32_t)bytes_written);
  1481. control_event_stream_bandwidth_used();
  1482. if (server_mode(options) &&
  1483. !net_is_disabled() &&
  1484. seconds_elapsed > 0 &&
  1485. can_complete_circuit &&
  1486. stats_n_seconds_working / TIMEOUT_UNTIL_UNREACHABILITY_COMPLAINT !=
  1487. (stats_n_seconds_working+seconds_elapsed) /
  1488. TIMEOUT_UNTIL_UNREACHABILITY_COMPLAINT) {
  1489. /* every 20 minutes, check and complain if necessary */
  1490. const routerinfo_t *me = router_get_my_routerinfo();
  1491. if (me && !check_whether_orport_reachable()) {
  1492. log_warn(LD_CONFIG,"Your server (%s:%d) has not managed to confirm that "
  1493. "its ORPort is reachable. Please check your firewalls, ports, "
  1494. "address, /etc/hosts file, etc.",
  1495. me->address, me->or_port);
  1496. control_event_server_status(LOG_WARN,
  1497. "REACHABILITY_FAILED ORADDRESS=%s:%d",
  1498. me->address, me->or_port);
  1499. }
  1500. if (me && !check_whether_dirport_reachable()) {
  1501. log_warn(LD_CONFIG,
  1502. "Your server (%s:%d) has not managed to confirm that its "
  1503. "DirPort is reachable. Please check your firewalls, ports, "
  1504. "address, /etc/hosts file, etc.",
  1505. me->address, me->dir_port);
  1506. control_event_server_status(LOG_WARN,
  1507. "REACHABILITY_FAILED DIRADDRESS=%s:%d",
  1508. me->address, me->dir_port);
  1509. }
  1510. }
  1511. /** If more than this many seconds have elapsed, probably the clock
  1512. * jumped: doesn't count. */
  1513. #define NUM_JUMPED_SECONDS_BEFORE_WARN 100
  1514. if (seconds_elapsed < -NUM_JUMPED_SECONDS_BEFORE_WARN ||
  1515. seconds_elapsed >= NUM_JUMPED_SECONDS_BEFORE_WARN) {
  1516. circuit_note_clock_jumped(seconds_elapsed);
  1517. /* XXX if the time jumps *back* many months, do our events in
  1518. * run_scheduled_events() recover? I don't think they do. -RD */
  1519. } else if (seconds_elapsed > 0)
  1520. stats_n_seconds_working += seconds_elapsed;
  1521. run_scheduled_events(now);
  1522. current_second = now; /* remember which second it is, for next time */
  1523. }
  1524. #ifndef USE_BUFFEREVENTS
  1525. /** Timer: used to invoke refill_callback(). */
  1526. static periodic_timer_t *refill_timer = NULL;
  1527. /** Libevent callback: invoked periodically to refill token buckets
  1528. * and count r/w bytes. It is only used when bufferevents are disabled. */
  1529. static void
  1530. refill_callback(periodic_timer_t *timer, void *arg)
  1531. {
  1532. static struct timeval current_millisecond;
  1533. struct timeval now;
  1534. size_t bytes_written;
  1535. size_t bytes_read;
  1536. int milliseconds_elapsed = 0;
  1537. int seconds_rolled_over = 0;
  1538. const or_options_t *options = get_options();
  1539. (void)timer;
  1540. (void)arg;
  1541. tor_gettimeofday(&now);
  1542. /* If this is our first time, no time has passed. */
  1543. if (current_millisecond.tv_sec) {
  1544. long mdiff = tv_mdiff(&current_millisecond, &now);
  1545. if (mdiff > INT_MAX)
  1546. mdiff = INT_MAX;
  1547. milliseconds_elapsed = (int)mdiff;
  1548. seconds_rolled_over = (int)(now.tv_sec - current_millisecond.tv_sec);
  1549. }
  1550. bytes_written = stats_prev_global_write_bucket - global_write_bucket;
  1551. bytes_read = stats_prev_global_read_bucket - global_read_bucket;
  1552. stats_n_bytes_read += bytes_read;
  1553. stats_n_bytes_written += bytes_written;
  1554. if (accounting_is_enabled(options) && milliseconds_elapsed >= 0)
  1555. accounting_add_bytes(bytes_read, bytes_written, seconds_rolled_over);
  1556. if (milliseconds_elapsed > 0)
  1557. connection_bucket_refill(milliseconds_elapsed, now.tv_sec);
  1558. stats_prev_global_read_bucket = global_read_bucket;
  1559. stats_prev_global_write_bucket = global_write_bucket;
  1560. current_millisecond = now; /* remember what time it is, for next time */
  1561. }
  1562. #endif
  1563. #ifndef _WIN32
  1564. /** Called when a possibly ignorable libevent error occurs; ensures that we
  1565. * don't get into an infinite loop by ignoring too many errors from
  1566. * libevent. */
  1567. static int
  1568. got_libevent_error(void)
  1569. {
  1570. if (++n_libevent_errors > 8) {
  1571. log_err(LD_NET, "Too many libevent errors in one second; dying");
  1572. return -1;
  1573. }
  1574. return 0;
  1575. }
  1576. #endif
  1577. #define UPTIME_CUTOFF_FOR_NEW_BANDWIDTH_TEST (6*60*60)
  1578. /** Called when our IP address seems to have changed. <b>at_interface</b>
  1579. * should be true if we detected a change in our interface, and false if we
  1580. * detected a change in our published address. */
  1581. void
  1582. ip_address_changed(int at_interface)
  1583. {
  1584. int server = server_mode(get_options());
  1585. if (at_interface) {
  1586. if (! server) {
  1587. /* Okay, change our keys. */
  1588. if (init_keys()<0)
  1589. log_warn(LD_GENERAL, "Unable to rotate keys after IP change!");
  1590. }
  1591. } else {
  1592. if (server) {
  1593. if (stats_n_seconds_working > UPTIME_CUTOFF_FOR_NEW_BANDWIDTH_TEST)
  1594. reset_bandwidth_test();
  1595. stats_n_seconds_working = 0;
  1596. router_reset_reachability();
  1597. mark_my_descriptor_dirty("IP address changed");
  1598. }
  1599. }
  1600. dns_servers_relaunch_checks();
  1601. }
  1602. /** Forget what we've learned about the correctness of our DNS servers, and
  1603. * start learning again. */
  1604. void
  1605. dns_servers_relaunch_checks(void)
  1606. {
  1607. if (server_mode(get_options())) {
  1608. dns_reset_correctness_checks();
  1609. time_to_check_for_correct_dns = 0;
  1610. }
  1611. }
  1612. /** Called when we get a SIGHUP: reload configuration files and keys,
  1613. * retry all connections, and so on. */
  1614. static int
  1615. do_hup(void)
  1616. {
  1617. const or_options_t *options = get_options();
  1618. #ifdef USE_DMALLOC
  1619. dmalloc_log_stats();
  1620. dmalloc_log_changed(0, 1, 0, 0);
  1621. #endif
  1622. log_notice(LD_GENERAL,"Received reload signal (hup). Reloading config and "
  1623. "resetting internal state.");
  1624. if (accounting_is_enabled(options))
  1625. accounting_record_bandwidth_usage(time(NULL), get_or_state());
  1626. router_reset_warnings();
  1627. routerlist_reset_warnings();
  1628. /* first, reload config variables, in case they've changed */
  1629. if (options->ReloadTorrcOnSIGHUP) {
  1630. /* no need to provide argc/v, they've been cached in init_from_config */
  1631. if (options_init_from_torrc(0, NULL) < 0) {
  1632. log_err(LD_CONFIG,"Reading config failed--see warnings above. "
  1633. "For usage, try -h.");
  1634. return -1;
  1635. }
  1636. options = get_options(); /* they have changed now */
  1637. } else {
  1638. char *msg = NULL;
  1639. log_notice(LD_GENERAL, "Not reloading config file: the controller told "
  1640. "us not to.");
  1641. /* Make stuff get rescanned, reloaded, etc. */
  1642. if (set_options((or_options_t*)options, &msg) < 0) {
  1643. if (!msg)
  1644. msg = tor_strdup("Unknown error");
  1645. log_warn(LD_GENERAL, "Unable to re-set previous options: %s", msg);
  1646. tor_free(msg);
  1647. }
  1648. }
  1649. if (authdir_mode_handles_descs(options, -1)) {
  1650. /* reload the approved-routers file */
  1651. if (dirserv_load_fingerprint_file() < 0) {
  1652. /* warnings are logged from dirserv_load_fingerprint_file() directly */
  1653. log_info(LD_GENERAL, "Error reloading fingerprints. "
  1654. "Continuing with old list.");
  1655. }
  1656. }
  1657. /* Rotate away from the old dirty circuits. This has to be done
  1658. * after we've read the new options, but before we start using
  1659. * circuits for directory fetches. */
  1660. circuit_mark_all_dirty_circs_as_unusable();
  1661. /* retry appropriate downloads */
  1662. router_reset_status_download_failures();
  1663. router_reset_descriptor_download_failures();
  1664. if (!options->DisableNetwork)
  1665. update_networkstatus_downloads(time(NULL));
  1666. /* We'll retry routerstatus downloads in about 10 seconds; no need to
  1667. * force a retry there. */
  1668. if (server_mode(options)) {
  1669. /* Restart cpuworker and dnsworker processes, so they get up-to-date
  1670. * configuration options. */
  1671. cpuworkers_rotate();
  1672. dns_reset();
  1673. }
  1674. return 0;
  1675. }
  1676. /** Tor main loop. */
  1677. /* static */ int
  1678. do_main_loop(void)
  1679. {
  1680. int loop_result;
  1681. time_t now;
  1682. /* initialize dns resolve map, spawn workers if needed */
  1683. if (dns_init() < 0) {
  1684. if (get_options()->ServerDNSAllowBrokenConfig)
  1685. log_warn(LD_GENERAL, "Couldn't set up any working nameservers. "
  1686. "Network not up yet? Will try again soon.");
  1687. else {
  1688. log_err(LD_GENERAL,"Error initializing dns subsystem; exiting. To "
  1689. "retry instead, set the ServerDNSAllowBrokenResolvConf option.");
  1690. }
  1691. }
  1692. #ifdef USE_BUFFEREVENTS
  1693. log_warn(LD_GENERAL, "Tor was compiled with the --enable-bufferevents "
  1694. "option. This is still experimental, and might cause strange "
  1695. "bugs. If you want a more stable Tor, be sure to build without "
  1696. "--enable-bufferevents.");
  1697. #endif
  1698. handle_signals(1);
  1699. /* load the private keys, if we're supposed to have them, and set up the
  1700. * TLS context. */
  1701. if (! client_identity_key_is_set()) {
  1702. if (init_keys() < 0) {
  1703. log_err(LD_BUG,"Error initializing keys; exiting");
  1704. return -1;
  1705. }
  1706. }
  1707. /* Set up the packed_cell_t memory pool. */
  1708. init_cell_pool();
  1709. /* Set up our buckets */
  1710. connection_bucket_init();
  1711. #ifndef USE_BUFFEREVENTS
  1712. stats_prev_global_read_bucket = global_read_bucket;
  1713. stats_prev_global_write_bucket = global_write_bucket;
  1714. #endif
  1715. /* initialize the bootstrap status events to know we're starting up */
  1716. control_event_bootstrap(BOOTSTRAP_STATUS_STARTING, 0);
  1717. if (trusted_dirs_reload_certs()) {
  1718. log_warn(LD_DIR,
  1719. "Couldn't load all cached v3 certificates. Starting anyway.");
  1720. }
  1721. if (router_reload_v2_networkstatus()) {
  1722. return -1;
  1723. }
  1724. if (router_reload_consensus_networkstatus()) {
  1725. return -1;
  1726. }
  1727. /* load the routers file, or assign the defaults. */
  1728. if (router_reload_router_list()) {
  1729. return -1;
  1730. }
  1731. /* load the networkstatuses. (This launches a download for new routers as
  1732. * appropriate.)
  1733. */
  1734. now = time(NULL);
  1735. directory_info_has_arrived(now, 1);
  1736. if (server_mode(get_options())) {
  1737. /* launch cpuworkers. Need to do this *after* we've read the onion key. */
  1738. cpu_init();
  1739. }
  1740. /* set up once-a-second callback. */
  1741. if (! second_timer) {
  1742. struct timeval one_second;
  1743. one_second.tv_sec = 1;
  1744. one_second.tv_usec = 0;
  1745. second_timer = periodic_timer_new(tor_libevent_get_base(),
  1746. &one_second,
  1747. second_elapsed_callback,
  1748. NULL);
  1749. tor_assert(second_timer);
  1750. }
  1751. #ifndef USE_BUFFEREVENTS
  1752. if (!refill_timer) {
  1753. struct timeval refill_interval;
  1754. int msecs = get_options()->TokenBucketRefillInterval;
  1755. refill_interval.tv_sec = msecs/1000;
  1756. refill_interval.tv_usec = (msecs%1000)*1000;
  1757. refill_timer = periodic_timer_new(tor_libevent_get_base(),
  1758. &refill_interval,
  1759. refill_callback,
  1760. NULL);
  1761. tor_assert(refill_timer);
  1762. }
  1763. #endif
  1764. for (;;) {
  1765. if (nt_service_is_stopping())
  1766. return 0;
  1767. #ifndef _WIN32
  1768. /* Make it easier to tell whether libevent failure is our fault or not. */
  1769. errno = 0;
  1770. #endif
  1771. /* All active linked conns should get their read events activated. */
  1772. SMARTLIST_FOREACH(active_linked_connection_lst, connection_t *, conn,
  1773. event_active(conn->read_event, EV_READ, 1));
  1774. called_loop_once = smartlist_len(active_linked_connection_lst) ? 1 : 0;
  1775. update_approx_time(time(NULL));
  1776. /* poll until we have an event, or the second ends, or until we have
  1777. * some active linked connections to trigger events for. */
  1778. loop_result = event_base_loop(tor_libevent_get_base(),
  1779. called_loop_once ? EVLOOP_ONCE : 0);
  1780. /* let catch() handle things like ^c, and otherwise don't worry about it */
  1781. if (loop_result < 0) {
  1782. int e = tor_socket_errno(-1);
  1783. /* let the program survive things like ^z */
  1784. if (e != EINTR && !ERRNO_IS_EINPROGRESS(e)) {
  1785. log_err(LD_NET,"libevent call with %s failed: %s [%d]",
  1786. tor_libevent_get_method(), tor_socket_strerror(e), e);
  1787. return -1;
  1788. #ifndef _WIN32
  1789. } else if (e == EINVAL) {
  1790. log_warn(LD_NET, "EINVAL from libevent: should you upgrade libevent?");
  1791. if (got_libevent_error())
  1792. return -1;
  1793. #endif
  1794. } else {
  1795. if (ERRNO_IS_EINPROGRESS(e))
  1796. log_warn(LD_BUG,
  1797. "libevent call returned EINPROGRESS? Please report.");
  1798. log_debug(LD_NET,"libevent call interrupted.");
  1799. /* You can't trust the results of this poll(). Go back to the
  1800. * top of the big for loop. */
  1801. continue;
  1802. }
  1803. }
  1804. }
  1805. }
  1806. #ifndef _WIN32 /* Only called when we're willing to use signals */
  1807. /** Libevent callback: invoked when we get a signal.
  1808. */
  1809. static void
  1810. signal_callback(int fd, short events, void *arg)
  1811. {
  1812. uintptr_t sig = (uintptr_t)arg;
  1813. (void)fd;
  1814. (void)events;
  1815. process_signal(sig);
  1816. }
  1817. #endif
  1818. /** Do the work of acting on a signal received in <b>sig</b> */
  1819. void
  1820. process_signal(uintptr_t sig)
  1821. {
  1822. switch (sig)
  1823. {
  1824. case SIGTERM:
  1825. log_notice(LD_GENERAL,"Catching signal TERM, exiting cleanly.");
  1826. tor_cleanup();
  1827. exit(0);
  1828. break;
  1829. case SIGINT:
  1830. if (!server_mode(get_options())) { /* do it now */
  1831. log_notice(LD_GENERAL,"Interrupt: exiting cleanly.");
  1832. tor_cleanup();
  1833. exit(0);
  1834. }
  1835. hibernate_begin_shutdown();
  1836. break;
  1837. #ifdef SIGPIPE
  1838. case SIGPIPE:
  1839. log_debug(LD_GENERAL,"Caught SIGPIPE. Ignoring.");
  1840. break;
  1841. #endif
  1842. case SIGUSR1:
  1843. /* prefer to log it at INFO, but make sure we always see it */
  1844. dumpstats(get_min_log_level()<LOG_INFO ? get_min_log_level() : LOG_INFO);
  1845. control_event_signal(sig);
  1846. break;
  1847. case SIGUSR2:
  1848. switch_logs_debug();
  1849. log_debug(LD_GENERAL,"Caught USR2, going to loglevel debug. "
  1850. "Send HUP to change back.");
  1851. control_event_signal(sig);
  1852. break;
  1853. case SIGHUP:
  1854. if (do_hup() < 0) {
  1855. log_warn(LD_CONFIG,"Restart failed (config error?). Exiting.");
  1856. tor_cleanup();
  1857. exit(1);
  1858. }
  1859. control_event_signal(sig);
  1860. break;
  1861. #ifdef SIGCHLD
  1862. case SIGCHLD:
  1863. while (waitpid(-1,NULL,WNOHANG) > 0) ; /* keep reaping until no more
  1864. zombies */
  1865. break;
  1866. #endif
  1867. case SIGNEWNYM: {
  1868. time_t now = time(NULL);
  1869. if (time_of_last_signewnym + MAX_SIGNEWNYM_RATE > now) {
  1870. signewnym_is_pending = 1;
  1871. log_notice(LD_CONTROL,
  1872. "Rate limiting NEWNYM request: delaying by %d second(s)",
  1873. (int)(MAX_SIGNEWNYM_RATE+time_of_last_signewnym-now));
  1874. } else {
  1875. signewnym_impl(now);
  1876. }
  1877. break;
  1878. }
  1879. case SIGCLEARDNSCACHE:
  1880. addressmap_clear_transient();
  1881. control_event_signal(sig);
  1882. break;
  1883. }
  1884. }
  1885. /** Returns Tor's uptime. */
  1886. long
  1887. get_uptime(void)
  1888. {
  1889. return stats_n_seconds_working;
  1890. }
  1891. extern uint64_t rephist_total_alloc;
  1892. extern uint32_t rephist_total_num;
  1893. /**
  1894. * Write current memory usage information to the log.
  1895. */
  1896. static void
  1897. dumpmemusage(int severity)
  1898. {
  1899. connection_dump_buffer_mem_stats(severity);
  1900. tor_log(severity, LD_GENERAL, "In rephist: "U64_FORMAT" used by %d Tors.",
  1901. U64_PRINTF_ARG(rephist_total_alloc), rephist_total_num);
  1902. dump_routerlist_mem_usage(severity);
  1903. dump_cell_pool_usage(severity);
  1904. dump_dns_mem_usage(severity);
  1905. buf_dump_freelist_sizes(severity);
  1906. tor_log_mallinfo(severity);
  1907. }
  1908. /** Write all statistics to the log, with log level <b>severity</b>. Called
  1909. * in response to a SIGUSR1. */
  1910. static void
  1911. dumpstats(int severity)
  1912. {
  1913. time_t now = time(NULL);
  1914. time_t elapsed;
  1915. size_t rbuf_cap, wbuf_cap, rbuf_len, wbuf_len;
  1916. tor_log(severity, LD_GENERAL, "Dumping stats:");
  1917. SMARTLIST_FOREACH_BEGIN(connection_array, connection_t *, conn) {
  1918. int i = conn_sl_idx;
  1919. tor_log(severity, LD_GENERAL,
  1920. "Conn %d (socket %d) type %d (%s), state %d (%s), created %d secs ago",
  1921. i, (int)conn->s, conn->type, conn_type_to_string(conn->type),
  1922. conn->state, conn_state_to_string(conn->type, conn->state),
  1923. (int)(now - conn->timestamp_created));
  1924. if (!connection_is_listener(conn)) {
  1925. tor_log(severity,LD_GENERAL,
  1926. "Conn %d is to %s:%d.", i,
  1927. safe_str_client(conn->address),
  1928. conn->port);
  1929. tor_log(severity,LD_GENERAL,
  1930. "Conn %d: %d bytes waiting on inbuf (len %d, last read %d secs ago)",
  1931. i,
  1932. (int)connection_get_inbuf_len(conn),
  1933. (int)buf_allocation(conn->inbuf),
  1934. (int)(now - conn->timestamp_lastread));
  1935. tor_log(severity,LD_GENERAL,
  1936. "Conn %d: %d bytes waiting on outbuf "
  1937. "(len %d, last written %d secs ago)",i,
  1938. (int)connection_get_outbuf_len(conn),
  1939. (int)buf_allocation(conn->outbuf),
  1940. (int)(now - conn->timestamp_lastwritten));
  1941. if (conn->type == CONN_TYPE_OR) {
  1942. or_connection_t *or_conn = TO_OR_CONN(conn);
  1943. if (or_conn->tls) {
  1944. tor_tls_get_buffer_sizes(or_conn->tls, &rbuf_cap, &rbuf_len,
  1945. &wbuf_cap, &wbuf_len);
  1946. tor_log(severity, LD_GENERAL,
  1947. "Conn %d: %d/%d bytes used on OpenSSL read buffer; "
  1948. "%d/%d bytes used on write buffer.",
  1949. i, (int)rbuf_len, (int)rbuf_cap, (int)wbuf_len, (int)wbuf_cap);
  1950. }
  1951. }
  1952. }
  1953. circuit_dump_by_conn(conn, severity); /* dump info about all the circuits
  1954. * using this conn */
  1955. } SMARTLIST_FOREACH_END(conn);
  1956. channel_dumpstats(severity);
  1957. channel_listener_dumpstats(severity);
  1958. tor_log(severity, LD_NET,
  1959. "Cells processed: "U64_FORMAT" padding\n"
  1960. " "U64_FORMAT" create\n"
  1961. " "U64_FORMAT" created\n"
  1962. " "U64_FORMAT" relay\n"
  1963. " ("U64_FORMAT" relayed)\n"
  1964. " ("U64_FORMAT" delivered)\n"
  1965. " "U64_FORMAT" destroy",
  1966. U64_PRINTF_ARG(stats_n_padding_cells_processed),
  1967. U64_PRINTF_ARG(stats_n_create_cells_processed),
  1968. U64_PRINTF_ARG(stats_n_created_cells_processed),
  1969. U64_PRINTF_ARG(stats_n_relay_cells_processed),
  1970. U64_PRINTF_ARG(stats_n_relay_cells_relayed),
  1971. U64_PRINTF_ARG(stats_n_relay_cells_delivered),
  1972. U64_PRINTF_ARG(stats_n_destroy_cells_processed));
  1973. if (stats_n_data_cells_packaged)
  1974. tor_log(severity,LD_NET,"Average packaged cell fullness: %2.3f%%",
  1975. 100*(U64_TO_DBL(stats_n_data_bytes_packaged) /
  1976. U64_TO_DBL(stats_n_data_cells_packaged*RELAY_PAYLOAD_SIZE)) );
  1977. if (stats_n_data_cells_received)
  1978. tor_log(severity,LD_NET,"Average delivered cell fullness: %2.3f%%",
  1979. 100*(U64_TO_DBL(stats_n_data_bytes_received) /
  1980. U64_TO_DBL(stats_n_data_cells_received*RELAY_PAYLOAD_SIZE)) );
  1981. cpuworker_log_onionskin_overhead(severity, ONION_HANDSHAKE_TYPE_TAP, "TAP");
  1982. cpuworker_log_onionskin_overhead(severity, ONION_HANDSHAKE_TYPE_NTOR,"ntor");
  1983. if (now - time_of_process_start >= 0)
  1984. elapsed = now - time_of_process_start;
  1985. else
  1986. elapsed = 0;
  1987. if (elapsed) {
  1988. tor_log(severity, LD_NET,
  1989. "Average bandwidth: "U64_FORMAT"/%d = %d bytes/sec reading",
  1990. U64_PRINTF_ARG(stats_n_bytes_read),
  1991. (int)elapsed,
  1992. (int) (stats_n_bytes_read/elapsed));
  1993. tor_log(severity, LD_NET,
  1994. "Average bandwidth: "U64_FORMAT"/%d = %d bytes/sec writing",
  1995. U64_PRINTF_ARG(stats_n_bytes_written),
  1996. (int)elapsed,
  1997. (int) (stats_n_bytes_written/elapsed));
  1998. }
  1999. tor_log(severity, LD_NET, "--------------- Dumping memory information:");
  2000. dumpmemusage(severity);
  2001. rep_hist_dump_stats(now,severity);
  2002. rend_service_dump_stats(severity);
  2003. dump_pk_ops(severity);
  2004. dump_distinct_digest_count(severity);
  2005. }
  2006. /** Called by exit() as we shut down the process.
  2007. */
  2008. static void
  2009. exit_function(void)
  2010. {
  2011. /* NOTE: If we ever daemonize, this gets called immediately. That's
  2012. * okay for now, because we only use this on Windows. */
  2013. #ifdef _WIN32
  2014. WSACleanup();
  2015. #endif
  2016. }
  2017. /** Set up the signal handlers for either parent or child. */
  2018. void
  2019. handle_signals(int is_parent)
  2020. {
  2021. #ifndef _WIN32 /* do signal stuff only on Unix */
  2022. int i;
  2023. static const int signals[] = {
  2024. SIGINT, /* do a controlled slow shutdown */
  2025. SIGTERM, /* to terminate now */
  2026. SIGPIPE, /* otherwise SIGPIPE kills us */
  2027. SIGUSR1, /* dump stats */
  2028. SIGUSR2, /* go to loglevel debug */
  2029. SIGHUP, /* to reload config, retry conns, etc */
  2030. #ifdef SIGXFSZ
  2031. SIGXFSZ, /* handle file-too-big resource exhaustion */
  2032. #endif
  2033. SIGCHLD, /* handle dns/cpu workers that exit */
  2034. -1 };
  2035. static struct event *signal_events[16]; /* bigger than it has to be. */
  2036. if (is_parent) {
  2037. for (i = 0; signals[i] >= 0; ++i) {
  2038. signal_events[i] = tor_evsignal_new(
  2039. tor_libevent_get_base(), signals[i], signal_callback,
  2040. (void*)(uintptr_t)signals[i]);
  2041. if (event_add(signal_events[i], NULL))
  2042. log_warn(LD_BUG, "Error from libevent when adding event for signal %d",
  2043. signals[i]);
  2044. }
  2045. } else {
  2046. struct sigaction action;
  2047. action.sa_flags = 0;
  2048. sigemptyset(&action.sa_mask);
  2049. action.sa_handler = SIG_IGN;
  2050. sigaction(SIGINT, &action, NULL);
  2051. sigaction(SIGTERM, &action, NULL);
  2052. sigaction(SIGPIPE, &action, NULL);
  2053. sigaction(SIGUSR1, &action, NULL);
  2054. sigaction(SIGUSR2, &action, NULL);
  2055. sigaction(SIGHUP, &action, NULL);
  2056. #ifdef SIGXFSZ
  2057. sigaction(SIGXFSZ, &action, NULL);
  2058. #endif
  2059. }
  2060. #else /* MS windows */
  2061. (void)is_parent;
  2062. #endif /* signal stuff */
  2063. }
  2064. /** Main entry point for the Tor command-line client.
  2065. */
  2066. /* static */ int
  2067. tor_init(int argc, char *argv[])
  2068. {
  2069. char buf[256];
  2070. int i, quiet = 0;
  2071. time_of_process_start = time(NULL);
  2072. if (!connection_array)
  2073. connection_array = smartlist_new();
  2074. if (!closeable_connection_lst)
  2075. closeable_connection_lst = smartlist_new();
  2076. if (!active_linked_connection_lst)
  2077. active_linked_connection_lst = smartlist_new();
  2078. /* Have the log set up with our application name. */
  2079. tor_snprintf(buf, sizeof(buf), "Tor %s", get_version());
  2080. log_set_application_name(buf);
  2081. /* Initialize the history structures. */
  2082. rep_hist_init();
  2083. /* Initialize the service cache. */
  2084. rend_cache_init();
  2085. addressmap_init(); /* Init the client dns cache. Do it always, since it's
  2086. * cheap. */
  2087. /* We search for the "quiet" option first, since it decides whether we
  2088. * will log anything at all to the command line. */
  2089. for (i=1;i<argc;++i) {
  2090. if (!strcmp(argv[i], "--hush"))
  2091. quiet = 1;
  2092. if (!strcmp(argv[i], "--quiet"))
  2093. quiet = 2;
  2094. /* --version implies --quiet */
  2095. if (!strcmp(argv[i], "--version"))
  2096. quiet = 2;
  2097. }
  2098. /* give it somewhere to log to initially */
  2099. switch (quiet) {
  2100. case 2:
  2101. /* no initial logging */
  2102. break;
  2103. case 1:
  2104. add_temp_log(LOG_WARN);
  2105. break;
  2106. default:
  2107. add_temp_log(LOG_NOTICE);
  2108. }
  2109. quiet_level = quiet;
  2110. {
  2111. const char *version = get_version();
  2112. const char *bev_str =
  2113. #ifdef USE_BUFFEREVENTS
  2114. "(with bufferevents) ";
  2115. #else
  2116. "";
  2117. #endif
  2118. log_notice(LD_GENERAL, "Tor v%s %srunning on %s with Libevent %s "
  2119. "and OpenSSL %s.", version, bev_str,
  2120. get_uname(),
  2121. tor_libevent_get_version_str(),
  2122. crypto_openssl_get_version_str());
  2123. log_notice(LD_GENERAL, "Tor can't help you if you use it wrong! "
  2124. "Learn how to be safe at "
  2125. "https://www.torproject.org/download/download#warning");
  2126. if (strstr(version, "alpha") || strstr(version, "beta"))
  2127. log_notice(LD_GENERAL, "This version is not a stable Tor release. "
  2128. "Expect more bugs than usual.");
  2129. }
  2130. #ifdef NON_ANONYMOUS_MODE_ENABLED
  2131. log_warn(LD_GENERAL, "This copy of Tor was compiled to run in a "
  2132. "non-anonymous mode. It will provide NO ANONYMITY.");
  2133. #endif
  2134. if (network_init()<0) {
  2135. log_err(LD_BUG,"Error initializing network; exiting.");
  2136. return -1;
  2137. }
  2138. atexit(exit_function);
  2139. if (options_init_from_torrc(argc,argv) < 0) {
  2140. log_err(LD_CONFIG,"Reading config failed--see warnings above.");
  2141. return -1;
  2142. }
  2143. #ifndef _WIN32
  2144. if (geteuid()==0)
  2145. log_warn(LD_GENERAL,"You are running Tor as root. You don't need to, "
  2146. "and you probably shouldn't.");
  2147. #endif
  2148. if (crypto_global_init(get_options()->HardwareAccel,
  2149. get_options()->AccelName,
  2150. get_options()->AccelDir)) {
  2151. log_err(LD_BUG, "Unable to initialize OpenSSL. Exiting.");
  2152. return -1;
  2153. }
  2154. stream_choice_seed_weak_rng();
  2155. return 0;
  2156. }
  2157. /** A lockfile structure, used to prevent two Tors from messing with the
  2158. * data directory at once. If this variable is non-NULL, we're holding
  2159. * the lockfile. */
  2160. static tor_lockfile_t *lockfile = NULL;
  2161. /** Try to grab the lock file described in <b>options</b>, if we do not
  2162. * already have it. If <b>err_if_locked</b> is true, warn if somebody else is
  2163. * holding the lock, and exit if we can't get it after waiting. Otherwise,
  2164. * return -1 if we can't get the lockfile. Return 0 on success.
  2165. */
  2166. int
  2167. try_locking(const or_options_t *options, int err_if_locked)
  2168. {
  2169. if (lockfile)
  2170. return 0;
  2171. else {
  2172. char *fname = options_get_datadir_fname2_suffix(options, "lock",NULL,NULL);
  2173. int already_locked = 0;
  2174. tor_lockfile_t *lf = tor_lockfile_lock(fname, 0, &already_locked);
  2175. tor_free(fname);
  2176. if (!lf) {
  2177. if (err_if_locked && already_locked) {
  2178. int r;
  2179. log_warn(LD_GENERAL, "It looks like another Tor process is running "
  2180. "with the same data directory. Waiting 5 seconds to see "
  2181. "if it goes away.");
  2182. #ifndef _WIN32
  2183. sleep(5);
  2184. #else
  2185. Sleep(5000);
  2186. #endif
  2187. r = try_locking(options, 0);
  2188. if (r<0) {
  2189. log_err(LD_GENERAL, "No, it's still there. Exiting.");
  2190. exit(0);
  2191. }
  2192. return r;
  2193. }
  2194. return -1;
  2195. }
  2196. lockfile = lf;
  2197. return 0;
  2198. }
  2199. }
  2200. /** Return true iff we've successfully acquired the lock file. */
  2201. int
  2202. have_lockfile(void)
  2203. {
  2204. return lockfile != NULL;
  2205. }
  2206. /** If we have successfully acquired the lock file, release it. */
  2207. void
  2208. release_lockfile(void)
  2209. {
  2210. if (lockfile) {
  2211. tor_lockfile_unlock(lockfile);
  2212. lockfile = NULL;
  2213. }
  2214. }
  2215. /** Free all memory that we might have allocated somewhere.
  2216. * If <b>postfork</b>, we are a worker process and we want to free
  2217. * only the parts of memory that we won't touch. If !<b>postfork</b>,
  2218. * Tor is shutting down and we should free everything.
  2219. *
  2220. * Helps us find the real leaks with dmalloc and the like. Also valgrind
  2221. * should then report 0 reachable in its leak report (in an ideal world --
  2222. * in practice libevent, SSL, libc etc never quite free everything). */
  2223. void
  2224. tor_free_all(int postfork)
  2225. {
  2226. if (!postfork) {
  2227. evdns_shutdown(1);
  2228. }
  2229. geoip_free_all();
  2230. dirvote_free_all();
  2231. routerlist_free_all();
  2232. networkstatus_free_all();
  2233. addressmap_free_all();
  2234. dirserv_free_all();
  2235. rend_service_free_all();
  2236. rend_cache_free_all();
  2237. rend_service_authorization_free_all();
  2238. rep_hist_free_all();
  2239. dns_free_all();
  2240. clear_pending_onions();
  2241. circuit_free_all();
  2242. entry_guards_free_all();
  2243. pt_free_all();
  2244. channel_tls_free_all();
  2245. channel_free_all();
  2246. connection_free_all();
  2247. buf_shrink_freelists(1);
  2248. memarea_clear_freelist();
  2249. nodelist_free_all();
  2250. microdesc_free_all();
  2251. if (!postfork) {
  2252. config_free_all();
  2253. or_state_free_all();
  2254. router_free_all();
  2255. policies_free_all();
  2256. }
  2257. free_cell_pool();
  2258. if (!postfork) {
  2259. tor_tls_free_all();
  2260. }
  2261. /* stuff in main.c */
  2262. smartlist_free(connection_array);
  2263. smartlist_free(closeable_connection_lst);
  2264. smartlist_free(active_linked_connection_lst);
  2265. periodic_timer_free(second_timer);
  2266. #ifndef USE_BUFFEREVENTS
  2267. periodic_timer_free(refill_timer);
  2268. #endif
  2269. if (!postfork) {
  2270. release_lockfile();
  2271. }
  2272. /* Stuff in util.c and address.c*/
  2273. if (!postfork) {
  2274. escaped(NULL);
  2275. esc_router_info(NULL);
  2276. logs_free_all(); /* free log strings. do this last so logs keep working. */
  2277. }
  2278. }
  2279. /** Do whatever cleanup is necessary before shutting Tor down. */
  2280. void
  2281. tor_cleanup(void)
  2282. {
  2283. const or_options_t *options = get_options();
  2284. if (options->command == CMD_RUN_TOR) {
  2285. time_t now = time(NULL);
  2286. /* Remove our pid file. We don't care if there was an error when we
  2287. * unlink, nothing we could do about it anyways. */
  2288. if (options->PidFile)
  2289. unlink(options->PidFile);
  2290. if (options->ControlPortWriteToFile)
  2291. unlink(options->ControlPortWriteToFile);
  2292. if (accounting_is_enabled(options))
  2293. accounting_record_bandwidth_usage(now, get_or_state());
  2294. or_state_mark_dirty(get_or_state(), 0); /* force an immediate save. */
  2295. or_state_save(now);
  2296. if (authdir_mode_tests_reachability(options))
  2297. rep_hist_record_mtbf_data(now, 0);
  2298. }
  2299. #ifdef USE_DMALLOC
  2300. dmalloc_log_stats();
  2301. #endif
  2302. tor_free_all(0); /* We could move tor_free_all back into the ifdef below
  2303. later, if it makes shutdown unacceptably slow. But for
  2304. now, leave it here: it's helped us catch bugs in the
  2305. past. */
  2306. crypto_global_cleanup();
  2307. #ifdef USE_DMALLOC
  2308. dmalloc_log_unfreed();
  2309. dmalloc_shutdown();
  2310. #endif
  2311. }
  2312. /** Read/create keys as needed, and echo our fingerprint to stdout. */
  2313. /* static */ int
  2314. do_list_fingerprint(void)
  2315. {
  2316. char buf[FINGERPRINT_LEN+1];
  2317. crypto_pk_t *k;
  2318. const char *nickname = get_options()->Nickname;
  2319. if (!server_mode(get_options())) {
  2320. log_err(LD_GENERAL,
  2321. "Clients don't have long-term identity keys. Exiting.\n");
  2322. return -1;
  2323. }
  2324. tor_assert(nickname);
  2325. if (init_keys() < 0) {
  2326. log_err(LD_BUG,"Error initializing keys; can't display fingerprint");
  2327. return -1;
  2328. }
  2329. if (!(k = get_server_identity_key())) {
  2330. log_err(LD_GENERAL,"Error: missing identity key.");
  2331. return -1;
  2332. }
  2333. if (crypto_pk_get_fingerprint(k, buf, 1)<0) {
  2334. log_err(LD_BUG, "Error computing fingerprint");
  2335. return -1;
  2336. }
  2337. printf("%s %s\n", nickname, buf);
  2338. return 0;
  2339. }
  2340. /** Entry point for password hashing: take the desired password from
  2341. * the command line, and print its salted hash to stdout. **/
  2342. /* static */ void
  2343. do_hash_password(void)
  2344. {
  2345. char output[256];
  2346. char key[S2K_SPECIFIER_LEN+DIGEST_LEN];
  2347. crypto_rand(key, S2K_SPECIFIER_LEN-1);
  2348. key[S2K_SPECIFIER_LEN-1] = (uint8_t)96; /* Hash 64 K of data. */
  2349. secret_to_key(key+S2K_SPECIFIER_LEN, DIGEST_LEN,
  2350. get_options()->command_arg, strlen(get_options()->command_arg),
  2351. key);
  2352. base16_encode(output, sizeof(output), key, sizeof(key));
  2353. printf("16:%s\n",output);
  2354. }
  2355. #if defined (WINCE)
  2356. int
  2357. find_flashcard_path(PWCHAR path, size_t size)
  2358. {
  2359. WIN32_FIND_DATA d = {0};
  2360. HANDLE h = NULL;
  2361. if (!path)
  2362. return -1;
  2363. h = FindFirstFlashCard(&d);
  2364. if (h == INVALID_HANDLE_VALUE)
  2365. return -1;
  2366. if (wcslen(d.cFileName) == 0) {
  2367. FindClose(h);
  2368. return -1;
  2369. }
  2370. wcsncpy(path,d.cFileName,size);
  2371. FindClose(h);
  2372. return 0;
  2373. }
  2374. #endif
  2375. static void
  2376. init_addrinfo(void)
  2377. {
  2378. char hname[256];
  2379. // host name to sandbox
  2380. gethostname(hname, sizeof(hname));
  2381. sandbox_add_addrinfo(hname);
  2382. }
  2383. static sandbox_cfg_t*
  2384. sandbox_init_filter(void)
  2385. {
  2386. sandbox_cfg_t *cfg = sandbox_cfg_new();
  2387. sandbox_cfg_allow_openat_filename(&cfg,
  2388. get_datadir_fname("cached-status"), 1);
  2389. sandbox_cfg_allow_open_filename_array(&cfg,
  2390. get_datadir_fname("cached-certs"), 1,
  2391. get_datadir_fname("cached-certs.tmp"), 1,
  2392. get_datadir_fname("cached-consensus"), 1,
  2393. get_datadir_fname("unverified-consensus"), 1,
  2394. get_datadir_fname("unverified-consensus.tmp"), 1,
  2395. get_datadir_fname("cached-microdesc-consensus"), 1,
  2396. get_datadir_fname("cached-microdesc-consensus.tmp"), 1,
  2397. get_datadir_fname("cached-microdescs"), 1,
  2398. get_datadir_fname("cached-microdescs.tmp"), 1,
  2399. get_datadir_fname("cached-microdescs.new"), 1,
  2400. get_datadir_fname("cached-microdescs.new.tmp"), 1,
  2401. get_datadir_fname("unverified-microdesc-consensus"), 1,
  2402. get_datadir_fname("cached-descriptors"), 1,
  2403. get_datadir_fname("cached-descriptors.new"), 1,
  2404. get_datadir_fname("cached-descriptors.tmp"), 1,
  2405. get_datadir_fname("cached-descriptors.new.tmp"), 1,
  2406. get_datadir_fname("cached-descriptors.tmp.tmp"), 1,
  2407. get_datadir_fname("cached-extrainfo"), 1,
  2408. get_datadir_fname("state.tmp"), 1,
  2409. get_datadir_fname("unparseable-desc.tmp"), 1,
  2410. get_datadir_fname("unparseable-desc"), 1,
  2411. "/dev/srandom", 0,
  2412. "/dev/urandom", 0,
  2413. "/dev/random", 0,
  2414. NULL, 0
  2415. );
  2416. sandbox_cfg_allow_stat_filename_array(&cfg,
  2417. get_datadir_fname(NULL), 1,
  2418. get_datadir_fname("lock"), 1,
  2419. get_datadir_fname("state"), 1,
  2420. get_datadir_fname("router-stability"), 1,
  2421. get_datadir_fname("cached-extrainfo.new"), 1,
  2422. NULL, 0
  2423. );
  2424. // orport
  2425. if (server_mode(get_options())) {
  2426. sandbox_cfg_allow_open_filename_array(&cfg,
  2427. get_datadir_fname2("keys", "secret_id_key"), 1,
  2428. get_datadir_fname2("keys", "secret_onion_key"), 1,
  2429. get_datadir_fname2("keys", "secret_onion_key_ntor"), 1,
  2430. get_datadir_fname2("keys", "secret_onion_key_ntor.tmp"), 1,
  2431. get_datadir_fname2("keys", "secret_id_key.old"), 1,
  2432. get_datadir_fname2("keys", "secret_onion_key.old"), 1,
  2433. get_datadir_fname2("keys", "secret_onion_key_ntor.old"), 1,
  2434. get_datadir_fname2("keys", "secret_onion_key.tmp"), 1,
  2435. get_datadir_fname2("keys", "secret_id_key.tmp"), 1,
  2436. get_datadir_fname("fingerprint"), 1,
  2437. get_datadir_fname("fingerprint.tmp"), 1,
  2438. get_datadir_fname("cached-consensus"), 1,
  2439. get_datadir_fname("cached-consensus.tmp"), 1,
  2440. "/etc/resolv.conf", 0,
  2441. NULL, 0
  2442. );
  2443. sandbox_cfg_allow_stat_filename_array(&cfg,
  2444. get_datadir_fname("keys"), 1,
  2445. get_datadir_fname("stats/dirreq-stats"), 1,
  2446. NULL, 0
  2447. );
  2448. }
  2449. sandbox_cfg_allow_execve(&cfg, "/usr/local/bin/tor");
  2450. init_addrinfo();
  2451. return cfg;
  2452. }
  2453. /** Main entry point for the Tor process. Called from main(). */
  2454. /* This function is distinct from main() only so we can link main.c into
  2455. * the unittest binary without conflicting with the unittests' main. */
  2456. int
  2457. tor_main(int argc, char *argv[])
  2458. {
  2459. int result = 0;
  2460. #if defined (WINCE)
  2461. WCHAR path [MAX_PATH] = {0};
  2462. WCHAR fullpath [MAX_PATH] = {0};
  2463. PWCHAR p = NULL;
  2464. FILE* redir = NULL;
  2465. FILE* redirdbg = NULL;
  2466. // this is to facilitate debugging by opening
  2467. // a file on a folder shared by the wm emulator.
  2468. // if no flashcard (real or emulated) is present,
  2469. // log files will be written in the root folder
  2470. if (find_flashcard_path(path,MAX_PATH) == -1) {
  2471. redir = _wfreopen( L"\\stdout.log", L"w", stdout );
  2472. redirdbg = _wfreopen( L"\\stderr.log", L"w", stderr );
  2473. } else {
  2474. swprintf(fullpath,L"\\%s\\tor",path);
  2475. CreateDirectory(fullpath,NULL);
  2476. swprintf(fullpath,L"\\%s\\tor\\stdout.log",path);
  2477. redir = _wfreopen( fullpath, L"w", stdout );
  2478. swprintf(fullpath,L"\\%s\\tor\\stderr.log",path);
  2479. redirdbg = _wfreopen( fullpath, L"w", stderr );
  2480. }
  2481. #endif
  2482. #ifdef _WIN32
  2483. /* Call SetProcessDEPPolicy to permanently enable DEP.
  2484. The function will not resolve on earlier versions of Windows,
  2485. and failure is not dangerous. */
  2486. HMODULE hMod = GetModuleHandleA("Kernel32.dll");
  2487. if (hMod) {
  2488. typedef BOOL (WINAPI *PSETDEP)(DWORD);
  2489. PSETDEP setdeppolicy = (PSETDEP)GetProcAddress(hMod,
  2490. "SetProcessDEPPolicy");
  2491. if (setdeppolicy) setdeppolicy(1); /* PROCESS_DEP_ENABLE */
  2492. }
  2493. #endif
  2494. update_approx_time(time(NULL));
  2495. tor_threads_init();
  2496. init_logging();
  2497. #ifdef USE_DMALLOC
  2498. {
  2499. /* Instruct OpenSSL to use our internal wrappers for malloc,
  2500. realloc and free. */
  2501. int r = CRYPTO_set_mem_ex_functions(tor_malloc_, tor_realloc_, tor_free_);
  2502. tor_assert(r);
  2503. }
  2504. #endif
  2505. #ifdef NT_SERVICE
  2506. {
  2507. int done = 0;
  2508. result = nt_service_parse_options(argc, argv, &done);
  2509. if (done) return result;
  2510. }
  2511. #endif
  2512. if (tor_init(argc, argv)<0)
  2513. return -1;
  2514. if (get_options()->Sandbox) {
  2515. sandbox_cfg_t* cfg = sandbox_init_filter();
  2516. if (sandbox_init(cfg)) {
  2517. log_err(LD_BUG,"Failed to create syscall sandbox filter");
  2518. return -1;
  2519. }
  2520. // registering libevent rng
  2521. #ifdef HAVE_EVUTIL_SECURE_RNG_SET_URANDOM_DEVICE_FILE
  2522. evutil_secure_rng_set_urandom_device_file(
  2523. (char*) sandbox_intern_string("/dev/urandom"));
  2524. #endif
  2525. }
  2526. switch (get_options()->command) {
  2527. case CMD_RUN_TOR:
  2528. #ifdef NT_SERVICE
  2529. nt_service_set_state(SERVICE_RUNNING);
  2530. #endif
  2531. result = do_main_loop();
  2532. break;
  2533. case CMD_LIST_FINGERPRINT:
  2534. result = do_list_fingerprint();
  2535. break;
  2536. case CMD_HASH_PASSWORD:
  2537. do_hash_password();
  2538. result = 0;
  2539. break;
  2540. case CMD_VERIFY_CONFIG:
  2541. printf("Configuration was valid\n");
  2542. result = 0;
  2543. break;
  2544. case CMD_RUN_UNITTESTS: /* only set by test.c */
  2545. default:
  2546. log_warn(LD_BUG,"Illegal command number %d: internal error.",
  2547. get_options()->command);
  2548. result = -1;
  2549. }
  2550. tor_cleanup();
  2551. return result;
  2552. }