main.c 100 KB

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