main.c 74 KB

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