main.c 75 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238
  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-2010, 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 "buffers.h"
  14. #include "circuitbuild.h"
  15. #include "circuitlist.h"
  16. #include "circuituse.h"
  17. #include "command.h"
  18. #include "config.h"
  19. #include "connection.h"
  20. #include "connection_edge.h"
  21. #include "connection_or.h"
  22. #include "control.h"
  23. #include "cpuworker.h"
  24. #include "directory.h"
  25. #include "dirserv.h"
  26. #include "dirvote.h"
  27. #include "dns.h"
  28. #include "dnsserv.h"
  29. #include "geoip.h"
  30. #include "hibernate.h"
  31. #include "main.h"
  32. #include "microdesc.h"
  33. #include "networkstatus.h"
  34. #include "ntmain.h"
  35. #include "onion.h"
  36. #include "rendclient.h"
  37. #include "rendcommon.h"
  38. #include "rendservice.h"
  39. #include "router.h"
  40. #include "routerlist.h"
  41. #ifdef USE_DMALLOC
  42. #include <dmalloc.h>
  43. #include <openssl/crypto.h>
  44. #endif
  45. #include "memarea.h"
  46. #ifdef HAVE_EVENT2_EVENT_H
  47. #include <event2/event.h>
  48. #else
  49. #include <event.h>
  50. #endif
  51. void evdns_shutdown(int);
  52. /********* PROTOTYPES **********/
  53. static void dumpmemusage(int severity);
  54. static void dumpstats(int severity); /* log stats */
  55. static void conn_read_callback(int fd, short event, void *_conn);
  56. static void conn_write_callback(int fd, short event, void *_conn);
  57. static void signal_callback(int fd, short events, void *arg);
  58. static void second_elapsed_callback(periodic_timer_t *timer, void *args);
  59. static int conn_close_if_marked(int i);
  60. static void connection_start_reading_from_linked_conn(connection_t *conn);
  61. static int connection_should_read_from_linked_conn(connection_t *conn);
  62. /********* START VARIABLES **********/
  63. int global_read_bucket; /**< Max number of bytes I can read this second. */
  64. int global_write_bucket; /**< Max number of bytes I can write this second. */
  65. /** Max number of relayed (bandwidth class 1) bytes I can read this second. */
  66. int global_relayed_read_bucket;
  67. /** Max number of relayed (bandwidth class 1) bytes I can write this second. */
  68. int global_relayed_write_bucket;
  69. /** What was the read bucket before the last second_elapsed_callback() call?
  70. * (used to determine how many bytes we've read). */
  71. static int stats_prev_global_read_bucket;
  72. /** What was the write bucket before the last second_elapsed_callback() call?
  73. * (used to determine how many bytes we've written). */
  74. static int stats_prev_global_write_bucket;
  75. /* XXX we might want to keep stats about global_relayed_*_bucket too. Or not.*/
  76. /** How many bytes have we read since we started the process? */
  77. static uint64_t stats_n_bytes_read = 0;
  78. /** How many bytes have we written since we started the process? */
  79. static uint64_t stats_n_bytes_written = 0;
  80. /** What time did this process start up? */
  81. time_t time_of_process_start = 0;
  82. /** How many seconds have we been running? */
  83. long stats_n_seconds_working = 0;
  84. /** When do we next launch DNS wildcarding checks? */
  85. static time_t time_to_check_for_correct_dns = 0;
  86. /** How often will we honor SIGNEWNYM requests? */
  87. #define MAX_SIGNEWNYM_RATE 10
  88. /** When did we last process a SIGNEWNYM request? */
  89. static time_t time_of_last_signewnym = 0;
  90. /** Is there a signewnym request we're currently waiting to handle? */
  91. static int signewnym_is_pending = 0;
  92. /** Smartlist of all open connections. */
  93. static smartlist_t *connection_array = NULL;
  94. /** List of connections that have been marked for close and need to be freed
  95. * and removed from connection_array. */
  96. static smartlist_t *closeable_connection_lst = NULL;
  97. /** List of linked connections that are currently reading data into their
  98. * inbuf from their partner's outbuf. */
  99. static smartlist_t *active_linked_connection_lst = NULL;
  100. /** Flag: Set to true iff we entered the current libevent main loop via
  101. * <b>loop_once</b>. If so, there's no need to trigger a loopexit in order
  102. * to handle linked connections. */
  103. static int called_loop_once = 0;
  104. /** We set this to 1 when we've opened a circuit, so we can print a log
  105. * entry to inform the user that Tor is working. */
  106. int has_completed_circuit=0;
  107. /** How often do we check for router descriptors that we should download
  108. * when we have too little directory info? */
  109. #define GREEDY_DESCRIPTOR_RETRY_INTERVAL (10)
  110. /** How often do we check for router descriptors that we should download
  111. * when we have enough directory info? */
  112. #define LAZY_DESCRIPTOR_RETRY_INTERVAL (60)
  113. /** How often do we 'forgive' undownloadable router descriptors and attempt
  114. * to download them again? */
  115. #define DESCRIPTOR_FAILURE_RESET_INTERVAL (60*60)
  116. /** How long do we let a directory connection stall before expiring it? */
  117. #define DIR_CONN_MAX_STALL (5*60)
  118. /** How long do we let OR connections handshake before we decide that
  119. * they are obsolete? */
  120. #define TLS_HANDSHAKE_TIMEOUT (60)
  121. /********* END VARIABLES ************/
  122. /****************************************************************************
  123. *
  124. * This section contains accessors and other methods on the connection_array
  125. * variables (which are global within this file and unavailable outside it).
  126. *
  127. ****************************************************************************/
  128. /** Add <b>conn</b> to the array of connections that we can poll on. The
  129. * connection's socket must be set; the connection starts out
  130. * non-reading and non-writing.
  131. */
  132. int
  133. connection_add(connection_t *conn)
  134. {
  135. tor_assert(conn);
  136. tor_assert(conn->s >= 0 ||
  137. conn->linked ||
  138. (conn->type == CONN_TYPE_AP &&
  139. TO_EDGE_CONN(conn)->is_dns_request));
  140. tor_assert(conn->conn_array_index == -1); /* can only connection_add once */
  141. conn->conn_array_index = smartlist_len(connection_array);
  142. smartlist_add(connection_array, conn);
  143. if (conn->s >= 0 || conn->linked) {
  144. conn->read_event = tor_event_new(tor_libevent_get_base(),
  145. conn->s, EV_READ|EV_PERSIST, conn_read_callback, conn);
  146. conn->write_event = tor_event_new(tor_libevent_get_base(),
  147. conn->s, EV_WRITE|EV_PERSIST, conn_write_callback, conn);
  148. }
  149. log_debug(LD_NET,"new conn type %s, socket %d, address %s, n_conns %d.",
  150. conn_type_to_string(conn->type), conn->s, conn->address,
  151. smartlist_len(connection_array));
  152. return 0;
  153. }
  154. /** Tell libevent that we don't care about <b>conn</b> any more. */
  155. void
  156. connection_unregister_events(connection_t *conn)
  157. {
  158. if (conn->read_event) {
  159. if (event_del(conn->read_event))
  160. log_warn(LD_BUG, "Error removing read event for %d", conn->s);
  161. tor_free(conn->read_event);
  162. }
  163. if (conn->write_event) {
  164. if (event_del(conn->write_event))
  165. log_warn(LD_BUG, "Error removing write event for %d", conn->s);
  166. tor_free(conn->write_event);
  167. }
  168. if (conn->dns_server_port) {
  169. dnsserv_close_listener(conn);
  170. }
  171. }
  172. /** Remove the connection from the global list, and remove the
  173. * corresponding poll entry. Calling this function will shift the last
  174. * connection (if any) into the position occupied by conn.
  175. */
  176. int
  177. connection_remove(connection_t *conn)
  178. {
  179. int current_index;
  180. connection_t *tmp;
  181. tor_assert(conn);
  182. log_debug(LD_NET,"removing socket %d (type %s), n_conns now %d",
  183. conn->s, conn_type_to_string(conn->type),
  184. smartlist_len(connection_array));
  185. tor_assert(conn->conn_array_index >= 0);
  186. current_index = conn->conn_array_index;
  187. connection_unregister_events(conn); /* This is redundant, but cheap. */
  188. if (current_index == smartlist_len(connection_array)-1) { /* at the end */
  189. smartlist_del(connection_array, current_index);
  190. return 0;
  191. }
  192. /* replace this one with the one at the end */
  193. smartlist_del(connection_array, current_index);
  194. tmp = smartlist_get(connection_array, current_index);
  195. tmp->conn_array_index = current_index;
  196. return 0;
  197. }
  198. /** If <b>conn</b> is an edge conn, remove it from the list
  199. * of conn's on this circuit. If it's not on an edge,
  200. * flush and send destroys for all circuits on this conn.
  201. *
  202. * Remove it from connection_array (if applicable) and
  203. * from closeable_connection_list.
  204. *
  205. * Then free it.
  206. */
  207. static void
  208. connection_unlink(connection_t *conn)
  209. {
  210. connection_about_to_close_connection(conn);
  211. if (conn->conn_array_index >= 0) {
  212. connection_remove(conn);
  213. }
  214. if (conn->linked_conn) {
  215. conn->linked_conn->linked_conn = NULL;
  216. if (! conn->linked_conn->marked_for_close &&
  217. conn->linked_conn->reading_from_linked_conn)
  218. connection_start_reading(conn->linked_conn);
  219. conn->linked_conn = NULL;
  220. }
  221. smartlist_remove(closeable_connection_lst, conn);
  222. smartlist_remove(active_linked_connection_lst, conn);
  223. if (conn->type == CONN_TYPE_EXIT) {
  224. assert_connection_edge_not_dns_pending(TO_EDGE_CONN(conn));
  225. }
  226. if (conn->type == CONN_TYPE_OR) {
  227. if (!tor_digest_is_zero(TO_OR_CONN(conn)->identity_digest))
  228. connection_or_remove_from_identity_map(TO_OR_CONN(conn));
  229. }
  230. connection_free(conn);
  231. }
  232. /** Schedule <b>conn</b> to be closed. **/
  233. void
  234. add_connection_to_closeable_list(connection_t *conn)
  235. {
  236. tor_assert(!smartlist_isin(closeable_connection_lst, conn));
  237. tor_assert(conn->marked_for_close);
  238. assert_connection_ok(conn, time(NULL));
  239. smartlist_add(closeable_connection_lst, conn);
  240. }
  241. /** Return 1 if conn is on the closeable list, else return 0. */
  242. int
  243. connection_is_on_closeable_list(connection_t *conn)
  244. {
  245. return smartlist_isin(closeable_connection_lst, conn);
  246. }
  247. /** Return true iff conn is in the current poll array. */
  248. int
  249. connection_in_array(connection_t *conn)
  250. {
  251. return smartlist_isin(connection_array, conn);
  252. }
  253. /** Set <b>*array</b> to an array of all connections, and <b>*n</b>
  254. * to the length of the array. <b>*array</b> and <b>*n</b> must not
  255. * be modified.
  256. */
  257. smartlist_t *
  258. get_connection_array(void)
  259. {
  260. if (!connection_array)
  261. connection_array = smartlist_create();
  262. return connection_array;
  263. }
  264. /** Set the event mask on <b>conn</b> to <b>events</b>. (The event
  265. * mask is a bitmask whose bits are READ_EVENT and WRITE_EVENT)
  266. */
  267. void
  268. connection_watch_events(connection_t *conn, watchable_events_t events)
  269. {
  270. if (events & READ_EVENT)
  271. connection_start_reading(conn);
  272. else
  273. connection_stop_reading(conn);
  274. if (events & WRITE_EVENT)
  275. connection_start_writing(conn);
  276. else
  277. connection_stop_writing(conn);
  278. }
  279. /** Return true iff <b>conn</b> is listening for read events. */
  280. int
  281. connection_is_reading(connection_t *conn)
  282. {
  283. tor_assert(conn);
  284. return conn->reading_from_linked_conn ||
  285. (conn->read_event && event_pending(conn->read_event, EV_READ, NULL));
  286. }
  287. /** Tell the main loop to stop notifying <b>conn</b> of any read events. */
  288. void
  289. connection_stop_reading(connection_t *conn)
  290. {
  291. tor_assert(conn);
  292. tor_assert(conn->read_event);
  293. if (conn->linked) {
  294. conn->reading_from_linked_conn = 0;
  295. connection_stop_reading_from_linked_conn(conn);
  296. } else {
  297. if (event_del(conn->read_event))
  298. log_warn(LD_NET, "Error from libevent setting read event state for %d "
  299. "to unwatched: %s",
  300. conn->s,
  301. tor_socket_strerror(tor_socket_errno(conn->s)));
  302. }
  303. }
  304. /** Tell the main loop to start notifying <b>conn</b> of any read events. */
  305. void
  306. connection_start_reading(connection_t *conn)
  307. {
  308. tor_assert(conn);
  309. tor_assert(conn->read_event);
  310. if (conn->linked) {
  311. conn->reading_from_linked_conn = 1;
  312. if (connection_should_read_from_linked_conn(conn))
  313. connection_start_reading_from_linked_conn(conn);
  314. } else {
  315. if (event_add(conn->read_event, NULL))
  316. log_warn(LD_NET, "Error from libevent setting read event state for %d "
  317. "to watched: %s",
  318. conn->s,
  319. tor_socket_strerror(tor_socket_errno(conn->s)));
  320. }
  321. }
  322. /** Return true iff <b>conn</b> is listening for write events. */
  323. int
  324. connection_is_writing(connection_t *conn)
  325. {
  326. tor_assert(conn);
  327. return conn->writing_to_linked_conn ||
  328. (conn->write_event && event_pending(conn->write_event, EV_WRITE, NULL));
  329. }
  330. /** Tell the main loop to stop notifying <b>conn</b> of any write events. */
  331. void
  332. connection_stop_writing(connection_t *conn)
  333. {
  334. tor_assert(conn);
  335. tor_assert(conn->write_event);
  336. if (conn->linked) {
  337. conn->writing_to_linked_conn = 0;
  338. if (conn->linked_conn)
  339. connection_stop_reading_from_linked_conn(conn->linked_conn);
  340. } else {
  341. if (event_del(conn->write_event))
  342. log_warn(LD_NET, "Error from libevent setting write event state for %d "
  343. "to unwatched: %s",
  344. conn->s,
  345. tor_socket_strerror(tor_socket_errno(conn->s)));
  346. }
  347. }
  348. /** Tell the main loop to start notifying <b>conn</b> of any write events. */
  349. void
  350. connection_start_writing(connection_t *conn)
  351. {
  352. tor_assert(conn);
  353. tor_assert(conn->write_event);
  354. if (conn->linked) {
  355. conn->writing_to_linked_conn = 1;
  356. if (conn->linked_conn &&
  357. connection_should_read_from_linked_conn(conn->linked_conn))
  358. connection_start_reading_from_linked_conn(conn->linked_conn);
  359. } else {
  360. if (event_add(conn->write_event, NULL))
  361. log_warn(LD_NET, "Error from libevent setting write event state for %d "
  362. "to watched: %s",
  363. conn->s,
  364. tor_socket_strerror(tor_socket_errno(conn->s)));
  365. }
  366. }
  367. /** Return true iff <b>conn</b> is linked conn, and reading from the conn
  368. * linked to it would be good and feasible. (Reading is "feasible" if the
  369. * other conn exists and has data in its outbuf, and is "good" if we have our
  370. * reading_from_linked_conn flag set and the other conn has its
  371. * writing_to_linked_conn flag set.)*/
  372. static int
  373. connection_should_read_from_linked_conn(connection_t *conn)
  374. {
  375. if (conn->linked && conn->reading_from_linked_conn) {
  376. if (! conn->linked_conn ||
  377. (conn->linked_conn->writing_to_linked_conn &&
  378. buf_datalen(conn->linked_conn->outbuf)))
  379. return 1;
  380. }
  381. return 0;
  382. }
  383. /** Helper: Tell the main loop to begin reading bytes into <b>conn</b> from
  384. * its linked connection, if it is not doing so already. Called by
  385. * connection_start_reading and connection_start_writing as appropriate. */
  386. static void
  387. connection_start_reading_from_linked_conn(connection_t *conn)
  388. {
  389. tor_assert(conn);
  390. tor_assert(conn->linked == 1);
  391. if (!conn->active_on_link) {
  392. conn->active_on_link = 1;
  393. smartlist_add(active_linked_connection_lst, conn);
  394. if (!called_loop_once) {
  395. /* This is the first event on the list; we won't be in LOOP_ONCE mode,
  396. * so we need to make sure that the event_base_loop() actually exits at
  397. * the end of its run through the current connections and lets us
  398. * activate read events for linked connections. */
  399. struct timeval tv = { 0, 0 };
  400. tor_event_base_loopexit(tor_libevent_get_base(), &tv);
  401. }
  402. } else {
  403. tor_assert(smartlist_isin(active_linked_connection_lst, conn));
  404. }
  405. }
  406. /** Tell the main loop to stop reading bytes into <b>conn</b> from its linked
  407. * connection, if is currently doing so. Called by connection_stop_reading,
  408. * connection_stop_writing, and connection_read. */
  409. void
  410. connection_stop_reading_from_linked_conn(connection_t *conn)
  411. {
  412. tor_assert(conn);
  413. tor_assert(conn->linked == 1);
  414. if (conn->active_on_link) {
  415. conn->active_on_link = 0;
  416. /* FFFF We could keep an index here so we can smartlist_del
  417. * cleanly. On the other hand, this doesn't show up on profiles,
  418. * so let's leave it alone for now. */
  419. smartlist_remove(active_linked_connection_lst, conn);
  420. } else {
  421. tor_assert(!smartlist_isin(active_linked_connection_lst, conn));
  422. }
  423. }
  424. /** Close all connections that have been scheduled to get closed. */
  425. static void
  426. close_closeable_connections(void)
  427. {
  428. int i;
  429. for (i = 0; i < smartlist_len(closeable_connection_lst); ) {
  430. connection_t *conn = smartlist_get(closeable_connection_lst, i);
  431. if (conn->conn_array_index < 0) {
  432. connection_unlink(conn); /* blow it away right now */
  433. } else {
  434. if (!conn_close_if_marked(conn->conn_array_index))
  435. ++i;
  436. }
  437. }
  438. }
  439. /** Libevent callback: this gets invoked when (connection_t*)<b>conn</b> has
  440. * some data to read. */
  441. static void
  442. conn_read_callback(int fd, short event, void *_conn)
  443. {
  444. connection_t *conn = _conn;
  445. (void)fd;
  446. (void)event;
  447. log_debug(LD_NET,"socket %d wants to read.",conn->s);
  448. /* assert_connection_ok(conn, time(NULL)); */
  449. if (connection_handle_read(conn) < 0) {
  450. if (!conn->marked_for_close) {
  451. #ifndef MS_WINDOWS
  452. log_warn(LD_BUG,"Unhandled error on read for %s connection "
  453. "(fd %d); removing",
  454. conn_type_to_string(conn->type), conn->s);
  455. tor_fragile_assert();
  456. #endif
  457. if (CONN_IS_EDGE(conn))
  458. connection_edge_end_errno(TO_EDGE_CONN(conn));
  459. connection_mark_for_close(conn);
  460. }
  461. }
  462. assert_connection_ok(conn, time(NULL));
  463. if (smartlist_len(closeable_connection_lst))
  464. close_closeable_connections();
  465. }
  466. /** Libevent callback: this gets invoked when (connection_t*)<b>conn</b> has
  467. * some data to write. */
  468. static void
  469. conn_write_callback(int fd, short events, void *_conn)
  470. {
  471. connection_t *conn = _conn;
  472. (void)fd;
  473. (void)events;
  474. LOG_FN_CONN(conn, (LOG_DEBUG, LD_NET, "socket %d wants to write.",conn->s));
  475. /* assert_connection_ok(conn, time(NULL)); */
  476. if (connection_handle_write(conn, 0) < 0) {
  477. if (!conn->marked_for_close) {
  478. /* this connection is broken. remove it. */
  479. log_fn(LOG_WARN,LD_BUG,
  480. "unhandled error on write for %s connection (fd %d); removing",
  481. conn_type_to_string(conn->type), conn->s);
  482. tor_fragile_assert();
  483. if (CONN_IS_EDGE(conn)) {
  484. /* otherwise we cry wolf about duplicate close */
  485. edge_connection_t *edge_conn = TO_EDGE_CONN(conn);
  486. if (!edge_conn->end_reason)
  487. edge_conn->end_reason = END_STREAM_REASON_INTERNAL;
  488. edge_conn->edge_has_sent_end = 1;
  489. }
  490. connection_close_immediate(conn); /* So we don't try to flush. */
  491. connection_mark_for_close(conn);
  492. }
  493. }
  494. assert_connection_ok(conn, time(NULL));
  495. if (smartlist_len(closeable_connection_lst))
  496. close_closeable_connections();
  497. }
  498. /** If the connection at connection_array[i] is marked for close, then:
  499. * - If it has data that it wants to flush, try to flush it.
  500. * - If it _still_ has data to flush, and conn->hold_open_until_flushed is
  501. * true, then leave the connection open and return.
  502. * - Otherwise, remove the connection from connection_array and from
  503. * all other lists, close it, and free it.
  504. * Returns 1 if the connection was closed, 0 otherwise.
  505. */
  506. static int
  507. conn_close_if_marked(int i)
  508. {
  509. connection_t *conn;
  510. int retval;
  511. time_t now;
  512. conn = smartlist_get(connection_array, i);
  513. if (!conn->marked_for_close)
  514. return 0; /* nothing to see here, move along */
  515. now = time(NULL);
  516. assert_connection_ok(conn, now);
  517. /* assert_all_pending_dns_resolves_ok(); */
  518. log_debug(LD_NET,"Cleaning up connection (fd %d).",conn->s);
  519. if ((conn->s >= 0 || conn->linked_conn) && connection_wants_to_flush(conn)) {
  520. /* s == -1 means it's an incomplete edge connection, or that the socket
  521. * has already been closed as unflushable. */
  522. ssize_t sz = connection_bucket_write_limit(conn, now);
  523. if (!conn->hold_open_until_flushed)
  524. log_info(LD_NET,
  525. "Conn (addr %s, fd %d, type %s, state %d) marked, but wants "
  526. "to flush %d bytes. (Marked at %s:%d)",
  527. escaped_safe_str_client(conn->address),
  528. conn->s, conn_type_to_string(conn->type), conn->state,
  529. (int)conn->outbuf_flushlen,
  530. conn->marked_for_close_file, conn->marked_for_close);
  531. if (conn->linked_conn) {
  532. retval = move_buf_to_buf(conn->linked_conn->inbuf, conn->outbuf,
  533. &conn->outbuf_flushlen);
  534. if (retval >= 0) {
  535. /* The linked conn will notice that it has data when it notices that
  536. * we're gone. */
  537. connection_start_reading_from_linked_conn(conn->linked_conn);
  538. }
  539. log_debug(LD_GENERAL, "Flushed last %d bytes from a linked conn; "
  540. "%d left; flushlen %d; wants-to-flush==%d", retval,
  541. (int)buf_datalen(conn->outbuf),
  542. (int)conn->outbuf_flushlen,
  543. connection_wants_to_flush(conn));
  544. } else if (connection_speaks_cells(conn)) {
  545. if (conn->state == OR_CONN_STATE_OPEN) {
  546. retval = flush_buf_tls(TO_OR_CONN(conn)->tls, conn->outbuf, sz,
  547. &conn->outbuf_flushlen);
  548. } else
  549. retval = -1; /* never flush non-open broken tls connections */
  550. } else {
  551. retval = flush_buf(conn->s, conn->outbuf, sz, &conn->outbuf_flushlen);
  552. }
  553. if (retval >= 0 && /* Technically, we could survive things like
  554. TLS_WANT_WRITE here. But don't bother for now. */
  555. conn->hold_open_until_flushed && connection_wants_to_flush(conn)) {
  556. if (retval > 0) {
  557. LOG_FN_CONN(conn, (LOG_INFO,LD_NET,
  558. "Holding conn (fd %d) open for more flushing.",
  559. conn->s));
  560. conn->timestamp_lastwritten = now; /* reset so we can flush more */
  561. }
  562. return 0;
  563. }
  564. if (connection_wants_to_flush(conn)) {
  565. int severity;
  566. if (conn->type == CONN_TYPE_EXIT ||
  567. (conn->type == CONN_TYPE_OR && server_mode(get_options())) ||
  568. (conn->type == CONN_TYPE_DIR && conn->purpose == DIR_PURPOSE_SERVER))
  569. severity = LOG_INFO;
  570. else
  571. severity = LOG_NOTICE;
  572. /* XXXX Maybe allow this to happen a certain amount per hour; it usually
  573. * is meaningless. */
  574. log_fn(severity, LD_NET, "We stalled too much while trying to write %d "
  575. "bytes to address %s. If this happens a lot, either "
  576. "something is wrong with your network connection, or "
  577. "something is wrong with theirs. "
  578. "(fd %d, type %s, state %d, marked at %s:%d).",
  579. (int)buf_datalen(conn->outbuf),
  580. escaped_safe_str_client(conn->address),
  581. conn->s, conn_type_to_string(conn->type), conn->state,
  582. conn->marked_for_close_file,
  583. conn->marked_for_close);
  584. }
  585. }
  586. connection_unlink(conn); /* unlink, remove, free */
  587. return 1;
  588. }
  589. /** We've just tried every dirserver we know about, and none of
  590. * them were reachable. Assume the network is down. Change state
  591. * so next time an application connection arrives we'll delay it
  592. * and try another directory fetch. Kill off all the circuit_wait
  593. * streams that are waiting now, since they will all timeout anyway.
  594. */
  595. void
  596. directory_all_unreachable(time_t now)
  597. {
  598. connection_t *conn;
  599. (void)now;
  600. stats_n_seconds_working=0; /* reset it */
  601. while ((conn = connection_get_by_type_state(CONN_TYPE_AP,
  602. AP_CONN_STATE_CIRCUIT_WAIT))) {
  603. edge_connection_t *edge_conn = TO_EDGE_CONN(conn);
  604. log_notice(LD_NET,
  605. "Is your network connection down? "
  606. "Failing connection to '%s:%d'.",
  607. safe_str_client(edge_conn->socks_request->address),
  608. edge_conn->socks_request->port);
  609. connection_mark_unattached_ap(edge_conn,
  610. END_STREAM_REASON_NET_UNREACHABLE);
  611. }
  612. control_event_general_status(LOG_ERR, "DIR_ALL_UNREACHABLE");
  613. }
  614. /** This function is called whenever we successfully pull down some new
  615. * network statuses or server descriptors. */
  616. void
  617. directory_info_has_arrived(time_t now, int from_cache)
  618. {
  619. or_options_t *options = get_options();
  620. if (!router_have_minimum_dir_info()) {
  621. int quiet = directory_too_idle_to_fetch_descriptors(options, now);
  622. log(quiet ? LOG_INFO : LOG_NOTICE, LD_DIR,
  623. "I learned some more directory information, but not enough to "
  624. "build a circuit: %s", get_dir_info_status_string());
  625. update_router_descriptor_downloads(now);
  626. return;
  627. } else {
  628. if (directory_fetches_from_authorities(options))
  629. update_router_descriptor_downloads(now);
  630. /* if we have enough dir info, then update our guard status with
  631. * whatever we just learned. */
  632. entry_guards_compute_status();
  633. /* Don't even bother trying to get extrainfo until the rest of our
  634. * directory info is up-to-date */
  635. if (options->DownloadExtraInfo)
  636. update_extrainfo_downloads(now);
  637. }
  638. if (server_mode(options) && !we_are_hibernating() && !from_cache &&
  639. (has_completed_circuit || !any_predicted_circuits(now)))
  640. consider_testing_reachability(1, 1);
  641. }
  642. /** How long do we wait before killing OR connections with no circuits?
  643. * In Tor versions up to 0.2.1.25 and 0.2.2.12-alpha, we waited 15 minutes
  644. * before cancelling these connections, which caused fast relays to accrue
  645. * many many idle connections. Hopefully 3 minutes is low enough that
  646. * it kills most idle connections, without being so low that we cause
  647. * clients to bounce on and off.
  648. */
  649. #define IDLE_OR_CONN_TIMEOUT 180
  650. /** Perform regular maintenance tasks for a single connection. This
  651. * function gets run once per second per connection by run_scheduled_events.
  652. */
  653. static void
  654. run_connection_housekeeping(int i, time_t now)
  655. {
  656. cell_t cell;
  657. connection_t *conn = smartlist_get(connection_array, i);
  658. or_options_t *options = get_options();
  659. or_connection_t *or_conn;
  660. int past_keepalive =
  661. now >= conn->timestamp_lastwritten + options->KeepalivePeriod;
  662. if (conn->outbuf && !buf_datalen(conn->outbuf) && conn->type == CONN_TYPE_OR)
  663. TO_OR_CONN(conn)->timestamp_lastempty = now;
  664. if (conn->marked_for_close) {
  665. /* nothing to do here */
  666. return;
  667. }
  668. /* Expire any directory connections that haven't been active (sent
  669. * if a server or received if a client) for 5 min */
  670. if (conn->type == CONN_TYPE_DIR &&
  671. ((DIR_CONN_IS_SERVER(conn) &&
  672. conn->timestamp_lastwritten + DIR_CONN_MAX_STALL < now) ||
  673. (!DIR_CONN_IS_SERVER(conn) &&
  674. conn->timestamp_lastread + DIR_CONN_MAX_STALL < now))) {
  675. log_info(LD_DIR,"Expiring wedged directory conn (fd %d, purpose %d)",
  676. conn->s, conn->purpose);
  677. /* This check is temporary; it's to let us know whether we should consider
  678. * parsing partial serverdesc responses. */
  679. if (conn->purpose == DIR_PURPOSE_FETCH_SERVERDESC &&
  680. buf_datalen(conn->inbuf)>=1024) {
  681. log_info(LD_DIR,"Trying to extract information from wedged server desc "
  682. "download.");
  683. connection_dir_reached_eof(TO_DIR_CONN(conn));
  684. } else {
  685. connection_mark_for_close(conn);
  686. }
  687. return;
  688. }
  689. if (!connection_speaks_cells(conn))
  690. return; /* we're all done here, the rest is just for OR conns */
  691. /* If we haven't written to an OR connection for a while, then either nuke
  692. the connection or send a keepalive, depending. */
  693. or_conn = TO_OR_CONN(conn);
  694. tor_assert(conn->outbuf);
  695. if (or_conn->is_bad_for_new_circs && !or_conn->n_circuits) {
  696. /* It's bad for new circuits, and has no unmarked circuits on it:
  697. * mark it now. */
  698. log_info(LD_OR,
  699. "Expiring non-used OR connection to fd %d (%s:%d) [Too old].",
  700. conn->s, conn->address, conn->port);
  701. if (conn->state == OR_CONN_STATE_CONNECTING)
  702. connection_or_connect_failed(TO_OR_CONN(conn),
  703. END_OR_CONN_REASON_TIMEOUT,
  704. "Tor gave up on the connection");
  705. connection_mark_for_close(conn);
  706. conn->hold_open_until_flushed = 1;
  707. } else if (past_keepalive && !connection_state_is_open(conn)) {
  708. /* We never managed to actually get this connection open and happy. */
  709. log_info(LD_OR,"Expiring non-open OR connection to fd %d (%s:%d).",
  710. conn->s,conn->address, conn->port);
  711. connection_mark_for_close(conn);
  712. conn->hold_open_until_flushed = 1;
  713. } else if (we_are_hibernating() && !or_conn->n_circuits &&
  714. !buf_datalen(conn->outbuf)) {
  715. /* We're hibernating, there's no circuits, and nothing to flush.*/
  716. log_info(LD_OR,"Expiring non-used OR connection to fd %d (%s:%d) "
  717. "[Hibernating or exiting].",
  718. conn->s,conn->address, conn->port);
  719. connection_mark_for_close(conn);
  720. conn->hold_open_until_flushed = 1;
  721. } else if (!or_conn->n_circuits &&
  722. now >= or_conn->timestamp_last_added_nonpadding +
  723. IDLE_OR_CONN_TIMEOUT) {
  724. log_info(LD_OR,"Expiring non-used OR connection to fd %d (%s:%d) "
  725. "[idle %d].", conn->s,conn->address, conn->port,
  726. (int)(now - or_conn->timestamp_last_added_nonpadding));
  727. connection_mark_for_close(conn);
  728. conn->hold_open_until_flushed = 1;
  729. } else if (
  730. now >= or_conn->timestamp_lastempty + options->KeepalivePeriod*10 &&
  731. now >= conn->timestamp_lastwritten + options->KeepalivePeriod*10) {
  732. log_fn(LOG_PROTOCOL_WARN,LD_PROTOCOL,
  733. "Expiring stuck OR connection to fd %d (%s:%d). (%d bytes to "
  734. "flush; %d seconds since last write)",
  735. conn->s, conn->address, conn->port,
  736. (int)buf_datalen(conn->outbuf),
  737. (int)(now-conn->timestamp_lastwritten));
  738. connection_mark_for_close(conn);
  739. } else if (past_keepalive && !buf_datalen(conn->outbuf)) {
  740. /* send a padding cell */
  741. log_fn(LOG_DEBUG,LD_OR,"Sending keepalive to (%s:%d)",
  742. conn->address, conn->port);
  743. memset(&cell,0,sizeof(cell_t));
  744. cell.command = CELL_PADDING;
  745. connection_or_write_cell_to_buf(&cell, or_conn);
  746. }
  747. }
  748. /** Honor a NEWNYM request: make future requests unlinkable to past
  749. * requests. */
  750. static void
  751. signewnym_impl(time_t now)
  752. {
  753. circuit_expire_all_dirty_circs();
  754. addressmap_clear_transient();
  755. time_of_last_signewnym = now;
  756. signewnym_is_pending = 0;
  757. }
  758. /** Perform regular maintenance tasks. This function gets run once per
  759. * second by second_elapsed_callback().
  760. */
  761. static void
  762. run_scheduled_events(time_t now)
  763. {
  764. static time_t last_rotated_x509_certificate = 0;
  765. static time_t time_to_check_v3_certificate = 0;
  766. static time_t time_to_check_listeners = 0;
  767. static time_t time_to_check_descriptor = 0;
  768. static time_t time_to_check_ipaddress = 0;
  769. static time_t time_to_shrink_memory = 0;
  770. static time_t time_to_try_getting_descriptors = 0;
  771. static time_t time_to_reset_descriptor_failures = 0;
  772. static time_t time_to_add_entropy = 0;
  773. static time_t time_to_write_bridge_status_file = 0;
  774. static time_t time_to_downrate_stability = 0;
  775. static time_t time_to_save_stability = 0;
  776. static time_t time_to_clean_caches = 0;
  777. static time_t time_to_recheck_bandwidth = 0;
  778. static time_t time_to_check_for_expired_networkstatus = 0;
  779. static time_t time_to_write_stats_files = 0;
  780. static time_t time_to_write_bridge_stats = 0;
  781. static int should_init_bridge_stats = 1;
  782. static time_t time_to_retry_dns_init = 0;
  783. or_options_t *options = get_options();
  784. int i;
  785. int have_dir_info;
  786. /** 0. See if we've been asked to shut down and our timeout has
  787. * expired; or if our bandwidth limits are exhausted and we
  788. * should hibernate; or if it's time to wake up from hibernation.
  789. */
  790. consider_hibernation(now);
  791. /* 0b. If we've deferred a signewnym, make sure it gets handled
  792. * eventually. */
  793. if (signewnym_is_pending &&
  794. time_of_last_signewnym + MAX_SIGNEWNYM_RATE <= now) {
  795. log(LOG_INFO, LD_CONTROL, "Honoring delayed NEWNYM request");
  796. signewnym_impl(now);
  797. }
  798. /** 1a. Every MIN_ONION_KEY_LIFETIME seconds, rotate the onion keys,
  799. * shut down and restart all cpuworkers, and update the directory if
  800. * necessary.
  801. */
  802. if (server_mode(options) &&
  803. get_onion_key_set_at()+MIN_ONION_KEY_LIFETIME < now) {
  804. log_info(LD_GENERAL,"Rotating onion key.");
  805. rotate_onion_key();
  806. cpuworkers_rotate();
  807. if (router_rebuild_descriptor(1)<0) {
  808. log_info(LD_CONFIG, "Couldn't rebuild router descriptor");
  809. }
  810. if (advertised_server_mode())
  811. router_upload_dir_desc_to_dirservers(0);
  812. }
  813. if (time_to_try_getting_descriptors < now) {
  814. update_router_descriptor_downloads(now);
  815. update_extrainfo_downloads(now);
  816. if (options->UseBridges)
  817. fetch_bridge_descriptors(now);
  818. if (router_have_minimum_dir_info())
  819. time_to_try_getting_descriptors = now + LAZY_DESCRIPTOR_RETRY_INTERVAL;
  820. else
  821. time_to_try_getting_descriptors = now + GREEDY_DESCRIPTOR_RETRY_INTERVAL;
  822. }
  823. if (time_to_reset_descriptor_failures < now) {
  824. router_reset_descriptor_download_failures();
  825. time_to_reset_descriptor_failures =
  826. now + DESCRIPTOR_FAILURE_RESET_INTERVAL;
  827. }
  828. /** 1b. Every MAX_SSL_KEY_LIFETIME seconds, we change our TLS context. */
  829. if (!last_rotated_x509_certificate)
  830. last_rotated_x509_certificate = now;
  831. if (last_rotated_x509_certificate+MAX_SSL_KEY_LIFETIME < now) {
  832. log_info(LD_GENERAL,"Rotating tls context.");
  833. if (tor_tls_context_new(get_identity_key(), MAX_SSL_KEY_LIFETIME) < 0) {
  834. log_warn(LD_BUG, "Error reinitializing TLS context");
  835. /* XXX is it a bug here, that we just keep going? -RD */
  836. }
  837. last_rotated_x509_certificate = now;
  838. /* We also make sure to rotate the TLS connections themselves if they've
  839. * been up for too long -- but that's done via is_bad_for_new_circs in
  840. * connection_run_housekeeping() above. */
  841. }
  842. if (time_to_add_entropy < now) {
  843. if (time_to_add_entropy) {
  844. /* We already seeded once, so don't die on failure. */
  845. crypto_seed_rng(0);
  846. }
  847. /** How often do we add more entropy to OpenSSL's RNG pool? */
  848. #define ENTROPY_INTERVAL (60*60)
  849. time_to_add_entropy = now + ENTROPY_INTERVAL;
  850. }
  851. /** 1c. If we have to change the accounting interval or record
  852. * bandwidth used in this accounting interval, do so. */
  853. if (accounting_is_enabled(options))
  854. accounting_run_housekeeping(now);
  855. if (now % 10 == 0 && (authdir_mode_tests_reachability(options)) &&
  856. !we_are_hibernating()) {
  857. /* try to determine reachability of the other Tor relays */
  858. dirserv_test_reachability(now);
  859. }
  860. /** 1d. Periodically, we discount older stability information so that new
  861. * stability info counts more, and save the stability information to disk as
  862. * appropriate. */
  863. if (time_to_downrate_stability < now)
  864. time_to_downrate_stability = rep_hist_downrate_old_runs(now);
  865. if (authdir_mode_tests_reachability(options)) {
  866. if (time_to_save_stability < now) {
  867. if (time_to_save_stability && rep_hist_record_mtbf_data(now, 1)<0) {
  868. log_warn(LD_GENERAL, "Couldn't store mtbf data.");
  869. }
  870. #define SAVE_STABILITY_INTERVAL (30*60)
  871. time_to_save_stability = now + SAVE_STABILITY_INTERVAL;
  872. }
  873. }
  874. /* 1e. Periodically, if we're a v3 authority, we check whether our cert is
  875. * close to expiring and warn the admin if it is. */
  876. if (time_to_check_v3_certificate < now) {
  877. v3_authority_check_key_expiry();
  878. #define CHECK_V3_CERTIFICATE_INTERVAL (5*60)
  879. time_to_check_v3_certificate = now + CHECK_V3_CERTIFICATE_INTERVAL;
  880. }
  881. /* 1f. Check whether our networkstatus has expired.
  882. */
  883. if (time_to_check_for_expired_networkstatus < now) {
  884. networkstatus_t *ns = networkstatus_get_latest_consensus();
  885. /*XXXX RD: This value needs to be the same as REASONABLY_LIVE_TIME in
  886. * networkstatus_get_reasonably_live_consensus(), but that value is way
  887. * way too high. Arma: is the bridge issue there resolved yet? -NM */
  888. #define NS_EXPIRY_SLOP (24*60*60)
  889. if (ns && ns->valid_until < now+NS_EXPIRY_SLOP &&
  890. router_have_minimum_dir_info()) {
  891. router_dir_info_changed();
  892. }
  893. #define CHECK_EXPIRED_NS_INTERVAL (2*60)
  894. time_to_check_for_expired_networkstatus = now + CHECK_EXPIRED_NS_INTERVAL;
  895. }
  896. /* 1g. Check whether we should write statistics to disk.
  897. */
  898. if (time_to_write_stats_files >= 0 && time_to_write_stats_files < now) {
  899. #define WRITE_STATS_INTERVAL (24*60*60)
  900. if (options->CellStatistics || options->DirReqStatistics ||
  901. options->EntryStatistics || options->ExitPortStatistics) {
  902. if (!time_to_write_stats_files) {
  903. /* Initialize stats. We're doing this here and not in options_act,
  904. * so that we know exactly when the 24 hours interval ends. */
  905. if (options->CellStatistics)
  906. rep_hist_buffer_stats_init(now);
  907. if (options->DirReqStatistics)
  908. geoip_dirreq_stats_init(now);
  909. if (options->EntryStatistics)
  910. geoip_entry_stats_init(now);
  911. if (options->ExitPortStatistics)
  912. rep_hist_exit_stats_init(now);
  913. log_notice(LD_CONFIG, "Configured to measure statistics. Look for "
  914. "the *-stats files that will first be written to the "
  915. "data directory in %d hours from now.",
  916. WRITE_STATS_INTERVAL / (60 * 60));
  917. time_to_write_stats_files = now + WRITE_STATS_INTERVAL;
  918. } else {
  919. /* Write stats to disk. */
  920. if (options->CellStatistics)
  921. rep_hist_buffer_stats_write(time_to_write_stats_files);
  922. if (options->DirReqStatistics)
  923. geoip_dirreq_stats_write(time_to_write_stats_files);
  924. if (options->EntryStatistics)
  925. geoip_entry_stats_write(time_to_write_stats_files);
  926. if (options->ExitPortStatistics)
  927. rep_hist_exit_stats_write(time_to_write_stats_files);
  928. time_to_write_stats_files += WRITE_STATS_INTERVAL;
  929. }
  930. } else {
  931. /* Never write stats to disk */
  932. time_to_write_stats_files = -1;
  933. }
  934. }
  935. /* 1h. Check whether we should write bridge statistics to disk.
  936. */
  937. if (should_record_bridge_info(options)) {
  938. if (time_to_write_bridge_stats < now) {
  939. if (should_init_bridge_stats) {
  940. /* (Re-)initialize bridge statistics. */
  941. geoip_bridge_stats_init(now);
  942. time_to_write_bridge_stats = now + WRITE_STATS_INTERVAL;
  943. should_init_bridge_stats = 0;
  944. } else {
  945. /* Possibly write bridge statistics to disk and ask when to write
  946. * them next time. */
  947. time_to_write_bridge_stats = geoip_bridge_stats_write(
  948. time_to_write_bridge_stats);
  949. }
  950. }
  951. } else if (!should_init_bridge_stats) {
  952. /* Bridge mode was turned off. Ensure that stats are re-initialized
  953. * next time bridge mode is turned on. */
  954. should_init_bridge_stats = 1;
  955. }
  956. /* Remove old information from rephist and the rend cache. */
  957. if (time_to_clean_caches < now) {
  958. rep_history_clean(now - options->RephistTrackTime);
  959. rend_cache_clean();
  960. rend_cache_clean_v2_descs_as_dir();
  961. #define CLEAN_CACHES_INTERVAL (30*60)
  962. time_to_clean_caches = now + CLEAN_CACHES_INTERVAL;
  963. }
  964. #define RETRY_DNS_INTERVAL (10*60)
  965. /* If we're a server and initializing dns failed, retry periodically. */
  966. if (time_to_retry_dns_init < now) {
  967. time_to_retry_dns_init = now + RETRY_DNS_INTERVAL;
  968. if (server_mode(options) && has_dns_init_failed())
  969. dns_init();
  970. }
  971. /** 2. Periodically, we consider force-uploading our descriptor
  972. * (if we've passed our internal checks). */
  973. /** How often do we check whether part of our router info has changed in a way
  974. * that would require an upload? */
  975. #define CHECK_DESCRIPTOR_INTERVAL (60)
  976. /** How often do we (as a router) check whether our IP address has changed? */
  977. #define CHECK_IPADDRESS_INTERVAL (15*60)
  978. /* 2b. Once per minute, regenerate and upload the descriptor if the old
  979. * one is inaccurate. */
  980. if (time_to_check_descriptor < now) {
  981. static int dirport_reachability_count = 0;
  982. time_to_check_descriptor = now + CHECK_DESCRIPTOR_INTERVAL;
  983. check_descriptor_bandwidth_changed(now);
  984. if (time_to_check_ipaddress < now) {
  985. time_to_check_ipaddress = now + CHECK_IPADDRESS_INTERVAL;
  986. check_descriptor_ipaddress_changed(now);
  987. }
  988. /** If our router descriptor ever goes this long without being regenerated
  989. * because something changed, we force an immediate regenerate-and-upload. */
  990. #define FORCE_REGENERATE_DESCRIPTOR_INTERVAL (18*60*60)
  991. mark_my_descriptor_dirty_if_older_than(
  992. now - FORCE_REGENERATE_DESCRIPTOR_INTERVAL);
  993. consider_publishable_server(0);
  994. /* also, check religiously for reachability, if it's within the first
  995. * 20 minutes of our uptime. */
  996. if (server_mode(options) &&
  997. (has_completed_circuit || !any_predicted_circuits(now)) &&
  998. !we_are_hibernating()) {
  999. if (stats_n_seconds_working < TIMEOUT_UNTIL_UNREACHABILITY_COMPLAINT) {
  1000. consider_testing_reachability(1, dirport_reachability_count==0);
  1001. if (++dirport_reachability_count > 5)
  1002. dirport_reachability_count = 0;
  1003. } else if (time_to_recheck_bandwidth < now) {
  1004. /* If we haven't checked for 12 hours and our bandwidth estimate is
  1005. * low, do another bandwidth test. This is especially important for
  1006. * bridges, since they might go long periods without much use. */
  1007. routerinfo_t *me = router_get_my_routerinfo();
  1008. if (time_to_recheck_bandwidth && me &&
  1009. me->bandwidthcapacity < me->bandwidthrate &&
  1010. me->bandwidthcapacity < 51200) {
  1011. reset_bandwidth_test();
  1012. }
  1013. #define BANDWIDTH_RECHECK_INTERVAL (12*60*60)
  1014. time_to_recheck_bandwidth = now + BANDWIDTH_RECHECK_INTERVAL;
  1015. }
  1016. }
  1017. /* If any networkstatus documents are no longer recent, we need to
  1018. * update all the descriptors' running status. */
  1019. /* purge obsolete entries */
  1020. networkstatus_v2_list_clean(now);
  1021. /* Remove dead routers. */
  1022. routerlist_remove_old_routers();
  1023. /* Also, once per minute, check whether we want to download any
  1024. * networkstatus documents.
  1025. */
  1026. update_networkstatus_downloads(now);
  1027. }
  1028. /** 2c. Let directory voting happen. */
  1029. if (authdir_mode_v3(options))
  1030. dirvote_act(options, now);
  1031. /** 3a. Every second, we examine pending circuits and prune the
  1032. * ones which have been pending for more than a few seconds.
  1033. * We do this before step 4, so it can try building more if
  1034. * it's not comfortable with the number of available circuits.
  1035. */
  1036. circuit_expire_building(now);
  1037. /** 3b. Also look at pending streams and prune the ones that 'began'
  1038. * a long time ago but haven't gotten a 'connected' yet.
  1039. * Do this before step 4, so we can put them back into pending
  1040. * state to be picked up by the new circuit.
  1041. */
  1042. connection_ap_expire_beginning();
  1043. /** 3c. And expire connections that we've held open for too long.
  1044. */
  1045. connection_expire_held_open();
  1046. /** 3d. And every 60 seconds, we relaunch listeners if any died. */
  1047. if (!we_are_hibernating() && time_to_check_listeners < now) {
  1048. retry_all_listeners(NULL, NULL);
  1049. time_to_check_listeners = now+60;
  1050. }
  1051. /** 4. Every second, we try a new circuit if there are no valid
  1052. * circuits. Every NewCircuitPeriod seconds, we expire circuits
  1053. * that became dirty more than MaxCircuitDirtiness seconds ago,
  1054. * and we make a new circ if there are no clean circuits.
  1055. */
  1056. have_dir_info = router_have_minimum_dir_info();
  1057. if (have_dir_info && !we_are_hibernating())
  1058. circuit_build_needed_circs(now);
  1059. /* every 10 seconds, but not at the same second as other such events */
  1060. if (now % 10 == 5)
  1061. circuit_expire_old_circuits_serverside(now);
  1062. /** 5. We do housekeeping for each connection... */
  1063. connection_or_set_bad_connections();
  1064. for (i=0;i<smartlist_len(connection_array);i++) {
  1065. run_connection_housekeeping(i, now);
  1066. }
  1067. if (time_to_shrink_memory < now) {
  1068. SMARTLIST_FOREACH(connection_array, connection_t *, conn, {
  1069. if (conn->outbuf)
  1070. buf_shrink(conn->outbuf);
  1071. if (conn->inbuf)
  1072. buf_shrink(conn->inbuf);
  1073. });
  1074. clean_cell_pool();
  1075. buf_shrink_freelists(0);
  1076. /** How often do we check buffers and pools for empty space that can be
  1077. * deallocated? */
  1078. #define MEM_SHRINK_INTERVAL (60)
  1079. time_to_shrink_memory = now + MEM_SHRINK_INTERVAL;
  1080. }
  1081. /** 6. And remove any marked circuits... */
  1082. circuit_close_all_marked();
  1083. /** 7. And upload service descriptors if necessary. */
  1084. if (has_completed_circuit && !we_are_hibernating()) {
  1085. rend_consider_services_upload(now);
  1086. rend_consider_descriptor_republication();
  1087. }
  1088. /** 8. and blow away any connections that need to die. have to do this now,
  1089. * because if we marked a conn for close and left its socket -1, then
  1090. * we'll pass it to poll/select and bad things will happen.
  1091. */
  1092. close_closeable_connections();
  1093. /** 8b. And if anything in our state is ready to get flushed to disk, we
  1094. * flush it. */
  1095. or_state_save(now);
  1096. /** 9. and if we're a server, check whether our DNS is telling stories to
  1097. * us. */
  1098. if (server_mode(options) && time_to_check_for_correct_dns < now) {
  1099. if (!time_to_check_for_correct_dns) {
  1100. time_to_check_for_correct_dns = now + 60 + crypto_rand_int(120);
  1101. } else {
  1102. dns_launch_correctness_checks();
  1103. time_to_check_for_correct_dns = now + 12*3600 +
  1104. crypto_rand_int(12*3600);
  1105. }
  1106. }
  1107. /** 10b. write bridge networkstatus file to disk */
  1108. if (options->BridgeAuthoritativeDir &&
  1109. time_to_write_bridge_status_file < now) {
  1110. networkstatus_dump_bridge_status_to_file(now);
  1111. #define BRIDGE_STATUSFILE_INTERVAL (30*60)
  1112. time_to_write_bridge_status_file = now+BRIDGE_STATUSFILE_INTERVAL;
  1113. }
  1114. }
  1115. /** Timer: used to invoke second_elapsed_callback() once per second. */
  1116. static periodic_timer_t *second_timer = NULL;
  1117. /** Number of libevent errors in the last second: we die if we get too many. */
  1118. static int n_libevent_errors = 0;
  1119. /** Libevent callback: invoked once every second. */
  1120. static void
  1121. second_elapsed_callback(periodic_timer_t *timer, void *arg)
  1122. {
  1123. /* XXXX This could be sensibly refactored into multiple callbacks, and we
  1124. * could use Libevent's timers for this rather than checking the current
  1125. * time against a bunch of timeouts every second. */
  1126. static time_t current_second = 0;
  1127. time_t now;
  1128. size_t bytes_written;
  1129. size_t bytes_read;
  1130. int seconds_elapsed;
  1131. or_options_t *options = get_options();
  1132. (void)timer;
  1133. (void)arg;
  1134. n_libevent_errors = 0;
  1135. /* log_notice(LD_GENERAL, "Tick."); */
  1136. now = time(NULL);
  1137. update_approx_time(now);
  1138. /* the second has rolled over. check more stuff. */
  1139. bytes_written = stats_prev_global_write_bucket - global_write_bucket;
  1140. bytes_read = stats_prev_global_read_bucket - global_read_bucket;
  1141. seconds_elapsed = current_second ? (int)(now - current_second) : 0;
  1142. stats_n_bytes_read += bytes_read;
  1143. stats_n_bytes_written += bytes_written;
  1144. if (accounting_is_enabled(options) && seconds_elapsed >= 0)
  1145. accounting_add_bytes(bytes_read, bytes_written, seconds_elapsed);
  1146. control_event_bandwidth_used((uint32_t)bytes_read,(uint32_t)bytes_written);
  1147. control_event_stream_bandwidth_used();
  1148. if (seconds_elapsed > 0)
  1149. connection_bucket_refill(seconds_elapsed, now);
  1150. stats_prev_global_read_bucket = global_read_bucket;
  1151. stats_prev_global_write_bucket = global_write_bucket;
  1152. if (server_mode(options) &&
  1153. !we_are_hibernating() &&
  1154. seconds_elapsed > 0 &&
  1155. has_completed_circuit &&
  1156. stats_n_seconds_working / TIMEOUT_UNTIL_UNREACHABILITY_COMPLAINT !=
  1157. (stats_n_seconds_working+seconds_elapsed) /
  1158. TIMEOUT_UNTIL_UNREACHABILITY_COMPLAINT) {
  1159. /* every 20 minutes, check and complain if necessary */
  1160. routerinfo_t *me = router_get_my_routerinfo();
  1161. if (me && !check_whether_orport_reachable()) {
  1162. log_warn(LD_CONFIG,"Your server (%s:%d) has not managed to confirm that "
  1163. "its ORPort is reachable. Please check your firewalls, ports, "
  1164. "address, /etc/hosts file, etc.",
  1165. me->address, me->or_port);
  1166. control_event_server_status(LOG_WARN,
  1167. "REACHABILITY_FAILED ORADDRESS=%s:%d",
  1168. me->address, me->or_port);
  1169. }
  1170. if (me && !check_whether_dirport_reachable()) {
  1171. log_warn(LD_CONFIG,
  1172. "Your server (%s:%d) has not managed to confirm that its "
  1173. "DirPort is reachable. Please check your firewalls, ports, "
  1174. "address, /etc/hosts file, etc.",
  1175. me->address, me->dir_port);
  1176. control_event_server_status(LOG_WARN,
  1177. "REACHABILITY_FAILED DIRADDRESS=%s:%d",
  1178. me->address, me->dir_port);
  1179. }
  1180. }
  1181. /** If more than this many seconds have elapsed, probably the clock
  1182. * jumped: doesn't count. */
  1183. #define NUM_JUMPED_SECONDS_BEFORE_WARN 100
  1184. if (seconds_elapsed < -NUM_JUMPED_SECONDS_BEFORE_WARN ||
  1185. seconds_elapsed >= NUM_JUMPED_SECONDS_BEFORE_WARN) {
  1186. circuit_note_clock_jumped(seconds_elapsed);
  1187. /* XXX if the time jumps *back* many months, do our events in
  1188. * run_scheduled_events() recover? I don't think they do. -RD */
  1189. } else if (seconds_elapsed > 0)
  1190. stats_n_seconds_working += seconds_elapsed;
  1191. run_scheduled_events(now);
  1192. current_second = now; /* remember which second it is, for next time */
  1193. }
  1194. #ifndef MS_WINDOWS
  1195. /** Called when a possibly ignorable libevent error occurs; ensures that we
  1196. * don't get into an infinite loop by ignoring too many errors from
  1197. * libevent. */
  1198. static int
  1199. got_libevent_error(void)
  1200. {
  1201. if (++n_libevent_errors > 8) {
  1202. log_err(LD_NET, "Too many libevent errors in one second; dying");
  1203. return -1;
  1204. }
  1205. return 0;
  1206. }
  1207. #endif
  1208. #define UPTIME_CUTOFF_FOR_NEW_BANDWIDTH_TEST (6*60*60)
  1209. /** Called when our IP address seems to have changed. <b>at_interface</b>
  1210. * should be true if we detected a change in our interface, and false if we
  1211. * detected a change in our published address. */
  1212. void
  1213. ip_address_changed(int at_interface)
  1214. {
  1215. int server = server_mode(get_options());
  1216. if (at_interface) {
  1217. if (! server) {
  1218. /* Okay, change our keys. */
  1219. init_keys();
  1220. }
  1221. } else {
  1222. if (server) {
  1223. if (stats_n_seconds_working > UPTIME_CUTOFF_FOR_NEW_BANDWIDTH_TEST)
  1224. reset_bandwidth_test();
  1225. stats_n_seconds_working = 0;
  1226. router_reset_reachability();
  1227. mark_my_descriptor_dirty();
  1228. }
  1229. }
  1230. dns_servers_relaunch_checks();
  1231. }
  1232. /** Forget what we've learned about the correctness of our DNS servers, and
  1233. * start learning again. */
  1234. void
  1235. dns_servers_relaunch_checks(void)
  1236. {
  1237. if (server_mode(get_options())) {
  1238. dns_reset_correctness_checks();
  1239. time_to_check_for_correct_dns = 0;
  1240. }
  1241. }
  1242. /** Called when we get a SIGHUP: reload configuration files and keys,
  1243. * retry all connections, and so on. */
  1244. static int
  1245. do_hup(void)
  1246. {
  1247. or_options_t *options = get_options();
  1248. #ifdef USE_DMALLOC
  1249. dmalloc_log_stats();
  1250. dmalloc_log_changed(0, 1, 0, 0);
  1251. #endif
  1252. log_notice(LD_GENERAL,"Received reload signal (hup). Reloading config and "
  1253. "resetting internal state.");
  1254. if (accounting_is_enabled(options))
  1255. accounting_record_bandwidth_usage(time(NULL), get_or_state());
  1256. router_reset_warnings();
  1257. routerlist_reset_warnings();
  1258. addressmap_clear_transient();
  1259. /* first, reload config variables, in case they've changed */
  1260. if (options->ReloadTorrcOnSIGHUP) {
  1261. /* no need to provide argc/v, they've been cached in init_from_config */
  1262. if (options_init_from_torrc(0, NULL) < 0) {
  1263. log_err(LD_CONFIG,"Reading config failed--see warnings above. "
  1264. "For usage, try -h.");
  1265. return -1;
  1266. }
  1267. options = get_options(); /* they have changed now */
  1268. } else {
  1269. log_notice(LD_GENERAL, "Not reloading config file: the controller told "
  1270. "us not to.");
  1271. }
  1272. if (authdir_mode_handles_descs(options, -1)) {
  1273. /* reload the approved-routers file */
  1274. if (dirserv_load_fingerprint_file() < 0) {
  1275. /* warnings are logged from dirserv_load_fingerprint_file() directly */
  1276. log_info(LD_GENERAL, "Error reloading fingerprints. "
  1277. "Continuing with old list.");
  1278. }
  1279. }
  1280. /* Rotate away from the old dirty circuits. This has to be done
  1281. * after we've read the new options, but before we start using
  1282. * circuits for directory fetches. */
  1283. circuit_expire_all_dirty_circs();
  1284. /* retry appropriate downloads */
  1285. router_reset_status_download_failures();
  1286. router_reset_descriptor_download_failures();
  1287. update_networkstatus_downloads(time(NULL));
  1288. /* We'll retry routerstatus downloads in about 10 seconds; no need to
  1289. * force a retry there. */
  1290. if (server_mode(options)) {
  1291. /* Restart cpuworker and dnsworker processes, so they get up-to-date
  1292. * configuration options. */
  1293. cpuworkers_rotate();
  1294. dns_reset();
  1295. }
  1296. return 0;
  1297. }
  1298. /** Tor main loop. */
  1299. /* static */ int
  1300. do_main_loop(void)
  1301. {
  1302. int loop_result;
  1303. time_t now;
  1304. /* initialize dns resolve map, spawn workers if needed */
  1305. if (dns_init() < 0) {
  1306. if (get_options()->ServerDNSAllowBrokenConfig)
  1307. log_warn(LD_GENERAL, "Couldn't set up any working nameservers. "
  1308. "Network not up yet? Will try again soon.");
  1309. else {
  1310. log_err(LD_GENERAL,"Error initializing dns subsystem; exiting. To "
  1311. "retry instead, set the ServerDNSAllowBrokenResolvConf option.");
  1312. }
  1313. }
  1314. handle_signals(1);
  1315. /* load the private keys, if we're supposed to have them, and set up the
  1316. * TLS context. */
  1317. if (! identity_key_is_set()) {
  1318. if (init_keys() < 0) {
  1319. log_err(LD_BUG,"Error initializing keys; exiting");
  1320. return -1;
  1321. }
  1322. }
  1323. /* Set up the packed_cell_t memory pool. */
  1324. init_cell_pool();
  1325. /* Set up our buckets */
  1326. connection_bucket_init();
  1327. stats_prev_global_read_bucket = global_read_bucket;
  1328. stats_prev_global_write_bucket = global_write_bucket;
  1329. /* initialize the bootstrap status events to know we're starting up */
  1330. control_event_bootstrap(BOOTSTRAP_STATUS_STARTING, 0);
  1331. if (trusted_dirs_reload_certs()) {
  1332. log_warn(LD_DIR,
  1333. "Couldn't load all cached v3 certificates. Starting anyway.");
  1334. }
  1335. if (router_reload_v2_networkstatus()) {
  1336. return -1;
  1337. }
  1338. if (router_reload_consensus_networkstatus()) {
  1339. return -1;
  1340. }
  1341. /* load the routers file, or assign the defaults. */
  1342. if (router_reload_router_list()) {
  1343. return -1;
  1344. }
  1345. /* load the networkstatuses. (This launches a download for new routers as
  1346. * appropriate.)
  1347. */
  1348. now = time(NULL);
  1349. directory_info_has_arrived(now, 1);
  1350. if (server_mode(get_options())) {
  1351. /* launch cpuworkers. Need to do this *after* we've read the onion key. */
  1352. cpu_init();
  1353. }
  1354. /* set up once-a-second callback. */
  1355. if (! second_timer) {
  1356. struct timeval one_second;
  1357. one_second.tv_sec = 1;
  1358. one_second.tv_usec = 0;
  1359. second_timer = periodic_timer_new(tor_libevent_get_base(),
  1360. &one_second,
  1361. second_elapsed_callback,
  1362. NULL);
  1363. tor_assert(second_timer);
  1364. }
  1365. for (;;) {
  1366. if (nt_service_is_stopping())
  1367. return 0;
  1368. #ifndef MS_WINDOWS
  1369. /* Make it easier to tell whether libevent failure is our fault or not. */
  1370. errno = 0;
  1371. #endif
  1372. /* All active linked conns should get their read events activated. */
  1373. SMARTLIST_FOREACH(active_linked_connection_lst, connection_t *, conn,
  1374. event_active(conn->read_event, EV_READ, 1));
  1375. called_loop_once = smartlist_len(active_linked_connection_lst) ? 1 : 0;
  1376. update_approx_time(time(NULL));
  1377. /* poll until we have an event, or the second ends, or until we have
  1378. * some active linked connections to trigger events for. */
  1379. loop_result = event_base_loop(tor_libevent_get_base(),
  1380. called_loop_once ? EVLOOP_ONCE : 0);
  1381. /* let catch() handle things like ^c, and otherwise don't worry about it */
  1382. if (loop_result < 0) {
  1383. int e = tor_socket_errno(-1);
  1384. /* let the program survive things like ^z */
  1385. if (e != EINTR && !ERRNO_IS_EINPROGRESS(e)) {
  1386. log_err(LD_NET,"libevent call with %s failed: %s [%d]",
  1387. tor_libevent_get_method(), tor_socket_strerror(e), e);
  1388. return -1;
  1389. #ifndef MS_WINDOWS
  1390. } else if (e == EINVAL) {
  1391. log_warn(LD_NET, "EINVAL from libevent: should you upgrade libevent?");
  1392. if (got_libevent_error())
  1393. return -1;
  1394. #endif
  1395. } else {
  1396. if (ERRNO_IS_EINPROGRESS(e))
  1397. log_warn(LD_BUG,
  1398. "libevent call returned EINPROGRESS? Please report.");
  1399. log_debug(LD_NET,"libevent call interrupted.");
  1400. /* You can't trust the results of this poll(). Go back to the
  1401. * top of the big for loop. */
  1402. continue;
  1403. }
  1404. }
  1405. }
  1406. }
  1407. /** Used to implement the SIGNAL control command: if we accept
  1408. * <b>the_signal</b> as a remote pseudo-signal, act on it. */
  1409. /* We don't re-use catch() here because:
  1410. * 1. We handle a different set of signals than those allowed in catch.
  1411. * 2. Platforms without signal() are unlikely to define SIGfoo.
  1412. * 3. The control spec is defined to use fixed numeric signal values
  1413. * which just happen to match the Unix values.
  1414. */
  1415. void
  1416. control_signal_act(int the_signal)
  1417. {
  1418. switch (the_signal)
  1419. {
  1420. case 1:
  1421. signal_callback(0,0,(void*)(uintptr_t)SIGHUP);
  1422. break;
  1423. case 2:
  1424. signal_callback(0,0,(void*)(uintptr_t)SIGINT);
  1425. break;
  1426. case 10:
  1427. signal_callback(0,0,(void*)(uintptr_t)SIGUSR1);
  1428. break;
  1429. case 12:
  1430. signal_callback(0,0,(void*)(uintptr_t)SIGUSR2);
  1431. break;
  1432. case 15:
  1433. signal_callback(0,0,(void*)(uintptr_t)SIGTERM);
  1434. break;
  1435. case SIGNEWNYM:
  1436. signal_callback(0,0,(void*)(uintptr_t)SIGNEWNYM);
  1437. break;
  1438. case SIGCLEARDNSCACHE:
  1439. signal_callback(0,0,(void*)(uintptr_t)SIGCLEARDNSCACHE);
  1440. break;
  1441. default:
  1442. log_warn(LD_BUG, "Unrecognized signal number %d.", the_signal);
  1443. break;
  1444. }
  1445. }
  1446. /** Libevent callback: invoked when we get a signal.
  1447. */
  1448. static void
  1449. signal_callback(int fd, short events, void *arg)
  1450. {
  1451. uintptr_t sig = (uintptr_t)arg;
  1452. (void)fd;
  1453. (void)events;
  1454. switch (sig)
  1455. {
  1456. case SIGTERM:
  1457. log_notice(LD_GENERAL,"Catching signal TERM, exiting cleanly.");
  1458. tor_cleanup();
  1459. exit(0);
  1460. break;
  1461. case SIGINT:
  1462. if (!server_mode(get_options())) { /* do it now */
  1463. log_notice(LD_GENERAL,"Interrupt: exiting cleanly.");
  1464. tor_cleanup();
  1465. exit(0);
  1466. }
  1467. hibernate_begin_shutdown();
  1468. break;
  1469. #ifdef SIGPIPE
  1470. case SIGPIPE:
  1471. log_debug(LD_GENERAL,"Caught SIGPIPE. Ignoring.");
  1472. break;
  1473. #endif
  1474. case SIGUSR1:
  1475. /* prefer to log it at INFO, but make sure we always see it */
  1476. dumpstats(get_min_log_level()<LOG_INFO ? get_min_log_level() : LOG_INFO);
  1477. break;
  1478. case SIGUSR2:
  1479. switch_logs_debug();
  1480. log_debug(LD_GENERAL,"Caught USR2, going to loglevel debug. "
  1481. "Send HUP to change back.");
  1482. break;
  1483. case SIGHUP:
  1484. if (do_hup() < 0) {
  1485. log_warn(LD_CONFIG,"Restart failed (config error?). Exiting.");
  1486. tor_cleanup();
  1487. exit(1);
  1488. }
  1489. break;
  1490. #ifdef SIGCHLD
  1491. case SIGCHLD:
  1492. while (waitpid(-1,NULL,WNOHANG) > 0) ; /* keep reaping until no more
  1493. zombies */
  1494. break;
  1495. #endif
  1496. case SIGNEWNYM: {
  1497. time_t now = time(NULL);
  1498. if (time_of_last_signewnym + MAX_SIGNEWNYM_RATE > now) {
  1499. signewnym_is_pending = 1;
  1500. log(LOG_NOTICE, LD_CONTROL,
  1501. "Rate limiting NEWNYM request: delaying by %d second(s)",
  1502. (int)(MAX_SIGNEWNYM_RATE+time_of_last_signewnym-now));
  1503. } else {
  1504. signewnym_impl(now);
  1505. }
  1506. break;
  1507. }
  1508. case SIGCLEARDNSCACHE:
  1509. addressmap_clear_transient();
  1510. break;
  1511. }
  1512. }
  1513. extern uint64_t rephist_total_alloc;
  1514. extern uint32_t rephist_total_num;
  1515. /**
  1516. * Write current memory usage information to the log.
  1517. */
  1518. static void
  1519. dumpmemusage(int severity)
  1520. {
  1521. connection_dump_buffer_mem_stats(severity);
  1522. log(severity, LD_GENERAL, "In rephist: "U64_FORMAT" used by %d Tors.",
  1523. U64_PRINTF_ARG(rephist_total_alloc), rephist_total_num);
  1524. dump_routerlist_mem_usage(severity);
  1525. dump_cell_pool_usage(severity);
  1526. dump_dns_mem_usage(severity);
  1527. buf_dump_freelist_sizes(severity);
  1528. tor_log_mallinfo(severity);
  1529. }
  1530. /** Write all statistics to the log, with log level <b>severity</b>. Called
  1531. * in response to a SIGUSR1. */
  1532. static void
  1533. dumpstats(int severity)
  1534. {
  1535. time_t now = time(NULL);
  1536. time_t elapsed;
  1537. size_t rbuf_cap, wbuf_cap, rbuf_len, wbuf_len;
  1538. log(severity, LD_GENERAL, "Dumping stats:");
  1539. SMARTLIST_FOREACH(connection_array, connection_t *, conn,
  1540. {
  1541. int i = conn_sl_idx;
  1542. log(severity, LD_GENERAL,
  1543. "Conn %d (socket %d) type %d (%s), state %d (%s), created %d secs ago",
  1544. i, conn->s, conn->type, conn_type_to_string(conn->type),
  1545. conn->state, conn_state_to_string(conn->type, conn->state),
  1546. (int)(now - conn->timestamp_created));
  1547. if (!connection_is_listener(conn)) {
  1548. log(severity,LD_GENERAL,
  1549. "Conn %d is to %s:%d.", i,
  1550. safe_str_client(conn->address),
  1551. conn->port);
  1552. log(severity,LD_GENERAL,
  1553. "Conn %d: %d bytes waiting on inbuf (len %d, last read %d secs ago)",
  1554. i,
  1555. (int)buf_datalen(conn->inbuf),
  1556. (int)buf_allocation(conn->inbuf),
  1557. (int)(now - conn->timestamp_lastread));
  1558. log(severity,LD_GENERAL,
  1559. "Conn %d: %d bytes waiting on outbuf "
  1560. "(len %d, last written %d secs ago)",i,
  1561. (int)buf_datalen(conn->outbuf),
  1562. (int)buf_allocation(conn->outbuf),
  1563. (int)(now - conn->timestamp_lastwritten));
  1564. if (conn->type == CONN_TYPE_OR) {
  1565. or_connection_t *or_conn = TO_OR_CONN(conn);
  1566. if (or_conn->tls) {
  1567. tor_tls_get_buffer_sizes(or_conn->tls, &rbuf_cap, &rbuf_len,
  1568. &wbuf_cap, &wbuf_len);
  1569. log(severity, LD_GENERAL,
  1570. "Conn %d: %d/%d bytes used on OpenSSL read buffer; "
  1571. "%d/%d bytes used on write buffer.",
  1572. i, (int)rbuf_len, (int)rbuf_cap, (int)wbuf_len, (int)wbuf_cap);
  1573. }
  1574. }
  1575. }
  1576. circuit_dump_by_conn(conn, severity); /* dump info about all the circuits
  1577. * using this conn */
  1578. });
  1579. log(severity, LD_NET,
  1580. "Cells processed: "U64_FORMAT" padding\n"
  1581. " "U64_FORMAT" create\n"
  1582. " "U64_FORMAT" created\n"
  1583. " "U64_FORMAT" relay\n"
  1584. " ("U64_FORMAT" relayed)\n"
  1585. " ("U64_FORMAT" delivered)\n"
  1586. " "U64_FORMAT" destroy",
  1587. U64_PRINTF_ARG(stats_n_padding_cells_processed),
  1588. U64_PRINTF_ARG(stats_n_create_cells_processed),
  1589. U64_PRINTF_ARG(stats_n_created_cells_processed),
  1590. U64_PRINTF_ARG(stats_n_relay_cells_processed),
  1591. U64_PRINTF_ARG(stats_n_relay_cells_relayed),
  1592. U64_PRINTF_ARG(stats_n_relay_cells_delivered),
  1593. U64_PRINTF_ARG(stats_n_destroy_cells_processed));
  1594. if (stats_n_data_cells_packaged)
  1595. log(severity,LD_NET,"Average packaged cell fullness: %2.3f%%",
  1596. 100*(U64_TO_DBL(stats_n_data_bytes_packaged) /
  1597. U64_TO_DBL(stats_n_data_cells_packaged*RELAY_PAYLOAD_SIZE)) );
  1598. if (stats_n_data_cells_received)
  1599. log(severity,LD_NET,"Average delivered cell fullness: %2.3f%%",
  1600. 100*(U64_TO_DBL(stats_n_data_bytes_received) /
  1601. U64_TO_DBL(stats_n_data_cells_received*RELAY_PAYLOAD_SIZE)) );
  1602. if (now - time_of_process_start >= 0)
  1603. elapsed = now - time_of_process_start;
  1604. else
  1605. elapsed = 0;
  1606. if (elapsed) {
  1607. log(severity, LD_NET,
  1608. "Average bandwidth: "U64_FORMAT"/%d = %d bytes/sec reading",
  1609. U64_PRINTF_ARG(stats_n_bytes_read),
  1610. (int)elapsed,
  1611. (int) (stats_n_bytes_read/elapsed));
  1612. log(severity, LD_NET,
  1613. "Average bandwidth: "U64_FORMAT"/%d = %d bytes/sec writing",
  1614. U64_PRINTF_ARG(stats_n_bytes_written),
  1615. (int)elapsed,
  1616. (int) (stats_n_bytes_written/elapsed));
  1617. }
  1618. log(severity, LD_NET, "--------------- Dumping memory information:");
  1619. dumpmemusage(severity);
  1620. rep_hist_dump_stats(now,severity);
  1621. rend_service_dump_stats(severity);
  1622. dump_pk_ops(severity);
  1623. dump_distinct_digest_count(severity);
  1624. }
  1625. /** Called by exit() as we shut down the process.
  1626. */
  1627. static void
  1628. exit_function(void)
  1629. {
  1630. /* NOTE: If we ever daemonize, this gets called immediately. That's
  1631. * okay for now, because we only use this on Windows. */
  1632. #ifdef MS_WINDOWS
  1633. WSACleanup();
  1634. #endif
  1635. }
  1636. /** Set up the signal handlers for either parent or child. */
  1637. void
  1638. handle_signals(int is_parent)
  1639. {
  1640. #ifndef MS_WINDOWS /* do signal stuff only on Unix */
  1641. int i;
  1642. static const int signals[] = {
  1643. SIGINT, /* do a controlled slow shutdown */
  1644. SIGTERM, /* to terminate now */
  1645. SIGPIPE, /* otherwise SIGPIPE kills us */
  1646. SIGUSR1, /* dump stats */
  1647. SIGUSR2, /* go to loglevel debug */
  1648. SIGHUP, /* to reload config, retry conns, etc */
  1649. #ifdef SIGXFSZ
  1650. SIGXFSZ, /* handle file-too-big resource exhaustion */
  1651. #endif
  1652. SIGCHLD, /* handle dns/cpu workers that exit */
  1653. -1 };
  1654. static struct event *signal_events[16]; /* bigger than it has to be. */
  1655. if (is_parent) {
  1656. for (i = 0; signals[i] >= 0; ++i) {
  1657. signal_events[i] = tor_evsignal_new(
  1658. tor_libevent_get_base(), signals[i], signal_callback,
  1659. (void*)(uintptr_t)signals[i]);
  1660. if (event_add(signal_events[i], NULL))
  1661. log_warn(LD_BUG, "Error from libevent when adding event for signal %d",
  1662. signals[i]);
  1663. }
  1664. } else {
  1665. struct sigaction action;
  1666. action.sa_flags = 0;
  1667. sigemptyset(&action.sa_mask);
  1668. action.sa_handler = SIG_IGN;
  1669. sigaction(SIGINT, &action, NULL);
  1670. sigaction(SIGTERM, &action, NULL);
  1671. sigaction(SIGPIPE, &action, NULL);
  1672. sigaction(SIGUSR1, &action, NULL);
  1673. sigaction(SIGUSR2, &action, NULL);
  1674. sigaction(SIGHUP, &action, NULL);
  1675. #ifdef SIGXFSZ
  1676. sigaction(SIGXFSZ, &action, NULL);
  1677. #endif
  1678. }
  1679. #else /* MS windows */
  1680. (void)is_parent;
  1681. #endif /* signal stuff */
  1682. }
  1683. /** Main entry point for the Tor command-line client.
  1684. */
  1685. /* static */ int
  1686. tor_init(int argc, char *argv[])
  1687. {
  1688. char buf[256];
  1689. int i, quiet = 0;
  1690. time_of_process_start = time(NULL);
  1691. if (!connection_array)
  1692. connection_array = smartlist_create();
  1693. if (!closeable_connection_lst)
  1694. closeable_connection_lst = smartlist_create();
  1695. if (!active_linked_connection_lst)
  1696. active_linked_connection_lst = smartlist_create();
  1697. /* Have the log set up with our application name. */
  1698. tor_snprintf(buf, sizeof(buf), "Tor %s", get_version());
  1699. log_set_application_name(buf);
  1700. /* Initialize the history structures. */
  1701. rep_hist_init();
  1702. /* Initialize the service cache. */
  1703. rend_cache_init();
  1704. addressmap_init(); /* Init the client dns cache. Do it always, since it's
  1705. * cheap. */
  1706. /* We search for the "quiet" option first, since it decides whether we
  1707. * will log anything at all to the command line. */
  1708. for (i=1;i<argc;++i) {
  1709. if (!strcmp(argv[i], "--hush"))
  1710. quiet = 1;
  1711. if (!strcmp(argv[i], "--quiet"))
  1712. quiet = 2;
  1713. }
  1714. /* give it somewhere to log to initially */
  1715. switch (quiet) {
  1716. case 2:
  1717. /* no initial logging */
  1718. break;
  1719. case 1:
  1720. add_temp_log(LOG_WARN);
  1721. break;
  1722. default:
  1723. add_temp_log(LOG_NOTICE);
  1724. }
  1725. log(LOG_NOTICE, LD_GENERAL, "Tor v%s. This is experimental software. "
  1726. "Do not rely on it for strong anonymity. (Running on %s)",get_version(),
  1727. get_uname());
  1728. if (network_init()<0) {
  1729. log_err(LD_BUG,"Error initializing network; exiting.");
  1730. return -1;
  1731. }
  1732. atexit(exit_function);
  1733. if (options_init_from_torrc(argc,argv) < 0) {
  1734. log_err(LD_CONFIG,"Reading config failed--see warnings above.");
  1735. return -1;
  1736. }
  1737. #ifndef MS_WINDOWS
  1738. if (geteuid()==0)
  1739. log_warn(LD_GENERAL,"You are running Tor as root. You don't need to, "
  1740. "and you probably shouldn't.");
  1741. #endif
  1742. if (crypto_global_init(get_options()->HardwareAccel,
  1743. get_options()->AccelName,
  1744. get_options()->AccelDir)) {
  1745. log_err(LD_BUG, "Unable to initialize OpenSSL. Exiting.");
  1746. return -1;
  1747. }
  1748. return 0;
  1749. }
  1750. /** A lockfile structure, used to prevent two Tors from messing with the
  1751. * data directory at once. If this variable is non-NULL, we're holding
  1752. * the lockfile. */
  1753. static tor_lockfile_t *lockfile = NULL;
  1754. /** Try to grab the lock file described in <b>options</b>, if we do not
  1755. * already have it. If <b>err_if_locked</b> is true, warn if somebody else is
  1756. * holding the lock, and exit if we can't get it after waiting. Otherwise,
  1757. * return -1 if we can't get the lockfile. Return 0 on success.
  1758. */
  1759. int
  1760. try_locking(or_options_t *options, int err_if_locked)
  1761. {
  1762. if (lockfile)
  1763. return 0;
  1764. else {
  1765. char *fname = options_get_datadir_fname2_suffix(options, "lock",NULL,NULL);
  1766. int already_locked = 0;
  1767. tor_lockfile_t *lf = tor_lockfile_lock(fname, 0, &already_locked);
  1768. tor_free(fname);
  1769. if (!lf) {
  1770. if (err_if_locked && already_locked) {
  1771. int r;
  1772. log_warn(LD_GENERAL, "It looks like another Tor process is running "
  1773. "with the same data directory. Waiting 5 seconds to see "
  1774. "if it goes away.");
  1775. #ifndef WIN32
  1776. sleep(5);
  1777. #else
  1778. Sleep(5000);
  1779. #endif
  1780. r = try_locking(options, 0);
  1781. if (r<0) {
  1782. log_err(LD_GENERAL, "No, it's still there. Exiting.");
  1783. exit(0);
  1784. }
  1785. return r;
  1786. }
  1787. return -1;
  1788. }
  1789. lockfile = lf;
  1790. return 0;
  1791. }
  1792. }
  1793. /** Return true iff we've successfully acquired the lock file. */
  1794. int
  1795. have_lockfile(void)
  1796. {
  1797. return lockfile != NULL;
  1798. }
  1799. /** If we have successfully acquired the lock file, release it. */
  1800. void
  1801. release_lockfile(void)
  1802. {
  1803. if (lockfile) {
  1804. tor_lockfile_unlock(lockfile);
  1805. lockfile = NULL;
  1806. }
  1807. }
  1808. /** Free all memory that we might have allocated somewhere.
  1809. * If <b>postfork</b>, we are a worker process and we want to free
  1810. * only the parts of memory that we won't touch. If !<b>postfork</b>,
  1811. * Tor is shutting down and we should free everything.
  1812. *
  1813. * Helps us find the real leaks with dmalloc and the like. Also valgrind
  1814. * should then report 0 reachable in its leak report (in an ideal world --
  1815. * in practice libevent, SSL, libc etc never quite free everything). */
  1816. void
  1817. tor_free_all(int postfork)
  1818. {
  1819. if (!postfork) {
  1820. evdns_shutdown(1);
  1821. }
  1822. geoip_free_all();
  1823. dirvote_free_all();
  1824. routerlist_free_all();
  1825. networkstatus_free_all();
  1826. addressmap_free_all();
  1827. dirserv_free_all();
  1828. rend_service_free_all();
  1829. rend_cache_free_all();
  1830. rend_service_authorization_free_all();
  1831. rep_hist_free_all();
  1832. dns_free_all();
  1833. clear_pending_onions();
  1834. circuit_free_all();
  1835. entry_guards_free_all();
  1836. connection_free_all();
  1837. buf_shrink_freelists(1);
  1838. memarea_clear_freelist();
  1839. microdesc_free_all();
  1840. if (!postfork) {
  1841. config_free_all();
  1842. router_free_all();
  1843. policies_free_all();
  1844. }
  1845. free_cell_pool();
  1846. if (!postfork) {
  1847. tor_tls_free_all();
  1848. }
  1849. /* stuff in main.c */
  1850. smartlist_free(connection_array);
  1851. smartlist_free(closeable_connection_lst);
  1852. smartlist_free(active_linked_connection_lst);
  1853. periodic_timer_free(second_timer);
  1854. if (!postfork) {
  1855. release_lockfile();
  1856. }
  1857. /* Stuff in util.c and address.c*/
  1858. if (!postfork) {
  1859. escaped(NULL);
  1860. esc_router_info(NULL);
  1861. logs_free_all(); /* free log strings. do this last so logs keep working. */
  1862. }
  1863. }
  1864. /** Do whatever cleanup is necessary before shutting Tor down. */
  1865. void
  1866. tor_cleanup(void)
  1867. {
  1868. or_options_t *options = get_options();
  1869. /* Remove our pid file. We don't care if there was an error when we
  1870. * unlink, nothing we could do about it anyways. */
  1871. if (options->command == CMD_RUN_TOR) {
  1872. time_t now = time(NULL);
  1873. if (options->PidFile)
  1874. unlink(options->PidFile);
  1875. if (accounting_is_enabled(options))
  1876. accounting_record_bandwidth_usage(now, get_or_state());
  1877. or_state_mark_dirty(get_or_state(), 0); /* force an immediate save. */
  1878. or_state_save(now);
  1879. if (authdir_mode_tests_reachability(options))
  1880. rep_hist_record_mtbf_data(now, 0);
  1881. }
  1882. #ifdef USE_DMALLOC
  1883. dmalloc_log_stats();
  1884. #endif
  1885. tor_free_all(0); /* We could move tor_free_all back into the ifdef below
  1886. later, if it makes shutdown unacceptably slow. But for
  1887. now, leave it here: it's helped us catch bugs in the
  1888. past. */
  1889. crypto_global_cleanup();
  1890. #ifdef USE_DMALLOC
  1891. dmalloc_log_unfreed();
  1892. dmalloc_shutdown();
  1893. #endif
  1894. }
  1895. /** Read/create keys as needed, and echo our fingerprint to stdout. */
  1896. /* static */ int
  1897. do_list_fingerprint(void)
  1898. {
  1899. char buf[FINGERPRINT_LEN+1];
  1900. crypto_pk_env_t *k;
  1901. const char *nickname = get_options()->Nickname;
  1902. if (!server_mode(get_options())) {
  1903. log_err(LD_GENERAL,
  1904. "Clients don't have long-term identity keys. Exiting.\n");
  1905. return -1;
  1906. }
  1907. tor_assert(nickname);
  1908. if (init_keys() < 0) {
  1909. log_err(LD_BUG,"Error initializing keys; can't display fingerprint");
  1910. return -1;
  1911. }
  1912. if (!(k = get_identity_key())) {
  1913. log_err(LD_GENERAL,"Error: missing identity key.");
  1914. return -1;
  1915. }
  1916. if (crypto_pk_get_fingerprint(k, buf, 1)<0) {
  1917. log_err(LD_BUG, "Error computing fingerprint");
  1918. return -1;
  1919. }
  1920. printf("%s %s\n", nickname, buf);
  1921. return 0;
  1922. }
  1923. /** Entry point for password hashing: take the desired password from
  1924. * the command line, and print its salted hash to stdout. **/
  1925. /* static */ void
  1926. do_hash_password(void)
  1927. {
  1928. char output[256];
  1929. char key[S2K_SPECIFIER_LEN+DIGEST_LEN];
  1930. crypto_rand(key, S2K_SPECIFIER_LEN-1);
  1931. key[S2K_SPECIFIER_LEN-1] = (uint8_t)96; /* Hash 64 K of data. */
  1932. secret_to_key(key+S2K_SPECIFIER_LEN, DIGEST_LEN,
  1933. get_options()->command_arg, strlen(get_options()->command_arg),
  1934. key);
  1935. base16_encode(output, sizeof(output), key, sizeof(key));
  1936. printf("16:%s\n",output);
  1937. }
  1938. #if defined (WINCE)
  1939. int
  1940. find_flashcard_path(PWCHAR path, size_t size)
  1941. {
  1942. WIN32_FIND_DATA d = {0};
  1943. HANDLE h = NULL;
  1944. if (!path)
  1945. return -1;
  1946. h = FindFirstFlashCard(&d);
  1947. if (h == INVALID_HANDLE_VALUE)
  1948. return -1;
  1949. if (wcslen(d.cFileName) == 0) {
  1950. FindClose(h);
  1951. return -1;
  1952. }
  1953. wcsncpy(path,d.cFileName,size);
  1954. FindClose(h);
  1955. return 0;
  1956. }
  1957. #endif
  1958. /** Main entry point for the Tor process. Called from main(). */
  1959. /* This function is distinct from main() only so we can link main.c into
  1960. * the unittest binary without conflicting with the unittests' main. */
  1961. int
  1962. tor_main(int argc, char *argv[])
  1963. {
  1964. int result = 0;
  1965. #if defined (WINCE)
  1966. WCHAR path [MAX_PATH] = {0};
  1967. WCHAR fullpath [MAX_PATH] = {0};
  1968. PWCHAR p = NULL;
  1969. FILE* redir = NULL;
  1970. FILE* redirdbg = NULL;
  1971. // this is to facilitate debugging by opening
  1972. // a file on a folder shared by the wm emulator.
  1973. // if no flashcard (real or emulated) is present,
  1974. // log files will be written in the root folder
  1975. if (find_flashcard_path(path,MAX_PATH) == -1)
  1976. {
  1977. redir = _wfreopen( L"\\stdout.log", L"w", stdout );
  1978. redirdbg = _wfreopen( L"\\stderr.log", L"w", stderr );
  1979. } else {
  1980. swprintf(fullpath,L"\\%s\\tor",path);
  1981. CreateDirectory(fullpath,NULL);
  1982. swprintf(fullpath,L"\\%s\\tor\\stdout.log",path);
  1983. redir = _wfreopen( fullpath, L"w", stdout );
  1984. swprintf(fullpath,L"\\%s\\tor\\stderr.log",path);
  1985. redirdbg = _wfreopen( fullpath, L"w", stderr );
  1986. }
  1987. #endif
  1988. update_approx_time(time(NULL));
  1989. tor_threads_init();
  1990. init_logging();
  1991. #ifdef USE_DMALLOC
  1992. {
  1993. /* Instruct OpenSSL to use our internal wrappers for malloc,
  1994. realloc and free. */
  1995. int r = CRYPTO_set_mem_ex_functions(_tor_malloc, _tor_realloc, _tor_free);
  1996. tor_assert(r);
  1997. }
  1998. #endif
  1999. #ifdef NT_SERVICE
  2000. {
  2001. int done = 0;
  2002. result = nt_service_parse_options(argc, argv, &done);
  2003. if (done) return result;
  2004. }
  2005. #endif
  2006. if (tor_init(argc, argv)<0)
  2007. return -1;
  2008. switch (get_options()->command) {
  2009. case CMD_RUN_TOR:
  2010. #ifdef NT_SERVICE
  2011. nt_service_set_state(SERVICE_RUNNING);
  2012. #endif
  2013. result = do_main_loop();
  2014. break;
  2015. case CMD_LIST_FINGERPRINT:
  2016. result = do_list_fingerprint();
  2017. break;
  2018. case CMD_HASH_PASSWORD:
  2019. do_hash_password();
  2020. result = 0;
  2021. break;
  2022. case CMD_VERIFY_CONFIG:
  2023. printf("Configuration was valid\n");
  2024. result = 0;
  2025. break;
  2026. case CMD_RUN_UNITTESTS: /* only set by test.c */
  2027. default:
  2028. log_warn(LD_BUG,"Illegal command number %d: internal error.",
  2029. get_options()->command);
  2030. result = -1;
  2031. }
  2032. tor_cleanup();
  2033. return result;
  2034. }