main.c 74 KB

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