main.c 99 KB

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