networkstatus.c 99 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779
  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-2019, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  6. /**
  7. * \file networkstatus.c
  8. * \brief Functions and structures for handling networkstatus documents as a
  9. * client or as a directory cache.
  10. *
  11. * A consensus networkstatus object is created by the directory
  12. * authorities. It authenticates a set of network parameters--most
  13. * importantly, the list of all the relays in the network. This list
  14. * of relays is represented as an array of routerstatus_t objects.
  15. *
  16. * There are currently two flavors of consensus. With the older "NS"
  17. * flavor, each relay is associated with a digest of its router
  18. * descriptor. Tor instances that use this consensus keep the list of
  19. * router descriptors as routerinfo_t objects stored and managed in
  20. * routerlist.c. With the newer "microdesc" flavor, each relay is
  21. * associated with a digest of the microdescriptor that the authorities
  22. * made for it. These are stored and managed in microdesc.c. Information
  23. * about the router is divided between the the networkstatus and the
  24. * microdescriptor according to the general rule that microdescriptors
  25. * should hold information that changes much less frequently than the
  26. * information in the networkstatus.
  27. *
  28. * Modern clients use microdescriptor networkstatuses. Directory caches
  29. * need to keep both kinds of networkstatus document, so they can serve them.
  30. *
  31. * This module manages fetching, holding, storing, updating, and
  32. * validating networkstatus objects. The download-and-validate process
  33. * is slightly complicated by the fact that the keys you need to
  34. * validate a consensus are stored in the authority certificates, which
  35. * you might not have yet when you download the consensus.
  36. */
  37. #define NETWORKSTATUS_PRIVATE
  38. #include "core/or/or.h"
  39. #include "app/config/config.h"
  40. #include "core/mainloop/connection.h"
  41. #include "core/mainloop/mainloop.h"
  42. #include "core/mainloop/netstatus.h"
  43. #include "core/or/channel.h"
  44. #include "core/or/channelpadding.h"
  45. #include "core/or/circuitpadding.h"
  46. #include "core/or/circuitmux.h"
  47. #include "core/or/circuitmux_ewma.h"
  48. #include "core/or/circuitstats.h"
  49. #include "core/or/connection_edge.h"
  50. #include "core/or/connection_or.h"
  51. #include "core/or/dos.h"
  52. #include "core/or/protover.h"
  53. #include "core/or/relay.h"
  54. #include "core/or/scheduler.h"
  55. #include "core/or/versions.h"
  56. #include "feature/client/bridges.h"
  57. #include "feature/client/entrynodes.h"
  58. #include "feature/client/transports.h"
  59. #include "feature/control/control_events.h"
  60. #include "feature/dirauth/reachability.h"
  61. #include "feature/dircache/consdiffmgr.h"
  62. #include "feature/dircache/dirserv.h"
  63. #include "feature/dirclient/dirclient.h"
  64. #include "feature/dirclient/dlstatus.h"
  65. #include "feature/dircommon/directory.h"
  66. #include "feature/dircommon/voting_schedule.h"
  67. #include "feature/dirparse/ns_parse.h"
  68. #include "feature/hibernate/hibernate.h"
  69. #include "feature/nodelist/authcert.h"
  70. #include "feature/nodelist/dirlist.h"
  71. #include "feature/nodelist/fmt_routerstatus.h"
  72. #include "feature/nodelist/microdesc.h"
  73. #include "feature/nodelist/networkstatus.h"
  74. #include "feature/nodelist/node_select.h"
  75. #include "feature/nodelist/nodelist.h"
  76. #include "feature/nodelist/routerinfo.h"
  77. #include "feature/nodelist/routerlist.h"
  78. #include "feature/nodelist/torcert.h"
  79. #include "feature/relay/routermode.h"
  80. #include "lib/crypt_ops/crypto_rand.h"
  81. #include "lib/crypt_ops/crypto_util.h"
  82. #include "feature/dirauth/dirauth_periodic.h"
  83. #include "feature/dirauth/dirvote.h"
  84. #include "feature/dirauth/authmode.h"
  85. #include "feature/dirauth/shared_random.h"
  86. #include "feature/dirauth/voteflags.h"
  87. #include "feature/nodelist/authority_cert_st.h"
  88. #include "feature/dircommon/dir_connection_st.h"
  89. #include "feature/dirclient/dir_server_st.h"
  90. #include "feature/nodelist/document_signature_st.h"
  91. #include "feature/nodelist/networkstatus_st.h"
  92. #include "feature/nodelist/networkstatus_voter_info_st.h"
  93. #include "feature/dirauth/ns_detached_signatures_st.h"
  94. #include "feature/nodelist/node_st.h"
  95. #include "feature/nodelist/routerinfo_st.h"
  96. #include "feature/nodelist/routerlist_st.h"
  97. #include "feature/dirauth/vote_microdesc_hash_st.h"
  98. #include "feature/nodelist/vote_routerstatus_st.h"
  99. #ifdef HAVE_UNISTD_H
  100. #include <unistd.h>
  101. #endif
  102. /** Most recently received and validated v3 "ns"-flavored consensus network
  103. * status. */
  104. STATIC networkstatus_t *current_ns_consensus = NULL;
  105. /** Most recently received and validated v3 "microdesc"-flavored consensus
  106. * network status. */
  107. STATIC networkstatus_t *current_md_consensus = NULL;
  108. /** A v3 consensus networkstatus that we've received, but which we don't
  109. * have enough certificates to be happy about. */
  110. typedef struct consensus_waiting_for_certs_t {
  111. /** The consensus itself. */
  112. networkstatus_t *consensus;
  113. /** When did we set the current value of consensus_waiting_for_certs? If
  114. * this is too recent, we shouldn't try to fetch a new consensus for a
  115. * little while, to give ourselves time to get certificates for this one. */
  116. time_t set_at;
  117. /** Set to 1 if we've been holding on to it for so long we should maybe
  118. * treat it as being bad. */
  119. int dl_failed;
  120. } consensus_waiting_for_certs_t;
  121. /** An array, for each flavor of consensus we might want, of consensuses that
  122. * we have downloaded, but which we cannot verify due to having insufficient
  123. * authority certificates. */
  124. static consensus_waiting_for_certs_t
  125. consensus_waiting_for_certs[N_CONSENSUS_FLAVORS];
  126. /** A time before which we shouldn't try to replace the current consensus:
  127. * this will be at some point after the next consensus becomes valid, but
  128. * before the current consensus becomes invalid. */
  129. static time_t time_to_download_next_consensus[N_CONSENSUS_FLAVORS];
  130. /** Download status for the current consensus networkstatus. */
  131. static download_status_t consensus_dl_status[N_CONSENSUS_FLAVORS] =
  132. {
  133. { 0, 0, 0, DL_SCHED_CONSENSUS, DL_WANT_ANY_DIRSERVER,
  134. DL_SCHED_INCREMENT_FAILURE, 0, 0 },
  135. { 0, 0, 0, DL_SCHED_CONSENSUS, DL_WANT_ANY_DIRSERVER,
  136. DL_SCHED_INCREMENT_FAILURE, 0, 0 },
  137. };
  138. #define N_CONSENSUS_BOOTSTRAP_SCHEDULES 2
  139. #define CONSENSUS_BOOTSTRAP_SOURCE_AUTHORITY 0
  140. #define CONSENSUS_BOOTSTRAP_SOURCE_ANY_DIRSERVER 1
  141. /* Using DL_SCHED_INCREMENT_ATTEMPT on these schedules means that
  142. * download_status_increment_failure won't increment these entries.
  143. * However, any bootstrap connection failures that occur after we have
  144. * a valid consensus will count against the failure counts on the non-bootstrap
  145. * schedules. There should only be one of these, as all the others will have
  146. * been cancelled. (This doesn't seem to be a significant issue.) */
  147. static download_status_t
  148. consensus_bootstrap_dl_status[N_CONSENSUS_BOOTSTRAP_SCHEDULES] =
  149. {
  150. { 0, 0, 0, DL_SCHED_CONSENSUS, DL_WANT_AUTHORITY,
  151. DL_SCHED_INCREMENT_ATTEMPT, 0, 0 },
  152. /* During bootstrap, DL_WANT_ANY_DIRSERVER means "use fallbacks". */
  153. { 0, 0, 0, DL_SCHED_CONSENSUS, DL_WANT_ANY_DIRSERVER,
  154. DL_SCHED_INCREMENT_ATTEMPT, 0, 0 },
  155. };
  156. /** True iff we have logged a warning about this OR's version being older than
  157. * listed by the authorities. */
  158. static int have_warned_about_old_version = 0;
  159. /** True iff we have logged a warning about this OR's version being newer than
  160. * listed by the authorities. */
  161. static int have_warned_about_new_version = 0;
  162. static void update_consensus_bootstrap_multiple_downloads(
  163. time_t now,
  164. const or_options_t *options);
  165. static int networkstatus_check_required_protocols(const networkstatus_t *ns,
  166. int client_mode,
  167. char **warning_out);
  168. static int reload_consensus_from_file(const char *fname,
  169. const char *flavor,
  170. unsigned flags,
  171. const char *source_dir);
  172. /** Forget that we've warned about anything networkstatus-related, so we will
  173. * give fresh warnings if the same behavior happens again. */
  174. void
  175. networkstatus_reset_warnings(void)
  176. {
  177. SMARTLIST_FOREACH(nodelist_get_list(), node_t *, node,
  178. node->name_lookup_warned = 0);
  179. have_warned_about_old_version = 0;
  180. have_warned_about_new_version = 0;
  181. }
  182. /** Reset the descriptor download failure count on all networkstatus docs, so
  183. * that we can retry any long-failed documents immediately.
  184. */
  185. void
  186. networkstatus_reset_download_failures(void)
  187. {
  188. int i;
  189. log_debug(LD_GENERAL,
  190. "In networkstatus_reset_download_failures()");
  191. for (i=0; i < N_CONSENSUS_FLAVORS; ++i)
  192. download_status_reset(&consensus_dl_status[i]);
  193. for (i=0; i < N_CONSENSUS_BOOTSTRAP_SCHEDULES; ++i)
  194. download_status_reset(&consensus_bootstrap_dl_status[i]);
  195. }
  196. /** Return the filename used to cache the consensus of a given flavor */
  197. static char *
  198. networkstatus_get_cache_fname(int flav,
  199. const char *flavorname,
  200. int unverified_consensus)
  201. {
  202. char buf[128];
  203. const char *prefix;
  204. if (unverified_consensus) {
  205. prefix = "unverified";
  206. } else {
  207. prefix = "cached";
  208. }
  209. if (flav == FLAV_NS) {
  210. tor_snprintf(buf, sizeof(buf), "%s-consensus", prefix);
  211. } else {
  212. tor_snprintf(buf, sizeof(buf), "%s-%s-consensus", prefix, flavorname);
  213. }
  214. return get_cachedir_fname(buf);
  215. }
  216. /**
  217. * Read and and return the cached consensus of type <b>flavorname</b>. If
  218. * <b>unverified</b> is false, get the one we haven't verified. Return NULL if
  219. * the file isn't there. */
  220. static tor_mmap_t *
  221. networkstatus_map_cached_consensus_impl(int flav,
  222. const char *flavorname,
  223. int unverified_consensus)
  224. {
  225. char *filename = networkstatus_get_cache_fname(flav,
  226. flavorname,
  227. unverified_consensus);
  228. tor_mmap_t *result = tor_mmap_file(filename);
  229. tor_free(filename);
  230. return result;
  231. }
  232. /** Map the file containing the current cached consensus of flavor
  233. * <b>flavorname</b> */
  234. tor_mmap_t *
  235. networkstatus_map_cached_consensus(const char *flavorname)
  236. {
  237. int flav = networkstatus_parse_flavor_name(flavorname);
  238. if (flav < 0)
  239. return NULL;
  240. return networkstatus_map_cached_consensus_impl(flav, flavorname, 0);
  241. }
  242. /** Read every cached v3 consensus networkstatus from the disk. */
  243. int
  244. router_reload_consensus_networkstatus(void)
  245. {
  246. const unsigned int flags = NSSET_FROM_CACHE | NSSET_DONT_DOWNLOAD_CERTS;
  247. int flav;
  248. /* FFFF Suppress warnings if cached consensus is bad? */
  249. for (flav = 0; flav < N_CONSENSUS_FLAVORS; ++flav) {
  250. const char *flavor = networkstatus_get_flavor_name(flav);
  251. char *fname = networkstatus_get_cache_fname(flav, flavor, 0);
  252. reload_consensus_from_file(fname, flavor, flags, NULL);
  253. tor_free(fname);
  254. fname = networkstatus_get_cache_fname(flav, flavor, 1);
  255. reload_consensus_from_file(fname, flavor,
  256. flags | NSSET_WAS_WAITING_FOR_CERTS,
  257. NULL);
  258. tor_free(fname);
  259. }
  260. update_certificate_downloads(time(NULL));
  261. routers_update_all_from_networkstatus(time(NULL), 3);
  262. update_microdescs_from_networkstatus(time(NULL));
  263. return 0;
  264. }
  265. /** Free all storage held by the vote_routerstatus object <b>rs</b>. */
  266. void
  267. vote_routerstatus_free_(vote_routerstatus_t *rs)
  268. {
  269. vote_microdesc_hash_t *h, *next;
  270. if (!rs)
  271. return;
  272. tor_free(rs->version);
  273. tor_free(rs->protocols);
  274. tor_free(rs->status.exitsummary);
  275. for (h = rs->microdesc; h; h = next) {
  276. tor_free(h->microdesc_hash_line);
  277. next = h->next;
  278. tor_free(h);
  279. }
  280. tor_free(rs);
  281. }
  282. /** Free all storage held by the routerstatus object <b>rs</b>. */
  283. void
  284. routerstatus_free_(routerstatus_t *rs)
  285. {
  286. if (!rs)
  287. return;
  288. tor_free(rs->exitsummary);
  289. tor_free(rs);
  290. }
  291. /** Free all storage held in <b>sig</b> */
  292. void
  293. document_signature_free_(document_signature_t *sig)
  294. {
  295. tor_free(sig->signature);
  296. tor_free(sig);
  297. }
  298. /** Return a newly allocated copy of <b>sig</b> */
  299. document_signature_t *
  300. document_signature_dup(const document_signature_t *sig)
  301. {
  302. document_signature_t *r = tor_memdup(sig, sizeof(document_signature_t));
  303. if (r->signature)
  304. r->signature = tor_memdup(sig->signature, sig->signature_len);
  305. return r;
  306. }
  307. /** Free all storage held in <b>ns</b>. */
  308. void
  309. networkstatus_vote_free_(networkstatus_t *ns)
  310. {
  311. if (!ns)
  312. return;
  313. tor_free(ns->client_versions);
  314. tor_free(ns->server_versions);
  315. tor_free(ns->recommended_client_protocols);
  316. tor_free(ns->recommended_relay_protocols);
  317. tor_free(ns->required_client_protocols);
  318. tor_free(ns->required_relay_protocols);
  319. if (ns->known_flags) {
  320. SMARTLIST_FOREACH(ns->known_flags, char *, c, tor_free(c));
  321. smartlist_free(ns->known_flags);
  322. }
  323. if (ns->weight_params) {
  324. SMARTLIST_FOREACH(ns->weight_params, char *, c, tor_free(c));
  325. smartlist_free(ns->weight_params);
  326. }
  327. if (ns->net_params) {
  328. SMARTLIST_FOREACH(ns->net_params, char *, c, tor_free(c));
  329. smartlist_free(ns->net_params);
  330. }
  331. if (ns->supported_methods) {
  332. SMARTLIST_FOREACH(ns->supported_methods, char *, c, tor_free(c));
  333. smartlist_free(ns->supported_methods);
  334. }
  335. if (ns->package_lines) {
  336. SMARTLIST_FOREACH(ns->package_lines, char *, c, tor_free(c));
  337. smartlist_free(ns->package_lines);
  338. }
  339. if (ns->voters) {
  340. SMARTLIST_FOREACH_BEGIN(ns->voters, networkstatus_voter_info_t *, voter) {
  341. tor_free(voter->nickname);
  342. tor_free(voter->address);
  343. tor_free(voter->contact);
  344. if (voter->sigs) {
  345. SMARTLIST_FOREACH(voter->sigs, document_signature_t *, sig,
  346. document_signature_free(sig));
  347. smartlist_free(voter->sigs);
  348. }
  349. tor_free(voter);
  350. } SMARTLIST_FOREACH_END(voter);
  351. smartlist_free(ns->voters);
  352. }
  353. authority_cert_free(ns->cert);
  354. if (ns->routerstatus_list) {
  355. if (ns->type == NS_TYPE_VOTE || ns->type == NS_TYPE_OPINION) {
  356. SMARTLIST_FOREACH(ns->routerstatus_list, vote_routerstatus_t *, rs,
  357. vote_routerstatus_free(rs));
  358. } else {
  359. SMARTLIST_FOREACH(ns->routerstatus_list, routerstatus_t *, rs,
  360. routerstatus_free(rs));
  361. }
  362. smartlist_free(ns->routerstatus_list);
  363. }
  364. if (ns->bw_file_headers) {
  365. SMARTLIST_FOREACH(ns->bw_file_headers, char *, c, tor_free(c));
  366. smartlist_free(ns->bw_file_headers);
  367. }
  368. digestmap_free(ns->desc_digest_map, NULL);
  369. if (ns->sr_info.commits) {
  370. dirvote_clear_commits(ns);
  371. }
  372. tor_free(ns->sr_info.previous_srv);
  373. tor_free(ns->sr_info.current_srv);
  374. memwipe(ns, 11, sizeof(*ns));
  375. tor_free(ns);
  376. }
  377. /** Return the voter info from <b>vote</b> for the voter whose identity digest
  378. * is <b>identity</b>, or NULL if no such voter is associated with
  379. * <b>vote</b>. */
  380. networkstatus_voter_info_t *
  381. networkstatus_get_voter_by_id(networkstatus_t *vote,
  382. const char *identity)
  383. {
  384. if (!vote || !vote->voters)
  385. return NULL;
  386. SMARTLIST_FOREACH(vote->voters, networkstatus_voter_info_t *, voter,
  387. if (fast_memeq(voter->identity_digest, identity, DIGEST_LEN))
  388. return voter);
  389. return NULL;
  390. }
  391. /** Return the signature made by <b>voter</b> using the algorithm
  392. * <b>alg</b>, or NULL if none is found. */
  393. document_signature_t *
  394. networkstatus_get_voter_sig_by_alg(const networkstatus_voter_info_t *voter,
  395. digest_algorithm_t alg)
  396. {
  397. if (!voter->sigs)
  398. return NULL;
  399. SMARTLIST_FOREACH(voter->sigs, document_signature_t *, sig,
  400. if (sig->alg == alg)
  401. return sig);
  402. return NULL;
  403. }
  404. /** Check whether the signature <b>sig</b> is correctly signed with the
  405. * signing key in <b>cert</b>. Return -1 if <b>cert</b> doesn't match the
  406. * signing key; otherwise set the good_signature or bad_signature flag on
  407. * <b>voter</b>, and return 0. */
  408. int
  409. networkstatus_check_document_signature(const networkstatus_t *consensus,
  410. document_signature_t *sig,
  411. const authority_cert_t *cert)
  412. {
  413. char key_digest[DIGEST_LEN];
  414. const int dlen = sig->alg == DIGEST_SHA1 ? DIGEST_LEN : DIGEST256_LEN;
  415. char *signed_digest;
  416. size_t signed_digest_len;
  417. if (crypto_pk_get_digest(cert->signing_key, key_digest)<0)
  418. return -1;
  419. if (tor_memneq(sig->signing_key_digest, key_digest, DIGEST_LEN) ||
  420. tor_memneq(sig->identity_digest, cert->cache_info.identity_digest,
  421. DIGEST_LEN))
  422. return -1;
  423. if (authority_cert_is_blacklisted(cert)) {
  424. /* We implement blacklisting for authority signing keys by treating
  425. * all their signatures as always bad. That way we don't get into
  426. * crazy loops of dropping and re-fetching signatures. */
  427. log_warn(LD_DIR, "Ignoring a consensus signature made with deprecated"
  428. " signing key %s",
  429. hex_str(cert->signing_key_digest, DIGEST_LEN));
  430. sig->bad_signature = 1;
  431. return 0;
  432. }
  433. signed_digest_len = crypto_pk_keysize(cert->signing_key);
  434. signed_digest = tor_malloc(signed_digest_len);
  435. if (crypto_pk_public_checksig(cert->signing_key,
  436. signed_digest,
  437. signed_digest_len,
  438. sig->signature,
  439. sig->signature_len) < dlen ||
  440. tor_memneq(signed_digest, consensus->digests.d[sig->alg], dlen)) {
  441. log_warn(LD_DIR, "Got a bad signature on a networkstatus vote");
  442. sig->bad_signature = 1;
  443. } else {
  444. sig->good_signature = 1;
  445. }
  446. tor_free(signed_digest);
  447. return 0;
  448. }
  449. /** Given a v3 networkstatus consensus in <b>consensus</b>, check every
  450. * as-yet-unchecked signature on <b>consensus</b>. Return 1 if there is a
  451. * signature from every recognized authority on it, 0 if there are
  452. * enough good signatures from recognized authorities on it, -1 if we might
  453. * get enough good signatures by fetching missing certificates, and -2
  454. * otherwise. Log messages at INFO or WARN: if <b>warn</b> is over 1, warn
  455. * about every problem; if warn is at least 1, warn only if we can't get
  456. * enough signatures; if warn is negative, log nothing at all. */
  457. int
  458. networkstatus_check_consensus_signature(networkstatus_t *consensus,
  459. int warn)
  460. {
  461. int n_good = 0;
  462. int n_missing_key = 0, n_dl_failed_key = 0;
  463. int n_bad = 0;
  464. int n_unknown = 0;
  465. int n_no_signature = 0;
  466. int n_v3_authorities = get_n_authorities(V3_DIRINFO);
  467. int n_required = n_v3_authorities/2 + 1;
  468. smartlist_t *list_good = smartlist_new();
  469. smartlist_t *list_no_signature = smartlist_new();
  470. smartlist_t *need_certs_from = smartlist_new();
  471. smartlist_t *unrecognized = smartlist_new();
  472. smartlist_t *missing_authorities = smartlist_new();
  473. int severity;
  474. time_t now = time(NULL);
  475. tor_assert(consensus->type == NS_TYPE_CONSENSUS);
  476. SMARTLIST_FOREACH_BEGIN(consensus->voters, networkstatus_voter_info_t *,
  477. voter) {
  478. int good_here = 0;
  479. int bad_here = 0;
  480. int unknown_here = 0;
  481. int missing_key_here = 0, dl_failed_key_here = 0;
  482. SMARTLIST_FOREACH_BEGIN(voter->sigs, document_signature_t *, sig) {
  483. if (!sig->good_signature && !sig->bad_signature &&
  484. sig->signature) {
  485. /* we can try to check the signature. */
  486. int is_v3_auth = trusteddirserver_get_by_v3_auth_digest(
  487. sig->identity_digest) != NULL;
  488. authority_cert_t *cert =
  489. authority_cert_get_by_digests(sig->identity_digest,
  490. sig->signing_key_digest);
  491. tor_assert(tor_memeq(sig->identity_digest, voter->identity_digest,
  492. DIGEST_LEN));
  493. if (!is_v3_auth) {
  494. smartlist_add(unrecognized, voter);
  495. ++unknown_here;
  496. continue;
  497. } else if (!cert || cert->expires < now) {
  498. smartlist_add(need_certs_from, voter);
  499. ++missing_key_here;
  500. if (authority_cert_dl_looks_uncertain(sig->identity_digest))
  501. ++dl_failed_key_here;
  502. continue;
  503. }
  504. if (networkstatus_check_document_signature(consensus, sig, cert) < 0) {
  505. smartlist_add(need_certs_from, voter);
  506. ++missing_key_here;
  507. if (authority_cert_dl_looks_uncertain(sig->identity_digest))
  508. ++dl_failed_key_here;
  509. continue;
  510. }
  511. }
  512. if (sig->good_signature)
  513. ++good_here;
  514. else if (sig->bad_signature)
  515. ++bad_here;
  516. } SMARTLIST_FOREACH_END(sig);
  517. if (good_here) {
  518. ++n_good;
  519. smartlist_add(list_good, voter->nickname);
  520. } else if (bad_here) {
  521. ++n_bad;
  522. } else if (missing_key_here) {
  523. ++n_missing_key;
  524. if (dl_failed_key_here)
  525. ++n_dl_failed_key;
  526. } else if (unknown_here) {
  527. ++n_unknown;
  528. } else {
  529. ++n_no_signature;
  530. smartlist_add(list_no_signature, voter->nickname);
  531. }
  532. } SMARTLIST_FOREACH_END(voter);
  533. /* Now see whether we're missing any voters entirely. */
  534. SMARTLIST_FOREACH(router_get_trusted_dir_servers(),
  535. dir_server_t *, ds,
  536. {
  537. if ((ds->type & V3_DIRINFO) &&
  538. !networkstatus_get_voter_by_id(consensus, ds->v3_identity_digest))
  539. smartlist_add(missing_authorities, ds);
  540. });
  541. if (warn > 1 || (warn >= 0 &&
  542. (n_good + n_missing_key - n_dl_failed_key < n_required))) {
  543. severity = LOG_WARN;
  544. } else {
  545. severity = LOG_INFO;
  546. }
  547. if (warn >= 0) {
  548. SMARTLIST_FOREACH(unrecognized, networkstatus_voter_info_t *, voter,
  549. {
  550. tor_log(severity, LD_DIR, "Consensus includes unrecognized authority "
  551. "'%s' at %s:%d (contact %s; identity %s)",
  552. voter->nickname, voter->address, (int)voter->dir_port,
  553. voter->contact?voter->contact:"n/a",
  554. hex_str(voter->identity_digest, DIGEST_LEN));
  555. });
  556. SMARTLIST_FOREACH(need_certs_from, networkstatus_voter_info_t *, voter,
  557. {
  558. tor_log(severity, LD_DIR, "Looks like we need to download a new "
  559. "certificate from authority '%s' at %s:%d (contact %s; "
  560. "identity %s)",
  561. voter->nickname, voter->address, (int)voter->dir_port,
  562. voter->contact?voter->contact:"n/a",
  563. hex_str(voter->identity_digest, DIGEST_LEN));
  564. });
  565. SMARTLIST_FOREACH(missing_authorities, dir_server_t *, ds,
  566. {
  567. tor_log(severity, LD_DIR, "Consensus does not include configured "
  568. "authority '%s' at %s:%d (identity %s)",
  569. ds->nickname, ds->address, (int)ds->dir_port,
  570. hex_str(ds->v3_identity_digest, DIGEST_LEN));
  571. });
  572. {
  573. char *joined;
  574. smartlist_t *sl = smartlist_new();
  575. char *tmp = smartlist_join_strings(list_good, " ", 0, NULL);
  576. smartlist_add_asprintf(sl,
  577. "A consensus needs %d good signatures from recognized "
  578. "authorities for us to accept it. "
  579. "This %s one has %d (%s).",
  580. n_required,
  581. networkstatus_get_flavor_name(consensus->flavor),
  582. n_good, tmp);
  583. tor_free(tmp);
  584. if (n_no_signature) {
  585. tmp = smartlist_join_strings(list_no_signature, " ", 0, NULL);
  586. smartlist_add_asprintf(sl,
  587. "%d (%s) of the authorities we know didn't sign it.",
  588. n_no_signature, tmp);
  589. tor_free(tmp);
  590. }
  591. if (n_unknown) {
  592. smartlist_add_asprintf(sl,
  593. "It has %d signatures from authorities we don't "
  594. "recognize.", n_unknown);
  595. }
  596. if (n_bad) {
  597. smartlist_add_asprintf(sl, "%d of the signatures on it didn't verify "
  598. "correctly.", n_bad);
  599. }
  600. if (n_missing_key) {
  601. smartlist_add_asprintf(sl,
  602. "We were unable to check %d of the signatures, "
  603. "because we were missing the keys.", n_missing_key);
  604. }
  605. joined = smartlist_join_strings(sl, " ", 0, NULL);
  606. tor_log(severity, LD_DIR, "%s", joined);
  607. tor_free(joined);
  608. SMARTLIST_FOREACH(sl, char *, c, tor_free(c));
  609. smartlist_free(sl);
  610. }
  611. }
  612. smartlist_free(list_good);
  613. smartlist_free(list_no_signature);
  614. smartlist_free(unrecognized);
  615. smartlist_free(need_certs_from);
  616. smartlist_free(missing_authorities);
  617. if (n_good == n_v3_authorities)
  618. return 1;
  619. else if (n_good >= n_required)
  620. return 0;
  621. else if (n_good + n_missing_key >= n_required)
  622. return -1;
  623. else
  624. return -2;
  625. }
  626. /** How far in the future do we allow a network-status to get before removing
  627. * it? (seconds) */
  628. #define NETWORKSTATUS_ALLOW_SKEW (24*60*60)
  629. /** Helper for bsearching a list of routerstatus_t pointers: compare a
  630. * digest in the key to the identity digest of a routerstatus_t. */
  631. int
  632. compare_digest_to_routerstatus_entry(const void *_key, const void **_member)
  633. {
  634. const char *key = _key;
  635. const routerstatus_t *rs = *_member;
  636. return tor_memcmp(key, rs->identity_digest, DIGEST_LEN);
  637. }
  638. /** Helper for bsearching a list of routerstatus_t pointers: compare a
  639. * digest in the key to the identity digest of a routerstatus_t. */
  640. int
  641. compare_digest_to_vote_routerstatus_entry(const void *_key,
  642. const void **_member)
  643. {
  644. const char *key = _key;
  645. const vote_routerstatus_t *vrs = *_member;
  646. return tor_memcmp(key, vrs->status.identity_digest, DIGEST_LEN);
  647. }
  648. /** As networkstatus_find_entry, but do not return a const pointer */
  649. routerstatus_t *
  650. networkstatus_vote_find_mutable_entry(networkstatus_t *ns, const char *digest)
  651. {
  652. return smartlist_bsearch(ns->routerstatus_list, digest,
  653. compare_digest_to_routerstatus_entry);
  654. }
  655. /** Return the entry in <b>ns</b> for the identity digest <b>digest</b>, or
  656. * NULL if none was found. */
  657. MOCK_IMPL(const routerstatus_t *,
  658. networkstatus_vote_find_entry,(networkstatus_t *ns, const char *digest))
  659. {
  660. return networkstatus_vote_find_mutable_entry(ns, digest);
  661. }
  662. /*XXXX MOVE make this static once functions are moved into this file. */
  663. /** Search the routerstatuses in <b>ns</b> for one whose identity digest is
  664. * <b>digest</b>. Return value and set *<b>found_out</b> as for
  665. * smartlist_bsearch_idx(). */
  666. int
  667. networkstatus_vote_find_entry_idx(networkstatus_t *ns,
  668. const char *digest, int *found_out)
  669. {
  670. return smartlist_bsearch_idx(ns->routerstatus_list, digest,
  671. compare_digest_to_routerstatus_entry,
  672. found_out);
  673. }
  674. /** As router_get_consensus_status_by_descriptor_digest, but does not return
  675. * a const pointer. */
  676. MOCK_IMPL(routerstatus_t *,
  677. router_get_mutable_consensus_status_by_descriptor_digest,(
  678. networkstatus_t *consensus,
  679. const char *digest))
  680. {
  681. if (!consensus)
  682. consensus = networkstatus_get_latest_consensus();
  683. if (!consensus)
  684. return NULL;
  685. if (!consensus->desc_digest_map) {
  686. digestmap_t *m = consensus->desc_digest_map = digestmap_new();
  687. SMARTLIST_FOREACH(consensus->routerstatus_list,
  688. routerstatus_t *, rs,
  689. {
  690. digestmap_set(m, rs->descriptor_digest, rs);
  691. });
  692. }
  693. return digestmap_get(consensus->desc_digest_map, digest);
  694. }
  695. /** Return the consensus view of the status of the router whose current
  696. * <i>descriptor</i> digest in <b>consensus</b> is <b>digest</b>, or NULL if
  697. * no such router is known. */
  698. const routerstatus_t *
  699. router_get_consensus_status_by_descriptor_digest(networkstatus_t *consensus,
  700. const char *digest)
  701. {
  702. return router_get_mutable_consensus_status_by_descriptor_digest(
  703. consensus, digest);
  704. }
  705. /** Return a smartlist of all router descriptor digests in a consensus */
  706. static smartlist_t *
  707. router_get_descriptor_digests_in_consensus(networkstatus_t *consensus)
  708. {
  709. smartlist_t *result = smartlist_new();
  710. digestmap_iter_t *i;
  711. const char *digest;
  712. void *rs;
  713. char *digest_tmp;
  714. for (i = digestmap_iter_init(consensus->desc_digest_map);
  715. !(digestmap_iter_done(i));
  716. i = digestmap_iter_next(consensus->desc_digest_map, i)) {
  717. digestmap_iter_get(i, &digest, &rs);
  718. digest_tmp = tor_malloc(DIGEST_LEN);
  719. memcpy(digest_tmp, digest, DIGEST_LEN);
  720. smartlist_add(result, digest_tmp);
  721. }
  722. return result;
  723. }
  724. /** Return a smartlist of all router descriptor digests in the current
  725. * consensus */
  726. MOCK_IMPL(smartlist_t *,
  727. router_get_descriptor_digests,(void))
  728. {
  729. smartlist_t *result = NULL;
  730. if (current_ns_consensus) {
  731. result =
  732. router_get_descriptor_digests_in_consensus(current_ns_consensus);
  733. }
  734. return result;
  735. }
  736. /** Given the digest of a router descriptor, return its current download
  737. * status, or NULL if the digest is unrecognized. */
  738. MOCK_IMPL(download_status_t *,
  739. router_get_dl_status_by_descriptor_digest,(const char *d))
  740. {
  741. routerstatus_t *rs;
  742. if (!current_ns_consensus)
  743. return NULL;
  744. if ((rs = router_get_mutable_consensus_status_by_descriptor_digest(
  745. current_ns_consensus, d)))
  746. return &rs->dl_status;
  747. return NULL;
  748. }
  749. /** As router_get_consensus_status_by_id, but do not return a const pointer */
  750. routerstatus_t *
  751. router_get_mutable_consensus_status_by_id(const char *digest)
  752. {
  753. const networkstatus_t *ns = networkstatus_get_latest_consensus();
  754. if (!ns)
  755. return NULL;
  756. smartlist_t *rslist = ns->routerstatus_list;
  757. return smartlist_bsearch(rslist, digest,
  758. compare_digest_to_routerstatus_entry);
  759. }
  760. /** Return the consensus view of the status of the router whose identity
  761. * digest is <b>digest</b>, or NULL if we don't know about any such router. */
  762. const routerstatus_t *
  763. router_get_consensus_status_by_id(const char *digest)
  764. {
  765. return router_get_mutable_consensus_status_by_id(digest);
  766. }
  767. /** How frequently do directory authorities re-download fresh networkstatus
  768. * documents? */
  769. #define AUTHORITY_NS_CACHE_INTERVAL (10*60)
  770. /** How frequently do non-authority directory caches re-download fresh
  771. * networkstatus documents? */
  772. #define NONAUTHORITY_NS_CACHE_INTERVAL (60*60)
  773. /** Return true iff, given the options listed in <b>options</b>, <b>flavor</b>
  774. * is the flavor of a consensus networkstatus that we would like to fetch.
  775. *
  776. * For certificate fetches, use we_want_to_fetch_unknown_auth_certs, and
  777. * for serving fetched documents, use directory_caches_dir_info. */
  778. int
  779. we_want_to_fetch_flavor(const or_options_t *options, int flavor)
  780. {
  781. if (flavor < 0 || flavor > N_CONSENSUS_FLAVORS) {
  782. /* This flavor is crazy; we don't want it */
  783. /*XXXX handle unrecognized flavors later */
  784. return 0;
  785. }
  786. if (authdir_mode_v3(options) || directory_caches_dir_info(options)) {
  787. /* We want to serve all flavors to others, regardless if we would use
  788. * it ourselves. */
  789. return 1;
  790. }
  791. if (options->FetchUselessDescriptors) {
  792. /* In order to get all descriptors, we need to fetch all consensuses. */
  793. return 1;
  794. }
  795. /* Otherwise, we want the flavor only if we want to use it to build
  796. * circuits. */
  797. return flavor == usable_consensus_flavor();
  798. }
  799. /** Return true iff, given the options listed in <b>options</b>, we would like
  800. * to fetch and store unknown authority certificates.
  801. *
  802. * For consensus and descriptor fetches, use we_want_to_fetch_flavor, and
  803. * for serving fetched certificates, use directory_caches_unknown_auth_certs.
  804. */
  805. int
  806. we_want_to_fetch_unknown_auth_certs(const or_options_t *options)
  807. {
  808. if (authdir_mode_v3(options) ||
  809. directory_caches_unknown_auth_certs((options))) {
  810. /* We want to serve all certs to others, regardless if we would use
  811. * them ourselves. */
  812. return 1;
  813. }
  814. if (options->FetchUselessDescriptors) {
  815. /* Unknown certificates are definitely useless. */
  816. return 1;
  817. }
  818. /* Otherwise, don't fetch unknown certificates. */
  819. return 0;
  820. }
  821. /** How long will we hang onto a possibly live consensus for which we're
  822. * fetching certs before we check whether there is a better one? */
  823. #define DELAY_WHILE_FETCHING_CERTS (20*60)
  824. /** What is the minimum time we need to have waited fetching certs, before we
  825. * increment the consensus download schedule on failure? */
  826. #define MIN_DELAY_FOR_FETCH_CERT_STATUS_FAILURE (1*60)
  827. /* Check if a downloaded consensus flavor should still wait for certificates
  828. * to download now. If we decide not to wait, check if enough time has passed
  829. * to consider the certificate download failure a separate failure. If so,
  830. * fail dls.
  831. * If waiting for certificates to download, return 1. If not, return 0. */
  832. static int
  833. check_consensus_waiting_for_certs(int flavor, time_t now,
  834. download_status_t *dls)
  835. {
  836. consensus_waiting_for_certs_t *waiting;
  837. /* We should always have a known flavor, because we_want_to_fetch_flavor()
  838. * filters out unknown flavors. */
  839. tor_assert(flavor >= 0 && flavor < N_CONSENSUS_FLAVORS);
  840. waiting = &consensus_waiting_for_certs[flavor];
  841. if (waiting->consensus) {
  842. /* XXXX make sure this doesn't delay sane downloads. */
  843. if (waiting->set_at + DELAY_WHILE_FETCHING_CERTS > now &&
  844. waiting->consensus->valid_until > now) {
  845. return 1;
  846. } else {
  847. if (!waiting->dl_failed) {
  848. if (waiting->set_at + MIN_DELAY_FOR_FETCH_CERT_STATUS_FAILURE > now) {
  849. download_status_failed(dls, 0);
  850. }
  851. waiting->dl_failed=1;
  852. }
  853. }
  854. }
  855. return 0;
  856. }
  857. /** If we want to download a fresh consensus, launch a new download as
  858. * appropriate. */
  859. static void
  860. update_consensus_networkstatus_downloads(time_t now)
  861. {
  862. int i;
  863. const or_options_t *options = get_options();
  864. const int we_are_bootstrapping = networkstatus_consensus_is_bootstrapping(
  865. now);
  866. const int use_multi_conn =
  867. networkstatus_consensus_can_use_multiple_directories(options);
  868. if (should_delay_dir_fetches(options, NULL))
  869. return;
  870. for (i=0; i < N_CONSENSUS_FLAVORS; ++i) {
  871. /* XXXX need some way to download unknown flavors if we are caching. */
  872. const char *resource;
  873. networkstatus_t *c;
  874. int max_in_progress_conns = 1;
  875. if (! we_want_to_fetch_flavor(options, i))
  876. continue;
  877. c = networkstatus_get_latest_consensus_by_flavor(i);
  878. if (! (c && c->valid_after <= now && now <= c->valid_until)) {
  879. /* No live consensus? Get one now!*/
  880. time_to_download_next_consensus[i] = now;
  881. }
  882. if (time_to_download_next_consensus[i] > now)
  883. continue; /* Wait until the current consensus is older. */
  884. resource = networkstatus_get_flavor_name(i);
  885. /* Check if we already have enough connections in progress */
  886. if (we_are_bootstrapping && use_multi_conn) {
  887. max_in_progress_conns =
  888. options->ClientBootstrapConsensusMaxInProgressTries;
  889. }
  890. if (connection_dir_count_by_purpose_and_resource(
  891. DIR_PURPOSE_FETCH_CONSENSUS,
  892. resource)
  893. >= max_in_progress_conns) {
  894. continue;
  895. }
  896. /* Check if we want to launch another download for a usable consensus.
  897. * Only used during bootstrap. */
  898. if (we_are_bootstrapping && use_multi_conn
  899. && i == usable_consensus_flavor()) {
  900. /* Check if we're already downloading a usable consensus */
  901. if (networkstatus_consensus_is_already_downloading(resource))
  902. continue;
  903. /* Make multiple connections for a bootstrap consensus download. */
  904. update_consensus_bootstrap_multiple_downloads(now, options);
  905. } else {
  906. /* Check if we failed downloading a consensus too recently */
  907. /* Let's make sure we remembered to update consensus_dl_status */
  908. tor_assert(consensus_dl_status[i].schedule == DL_SCHED_CONSENSUS);
  909. if (!download_status_is_ready(&consensus_dl_status[i], now)) {
  910. continue;
  911. }
  912. /** Check if we're waiting for certificates to download. If we are,
  913. * launch download for missing directory authority certificates. */
  914. if (check_consensus_waiting_for_certs(i, now, &consensus_dl_status[i])) {
  915. update_certificate_downloads(now);
  916. continue;
  917. }
  918. /* Try the requested attempt */
  919. log_info(LD_DIR, "Launching %s standard networkstatus consensus "
  920. "download.", networkstatus_get_flavor_name(i));
  921. directory_get_from_dirserver(DIR_PURPOSE_FETCH_CONSENSUS,
  922. ROUTER_PURPOSE_GENERAL, resource,
  923. PDS_RETRY_IF_NO_SERVERS,
  924. consensus_dl_status[i].want_authority);
  925. }
  926. }
  927. }
  928. /** When we're bootstrapping, launch one or more consensus download
  929. * connections, if schedule indicates connection(s) should be made after now.
  930. * If is_authority, connect to an authority, otherwise, use a fallback
  931. * directory mirror.
  932. */
  933. static void
  934. update_consensus_bootstrap_attempt_downloads(
  935. time_t now,
  936. download_status_t *dls,
  937. download_want_authority_t want_authority)
  938. {
  939. const char *resource = networkstatus_get_flavor_name(
  940. usable_consensus_flavor());
  941. /* Let's make sure we remembered to update schedule */
  942. tor_assert(dls->schedule == DL_SCHED_CONSENSUS);
  943. /* Allow for multiple connections in the same second, if the schedule value
  944. * is 0. */
  945. while (download_status_is_ready(dls, now)) {
  946. log_info(LD_DIR, "Launching %s bootstrap %s networkstatus consensus "
  947. "download.", resource, (want_authority == DL_WANT_AUTHORITY
  948. ? "authority"
  949. : "mirror"));
  950. directory_get_from_dirserver(DIR_PURPOSE_FETCH_CONSENSUS,
  951. ROUTER_PURPOSE_GENERAL, resource,
  952. PDS_RETRY_IF_NO_SERVERS, want_authority);
  953. /* schedule the next attempt */
  954. download_status_increment_attempt(dls, resource, now);
  955. }
  956. }
  957. /** If we're bootstrapping, check the connection schedules and see if we want
  958. * to make additional, potentially concurrent, consensus download
  959. * connections.
  960. * Only call when bootstrapping, and when we want to make additional
  961. * connections. Only nodes that satisfy
  962. * networkstatus_consensus_can_use_multiple_directories make additional
  963. * connections.
  964. */
  965. static void
  966. update_consensus_bootstrap_multiple_downloads(time_t now,
  967. const or_options_t *options)
  968. {
  969. const int usable_flavor = usable_consensus_flavor();
  970. /* make sure we can use multiple connections */
  971. if (!networkstatus_consensus_can_use_multiple_directories(options)) {
  972. return;
  973. }
  974. /* Launch concurrent consensus download attempt(s) based on the mirror and
  975. * authority schedules. Try the mirror first - this makes it slightly more
  976. * likely that we'll connect to the fallback first, and then end the
  977. * authority connection attempt. */
  978. /* If a consensus download fails because it's waiting for certificates,
  979. * we'll fail both the authority and fallback schedules. This is better than
  980. * failing only one of the schedules, and having the other continue
  981. * unchecked.
  982. */
  983. /* If we don't have or can't use extra fallbacks, don't try them. */
  984. if (networkstatus_consensus_can_use_extra_fallbacks(options)) {
  985. download_status_t *dls_f =
  986. &consensus_bootstrap_dl_status[CONSENSUS_BOOTSTRAP_SOURCE_ANY_DIRSERVER];
  987. if (!check_consensus_waiting_for_certs(usable_flavor, now, dls_f)) {
  988. /* During bootstrap, DL_WANT_ANY_DIRSERVER means "use fallbacks". */
  989. update_consensus_bootstrap_attempt_downloads(now, dls_f,
  990. DL_WANT_ANY_DIRSERVER);
  991. }
  992. }
  993. /* Now try an authority. */
  994. download_status_t *dls_a =
  995. &consensus_bootstrap_dl_status[CONSENSUS_BOOTSTRAP_SOURCE_AUTHORITY];
  996. if (!check_consensus_waiting_for_certs(usable_flavor, now, dls_a)) {
  997. update_consensus_bootstrap_attempt_downloads(now, dls_a,
  998. DL_WANT_AUTHORITY);
  999. }
  1000. }
  1001. /** Called when an attempt to download a consensus fails: note that the
  1002. * failure occurred, and possibly retry. */
  1003. void
  1004. networkstatus_consensus_download_failed(int status_code, const char *flavname)
  1005. {
  1006. int flav = networkstatus_parse_flavor_name(flavname);
  1007. if (flav >= 0) {
  1008. tor_assert(flav < N_CONSENSUS_FLAVORS);
  1009. /* XXXX handle unrecognized flavors */
  1010. download_status_failed(&consensus_dl_status[flav], status_code);
  1011. /* Retry immediately, if appropriate. */
  1012. update_consensus_networkstatus_downloads(time(NULL));
  1013. }
  1014. }
  1015. /** How long do we (as a cache) wait after a consensus becomes non-fresh
  1016. * before trying to fetch another? */
  1017. #define CONSENSUS_MIN_SECONDS_BEFORE_CACHING 120
  1018. /** Update the time at which we'll consider replacing the current
  1019. * consensus of flavor <b>flav</b> */
  1020. static void
  1021. update_consensus_networkstatus_fetch_time_impl(time_t now, int flav)
  1022. {
  1023. const or_options_t *options = get_options();
  1024. networkstatus_t *c = networkstatus_get_latest_consensus_by_flavor(flav);
  1025. const char *flavor = networkstatus_get_flavor_name(flav);
  1026. if (! we_want_to_fetch_flavor(get_options(), flav))
  1027. return;
  1028. if (c && c->valid_after <= now && now <= c->valid_until) {
  1029. long dl_interval;
  1030. long interval = c->fresh_until - c->valid_after;
  1031. long min_sec_before_caching = CONSENSUS_MIN_SECONDS_BEFORE_CACHING;
  1032. time_t start;
  1033. if (min_sec_before_caching > interval/16) {
  1034. /* Usually we allow 2-minutes slop factor in case clocks get
  1035. desynchronized a little. If we're on a private network with
  1036. a crazy-fast voting interval, though, 2 minutes may be too
  1037. much. */
  1038. min_sec_before_caching = interval/16;
  1039. /* make sure we always delay by at least a second before caching */
  1040. if (min_sec_before_caching == 0) {
  1041. min_sec_before_caching = 1;
  1042. }
  1043. }
  1044. if (directory_fetches_dir_info_early(options)) {
  1045. /* We want to cache the next one at some point after this one
  1046. * is no longer fresh... */
  1047. start = (time_t)(c->fresh_until + min_sec_before_caching);
  1048. /* Some clients may need the consensus sooner than others. */
  1049. if (options->FetchDirInfoExtraEarly || authdir_mode_v3(options)) {
  1050. dl_interval = 60;
  1051. if (min_sec_before_caching + dl_interval > interval)
  1052. dl_interval = interval/2;
  1053. } else {
  1054. /* But only in the first half-interval after that. */
  1055. dl_interval = interval/2;
  1056. }
  1057. } else {
  1058. /* We're an ordinary client, a bridge, or a hidden service.
  1059. * Give all the caches enough time to download the consensus. */
  1060. start = (time_t)(c->fresh_until + (interval*3)/4);
  1061. /* But download the next one well before this one is expired. */
  1062. dl_interval = ((c->valid_until - start) * 7 )/ 8;
  1063. /* If we're a bridge user, make use of the numbers we just computed
  1064. * to choose the rest of the interval *after* them. */
  1065. if (directory_fetches_dir_info_later(options)) {
  1066. /* Give all the *clients* enough time to download the consensus. */
  1067. start = (time_t)(start + dl_interval + min_sec_before_caching);
  1068. /* But try to get it before ours actually expires. */
  1069. dl_interval = (c->valid_until - start) - min_sec_before_caching;
  1070. }
  1071. }
  1072. /* catch low dl_interval in crazy-fast networks */
  1073. if (dl_interval < 1)
  1074. dl_interval = 1;
  1075. /* catch late start in crazy-fast networks */
  1076. if (start+dl_interval >= c->valid_until)
  1077. start = c->valid_until - dl_interval - 1;
  1078. log_debug(LD_DIR,
  1079. "fresh_until: %ld start: %ld "
  1080. "dl_interval: %ld valid_until: %ld ",
  1081. (long)c->fresh_until, (long)start, dl_interval,
  1082. (long)c->valid_until);
  1083. /* We must not try to replace c while it's still fresh: */
  1084. tor_assert(c->fresh_until < start);
  1085. /* We must download the next one before c is invalid: */
  1086. tor_assert(start+dl_interval < c->valid_until);
  1087. time_to_download_next_consensus[flav] =
  1088. start + crypto_rand_int((int)dl_interval);
  1089. {
  1090. char tbuf1[ISO_TIME_LEN+1];
  1091. char tbuf2[ISO_TIME_LEN+1];
  1092. char tbuf3[ISO_TIME_LEN+1];
  1093. format_local_iso_time(tbuf1, c->fresh_until);
  1094. format_local_iso_time(tbuf2, c->valid_until);
  1095. format_local_iso_time(tbuf3, time_to_download_next_consensus[flav]);
  1096. log_info(LD_DIR, "Live %s consensus %s the most recent until %s and "
  1097. "will expire at %s; fetching the next one at %s.",
  1098. flavor, (c->fresh_until > now) ? "will be" : "was",
  1099. tbuf1, tbuf2, tbuf3);
  1100. }
  1101. } else {
  1102. time_to_download_next_consensus[flav] = now;
  1103. log_info(LD_DIR, "No live %s consensus; we should fetch one immediately.",
  1104. flavor);
  1105. }
  1106. }
  1107. /** Update the time at which we'll consider replacing the current
  1108. * consensus of flavor 'flavor' */
  1109. void
  1110. update_consensus_networkstatus_fetch_time(time_t now)
  1111. {
  1112. int i;
  1113. for (i = 0; i < N_CONSENSUS_FLAVORS; ++i) {
  1114. if (we_want_to_fetch_flavor(get_options(), i))
  1115. update_consensus_networkstatus_fetch_time_impl(now, i);
  1116. }
  1117. }
  1118. /** Return 1 if there's a reason we shouldn't try any directory
  1119. * fetches yet (e.g. we demand bridges and none are yet known).
  1120. * Else return 0.
  1121. * If we return 1 and <b>msg_out</b> is provided, set <b>msg_out</b>
  1122. * to an explanation of why directory fetches are delayed. (If we
  1123. * return 0, we set msg_out to NULL.)
  1124. */
  1125. int
  1126. should_delay_dir_fetches(const or_options_t *options, const char **msg_out)
  1127. {
  1128. if (msg_out) {
  1129. *msg_out = NULL;
  1130. }
  1131. if (options->DisableNetwork) {
  1132. if (msg_out) {
  1133. *msg_out = "DisableNetwork is set.";
  1134. }
  1135. log_info(LD_DIR, "Delaying dir fetches (DisableNetwork is set)");
  1136. return 1;
  1137. }
  1138. if (we_are_hibernating()) {
  1139. if (msg_out) {
  1140. *msg_out = "We are hibernating or shutting down.";
  1141. }
  1142. log_info(LD_DIR, "Delaying dir fetches (Hibernating or shutting down)");
  1143. return 1;
  1144. }
  1145. if (options->UseBridges) {
  1146. /* If we know that none of our bridges can possibly work, avoid fetching
  1147. * directory documents. But if some of them might work, try again. */
  1148. if (num_bridges_usable(1) == 0) {
  1149. if (msg_out) {
  1150. *msg_out = "No running bridges";
  1151. }
  1152. log_info(LD_DIR, "Delaying dir fetches (no running bridges known)");
  1153. return 1;
  1154. }
  1155. if (pt_proxies_configuration_pending()) {
  1156. if (msg_out) {
  1157. *msg_out = "Pluggable transport proxies still configuring";
  1158. }
  1159. log_info(LD_DIR, "Delaying dir fetches (pt proxies still configuring)");
  1160. return 1;
  1161. }
  1162. }
  1163. return 0;
  1164. }
  1165. /** Launch requests for networkstatus documents as appropriate. This is called
  1166. * when we retry all the connections on a SIGHUP and periodically by a Periodic
  1167. * event which checks whether we want to download any networkstatus documents.
  1168. */
  1169. void
  1170. update_networkstatus_downloads(time_t now)
  1171. {
  1172. const or_options_t *options = get_options();
  1173. if (should_delay_dir_fetches(options, NULL))
  1174. return;
  1175. /** Launch a consensus download request, we will wait for the consensus to
  1176. * download and when it completes we will launch a certificate download
  1177. * request. */
  1178. update_consensus_networkstatus_downloads(now);
  1179. }
  1180. /** Launch requests as appropriate for missing directory authority
  1181. * certificates. */
  1182. void
  1183. update_certificate_downloads(time_t now)
  1184. {
  1185. int i;
  1186. for (i = 0; i < N_CONSENSUS_FLAVORS; ++i) {
  1187. if (consensus_waiting_for_certs[i].consensus)
  1188. authority_certs_fetch_missing(consensus_waiting_for_certs[i].consensus,
  1189. now, NULL);
  1190. }
  1191. if (current_ns_consensus)
  1192. authority_certs_fetch_missing(current_ns_consensus, now, NULL);
  1193. if (current_md_consensus)
  1194. authority_certs_fetch_missing(current_md_consensus, now, NULL);
  1195. }
  1196. /** Return 1 if we have a consensus but we don't have enough certificates
  1197. * to start using it yet. */
  1198. int
  1199. consensus_is_waiting_for_certs(void)
  1200. {
  1201. return consensus_waiting_for_certs[usable_consensus_flavor()].consensus
  1202. ? 1 : 0;
  1203. }
  1204. /** Look up the currently active (depending on bootstrap status) download
  1205. * status for this consensus flavor and return a pointer to it.
  1206. */
  1207. MOCK_IMPL(download_status_t *,
  1208. networkstatus_get_dl_status_by_flavor,(consensus_flavor_t flavor))
  1209. {
  1210. download_status_t *dl = NULL;
  1211. const int we_are_bootstrapping =
  1212. networkstatus_consensus_is_bootstrapping(time(NULL));
  1213. if ((int)flavor <= N_CONSENSUS_FLAVORS) {
  1214. dl = &((we_are_bootstrapping ?
  1215. consensus_bootstrap_dl_status : consensus_dl_status)[flavor]);
  1216. }
  1217. return dl;
  1218. }
  1219. /** Look up the bootstrap download status for this consensus flavor
  1220. * and return a pointer to it. */
  1221. MOCK_IMPL(download_status_t *,
  1222. networkstatus_get_dl_status_by_flavor_bootstrap,(consensus_flavor_t flavor))
  1223. {
  1224. download_status_t *dl = NULL;
  1225. if ((int)flavor <= N_CONSENSUS_FLAVORS) {
  1226. dl = &(consensus_bootstrap_dl_status[flavor]);
  1227. }
  1228. return dl;
  1229. }
  1230. /** Look up the running (non-bootstrap) download status for this consensus
  1231. * flavor and return a pointer to it. */
  1232. MOCK_IMPL(download_status_t *,
  1233. networkstatus_get_dl_status_by_flavor_running,(consensus_flavor_t flavor))
  1234. {
  1235. download_status_t *dl = NULL;
  1236. if ((int)flavor <= N_CONSENSUS_FLAVORS) {
  1237. dl = &(consensus_dl_status[flavor]);
  1238. }
  1239. return dl;
  1240. }
  1241. /** Return the most recent consensus that we have downloaded, or NULL if we
  1242. * don't have one. May return future or expired consensuses. */
  1243. MOCK_IMPL(networkstatus_t *,
  1244. networkstatus_get_latest_consensus,(void))
  1245. {
  1246. if (we_use_microdescriptors_for_circuits(get_options()))
  1247. return current_md_consensus;
  1248. else
  1249. return current_ns_consensus;
  1250. }
  1251. /** Return the latest consensus we have whose flavor matches <b>f</b>, or NULL
  1252. * if we don't have one. May return future or expired consensuses. */
  1253. MOCK_IMPL(networkstatus_t *,
  1254. networkstatus_get_latest_consensus_by_flavor,(consensus_flavor_t f))
  1255. {
  1256. if (f == FLAV_NS)
  1257. return current_ns_consensus;
  1258. else if (f == FLAV_MICRODESC)
  1259. return current_md_consensus;
  1260. else {
  1261. tor_assert(0);
  1262. return NULL;
  1263. }
  1264. }
  1265. /** Return the most recent consensus that we have downloaded, or NULL if it is
  1266. * no longer live. */
  1267. MOCK_IMPL(networkstatus_t *,
  1268. networkstatus_get_live_consensus,(time_t now))
  1269. {
  1270. networkstatus_t *ns = networkstatus_get_latest_consensus();
  1271. if (ns && networkstatus_is_live(ns, now))
  1272. return ns;
  1273. else
  1274. return NULL;
  1275. }
  1276. /** Given a consensus in <b>ns</b>, return true iff currently live and
  1277. * unexpired. */
  1278. int
  1279. networkstatus_is_live(const networkstatus_t *ns, time_t now)
  1280. {
  1281. return (ns->valid_after <= now && now <= ns->valid_until);
  1282. }
  1283. /** Determine if <b>consensus</b> is valid, or expired recently enough, or not
  1284. * too far in the future, so that we can still use it.
  1285. *
  1286. * Return 1 if the consensus is reasonably live, or 0 if it is too old or
  1287. * too new.
  1288. */
  1289. int
  1290. networkstatus_consensus_reasonably_live(const networkstatus_t *consensus,
  1291. time_t now)
  1292. {
  1293. if (BUG(!consensus))
  1294. return 0;
  1295. return networkstatus_valid_after_is_reasonably_live(consensus->valid_after,
  1296. now) &&
  1297. networkstatus_valid_until_is_reasonably_live(consensus->valid_until,
  1298. now);
  1299. }
  1300. #define REASONABLY_LIVE_TIME (24*60*60)
  1301. /** As networkstatus_consensus_reasonably_live, but takes a valid_after
  1302. * time, and checks to see if it is in the past, or not too far in the future.
  1303. */
  1304. int
  1305. networkstatus_valid_after_is_reasonably_live(time_t valid_after,
  1306. time_t now)
  1307. {
  1308. return (now >= valid_after - REASONABLY_LIVE_TIME);
  1309. }
  1310. /** As networkstatus_consensus_reasonably_live, but takes a valid_until
  1311. * time, and checks to see if it is in the future, or not too far in the past.
  1312. */
  1313. int
  1314. networkstatus_valid_until_is_reasonably_live(time_t valid_until,
  1315. time_t now)
  1316. {
  1317. return (now <= valid_until + REASONABLY_LIVE_TIME);
  1318. }
  1319. /** As networkstatus_get_live_consensus(), but is way more tolerant of expired
  1320. * and future consensuses. */
  1321. MOCK_IMPL(networkstatus_t *,
  1322. networkstatus_get_reasonably_live_consensus,(time_t now, int flavor))
  1323. {
  1324. networkstatus_t *consensus =
  1325. networkstatus_get_latest_consensus_by_flavor(flavor);
  1326. if (consensus &&
  1327. networkstatus_consensus_reasonably_live(consensus, now))
  1328. return consensus;
  1329. else
  1330. return NULL;
  1331. }
  1332. /** Check if we need to download a consensus during tor's bootstrap phase.
  1333. * If we have no consensus, or our consensus is unusably old, return 1.
  1334. * As soon as we have received a consensus, return 0, even if we don't have
  1335. * enough certificates to validate it.
  1336. * If a fallback directory gives us a consensus we can never get certs for,
  1337. * check_consensus_waiting_for_certs() will wait 20 minutes before failing
  1338. * the cert downloads. After that, a new consensus will be fetched from a
  1339. * randomly chosen fallback. */
  1340. MOCK_IMPL(int,
  1341. networkstatus_consensus_is_bootstrapping,(time_t now))
  1342. {
  1343. /* If we have a validated, reasonably live consensus, we're not
  1344. * bootstrapping a consensus at all. */
  1345. if (networkstatus_get_reasonably_live_consensus(
  1346. now,
  1347. usable_consensus_flavor())) {
  1348. return 0;
  1349. }
  1350. /* If we have a consensus, but we're waiting for certificates,
  1351. * we're not waiting for a consensus download while bootstrapping. */
  1352. if (consensus_is_waiting_for_certs()) {
  1353. return 0;
  1354. }
  1355. /* If we have no consensus, or our consensus is very old, we are
  1356. * bootstrapping, and we need to download a consensus. */
  1357. return 1;
  1358. }
  1359. /** Check if we can use multiple directories for a consensus download.
  1360. * Only clients (including bridge relays, which act like clients) benefit
  1361. * from multiple simultaneous consensus downloads. */
  1362. int
  1363. networkstatus_consensus_can_use_multiple_directories(
  1364. const or_options_t *options)
  1365. {
  1366. /* If we are a client, bridge, bridge client, or hidden service */
  1367. return !public_server_mode(options);
  1368. }
  1369. /** Check if we can use fallback directory mirrors for a consensus download.
  1370. * If we have fallbacks and don't want to fetch from the authorities,
  1371. * we can use them. */
  1372. MOCK_IMPL(int,
  1373. networkstatus_consensus_can_use_extra_fallbacks,(const or_options_t *options))
  1374. {
  1375. /* The list length comparisons are a quick way to check if we have any
  1376. * non-authority fallback directories. If we ever have any authorities that
  1377. * aren't fallback directories, we will need to change this code. */
  1378. tor_assert(smartlist_len(router_get_fallback_dir_servers())
  1379. >= smartlist_len(router_get_trusted_dir_servers()));
  1380. /* If we don't fetch from the authorities, and we have additional mirrors,
  1381. * we can use them. */
  1382. return (!directory_fetches_from_authorities(options)
  1383. && (smartlist_len(router_get_fallback_dir_servers())
  1384. > smartlist_len(router_get_trusted_dir_servers())));
  1385. }
  1386. /* Is there a consensus fetch for flavor <b>resource</b> that's far
  1387. * enough along to be attached to a circuit? */
  1388. int
  1389. networkstatus_consensus_is_already_downloading(const char *resource)
  1390. {
  1391. int answer = 0;
  1392. /* First, get a list of all the dir conns that are fetching a consensus,
  1393. * fetching *this* consensus, and are in state "reading" (meaning they
  1394. * have already flushed their request onto the socks connection). */
  1395. smartlist_t *fetching_conns =
  1396. connection_dir_list_by_purpose_resource_and_state(
  1397. DIR_PURPOSE_FETCH_CONSENSUS, resource, DIR_CONN_STATE_CLIENT_READING);
  1398. /* Then, walk through each conn, to see if its linked socks connection
  1399. * is in an attached state. We have to check this separately, since with
  1400. * the optimistic data feature, fetches can send their request to the
  1401. * socks connection and go into state 'reading', even before they're
  1402. * attached to any circuit. */
  1403. SMARTLIST_FOREACH_BEGIN(fetching_conns, dir_connection_t *, dirconn) {
  1404. /* Do any of these other dir conns have a linked socks conn that is
  1405. * attached to a circuit already? */
  1406. connection_t *base = TO_CONN(dirconn);
  1407. if (base->linked_conn &&
  1408. base->linked_conn->type == CONN_TYPE_AP &&
  1409. !AP_CONN_STATE_IS_UNATTACHED(base->linked_conn->state)) {
  1410. answer = 1;
  1411. break; /* stop looping, because we know the answer will be yes */
  1412. }
  1413. } SMARTLIST_FOREACH_END(dirconn);
  1414. smartlist_free(fetching_conns);
  1415. return answer;
  1416. }
  1417. /* Does the current, reasonably live consensus have IPv6 addresses?
  1418. * Returns 1 if there is a reasonably live consensus and its consensus method
  1419. * includes IPv6 addresses in the consensus.
  1420. * Otherwise, if there is no consensus, or the method does not include IPv6
  1421. * addresses, returns 0. */
  1422. int
  1423. networkstatus_consensus_has_ipv6(const or_options_t* options)
  1424. {
  1425. const networkstatus_t *cons = networkstatus_get_reasonably_live_consensus(
  1426. approx_time(),
  1427. usable_consensus_flavor());
  1428. /* If we have no consensus, we have no IPv6 in it */
  1429. if (!cons) {
  1430. return 0;
  1431. }
  1432. /* Different flavours of consensus gained IPv6 at different times */
  1433. if (we_use_microdescriptors_for_circuits(options)) {
  1434. return
  1435. cons->consensus_method >= MIN_METHOD_FOR_A_LINES_IN_MICRODESC_CONSENSUS;
  1436. } else {
  1437. return 1;
  1438. }
  1439. }
  1440. /** Given two router status entries for the same router identity, return 1 if
  1441. * if the contents have changed between them. Otherwise, return 0. */
  1442. static int
  1443. routerstatus_has_changed(const routerstatus_t *a, const routerstatus_t *b)
  1444. {
  1445. tor_assert(tor_memeq(a->identity_digest, b->identity_digest, DIGEST_LEN));
  1446. return strcmp(a->nickname, b->nickname) ||
  1447. fast_memneq(a->descriptor_digest, b->descriptor_digest, DIGEST_LEN) ||
  1448. a->addr != b->addr ||
  1449. a->or_port != b->or_port ||
  1450. a->dir_port != b->dir_port ||
  1451. a->is_authority != b->is_authority ||
  1452. a->is_exit != b->is_exit ||
  1453. a->is_stable != b->is_stable ||
  1454. a->is_fast != b->is_fast ||
  1455. a->is_flagged_running != b->is_flagged_running ||
  1456. a->is_named != b->is_named ||
  1457. a->is_unnamed != b->is_unnamed ||
  1458. a->is_valid != b->is_valid ||
  1459. a->is_possible_guard != b->is_possible_guard ||
  1460. a->is_bad_exit != b->is_bad_exit ||
  1461. a->is_hs_dir != b->is_hs_dir;
  1462. // XXXX this function needs a huge refactoring; it has gotten out
  1463. // XXXX of sync with routerstatus_t, and it will do so again.
  1464. }
  1465. /** Notify controllers of any router status entries that changed between
  1466. * <b>old_c</b> and <b>new_c</b>. */
  1467. static void
  1468. notify_control_networkstatus_changed(const networkstatus_t *old_c,
  1469. const networkstatus_t *new_c)
  1470. {
  1471. smartlist_t *changed;
  1472. if (old_c == new_c)
  1473. return;
  1474. /* tell the controller exactly which relays are still listed, as well
  1475. * as what they're listed as */
  1476. control_event_newconsensus(new_c);
  1477. if (!control_event_is_interesting(EVENT_NS))
  1478. return;
  1479. if (!old_c) {
  1480. control_event_networkstatus_changed(new_c->routerstatus_list);
  1481. return;
  1482. }
  1483. changed = smartlist_new();
  1484. SMARTLIST_FOREACH_JOIN(
  1485. old_c->routerstatus_list, const routerstatus_t *, rs_old,
  1486. new_c->routerstatus_list, const routerstatus_t *, rs_new,
  1487. tor_memcmp(rs_old->identity_digest,
  1488. rs_new->identity_digest, DIGEST_LEN),
  1489. smartlist_add(changed, (void*) rs_new)) {
  1490. if (routerstatus_has_changed(rs_old, rs_new))
  1491. smartlist_add(changed, (void*)rs_new);
  1492. } SMARTLIST_FOREACH_JOIN_END(rs_old, rs_new);
  1493. control_event_networkstatus_changed(changed);
  1494. smartlist_free(changed);
  1495. }
  1496. /* Called before the consensus changes from old_c to new_c. */
  1497. static void
  1498. notify_before_networkstatus_changes(const networkstatus_t *old_c,
  1499. const networkstatus_t *new_c)
  1500. {
  1501. notify_control_networkstatus_changed(old_c, new_c);
  1502. dos_consensus_has_changed(new_c);
  1503. relay_consensus_has_changed(new_c);
  1504. }
  1505. /* Called after a new consensus has been put in the global state. It is safe
  1506. * to use the consensus getters in this function. */
  1507. static void
  1508. notify_after_networkstatus_changes(void)
  1509. {
  1510. scheduler_notify_networkstatus_changed();
  1511. }
  1512. /** Copy all the ancillary information (like router download status and so on)
  1513. * from <b>old_c</b> to <b>new_c</b>. */
  1514. static void
  1515. networkstatus_copy_old_consensus_info(networkstatus_t *new_c,
  1516. const networkstatus_t *old_c)
  1517. {
  1518. if (old_c == new_c)
  1519. return;
  1520. if (!old_c || !smartlist_len(old_c->routerstatus_list))
  1521. return;
  1522. SMARTLIST_FOREACH_JOIN(old_c->routerstatus_list, routerstatus_t *, rs_old,
  1523. new_c->routerstatus_list, routerstatus_t *, rs_new,
  1524. tor_memcmp(rs_old->identity_digest,
  1525. rs_new->identity_digest, DIGEST_LEN),
  1526. STMT_NIL) {
  1527. /* Okay, so we're looking at the same identity. */
  1528. rs_new->last_dir_503_at = rs_old->last_dir_503_at;
  1529. if (tor_memeq(rs_old->descriptor_digest, rs_new->descriptor_digest,
  1530. DIGEST256_LEN)) {
  1531. /* And the same descriptor too! */
  1532. memcpy(&rs_new->dl_status, &rs_old->dl_status,sizeof(download_status_t));
  1533. }
  1534. } SMARTLIST_FOREACH_JOIN_END(rs_old, rs_new);
  1535. }
  1536. #ifdef TOR_UNIT_TESTS
  1537. /**Accept a <b>flavor</b> consensus <b>c</b> without any additional
  1538. * validation. This is exclusively for unit tests.
  1539. * We copy any ancillary information from a pre-existing consensus
  1540. * and then free the current one and replace it with the newly
  1541. * provided instance. Returns -1 on unrecognized flavor, 0 otherwise.
  1542. */
  1543. int
  1544. networkstatus_set_current_consensus_from_ns(networkstatus_t *c,
  1545. const char *flavor)
  1546. {
  1547. int flav = networkstatus_parse_flavor_name(flavor);
  1548. switch (flav) {
  1549. case FLAV_NS:
  1550. if (current_ns_consensus) {
  1551. networkstatus_copy_old_consensus_info(c, current_ns_consensus);
  1552. networkstatus_vote_free(current_ns_consensus);
  1553. }
  1554. current_ns_consensus = c;
  1555. break;
  1556. case FLAV_MICRODESC:
  1557. if (current_md_consensus) {
  1558. networkstatus_copy_old_consensus_info(c, current_md_consensus);
  1559. networkstatus_vote_free(current_md_consensus);
  1560. }
  1561. current_md_consensus = c;
  1562. break;
  1563. }
  1564. return current_md_consensus ? 0 : -1;
  1565. }
  1566. #endif /* defined(TOR_UNIT_TESTS) */
  1567. /**
  1568. * Helper: Read the current consensus of type <b>flavor</b> from
  1569. * <b>fname</b>. Flags and return values are as for
  1570. * networkstatus_set_current_consensus().
  1571. **/
  1572. static int
  1573. reload_consensus_from_file(const char *fname,
  1574. const char *flavor,
  1575. unsigned flags,
  1576. const char *source_dir)
  1577. {
  1578. tor_mmap_t *map = tor_mmap_file(fname);
  1579. if (!map)
  1580. return 0;
  1581. int rv = networkstatus_set_current_consensus(map->data, map->size,
  1582. flavor, flags, source_dir);
  1583. #ifdef _WIN32
  1584. if (rv < 0 && tor_memstr(map->data, map->size, "\r\n")) {
  1585. log_notice(LD_GENERAL, "Looks like the above failures are probably "
  1586. "because of a CRLF in consensus file %s; falling back to "
  1587. "read_file_to_string. Nothing to worry about: this file "
  1588. "was probably saved by an earlier version of Tor.",
  1589. escaped(fname));
  1590. char *content = read_file_to_str(fname, RFTS_IGNORE_MISSING, NULL);
  1591. rv = networkstatus_set_current_consensus(content, strlen(content),
  1592. flavor, flags, source_dir);
  1593. tor_free(content);
  1594. }
  1595. #endif
  1596. if (rv < -1) {
  1597. log_warn(LD_GENERAL, "Couldn't set consensus from cache file %s",
  1598. escaped(fname));
  1599. }
  1600. tor_munmap_file(map);
  1601. return rv;
  1602. }
  1603. /**
  1604. * Helper for handle_missing_protocol_warning: handles either the
  1605. * client case (if <b>is_client</b> is set) or the server case otherwise.
  1606. */
  1607. static void
  1608. handle_missing_protocol_warning_impl(const networkstatus_t *c,
  1609. int is_client)
  1610. {
  1611. char *protocol_warning = NULL;
  1612. int should_exit = networkstatus_check_required_protocols(c,
  1613. is_client,
  1614. &protocol_warning);
  1615. if (protocol_warning) {
  1616. tor_log(should_exit ? LOG_ERR : LOG_WARN,
  1617. LD_GENERAL,
  1618. "%s", protocol_warning);
  1619. }
  1620. if (should_exit) {
  1621. tor_assert_nonfatal(protocol_warning);
  1622. }
  1623. tor_free(protocol_warning);
  1624. if (should_exit)
  1625. exit(1); // XXXX bad exit: should return from main.
  1626. }
  1627. /** Called when we have received a networkstatus <b>c</b>. If there are
  1628. * any _required_ protocols we are missing, log an error and exit
  1629. * immediately. If there are any _recommended_ protocols we are missing,
  1630. * warn. */
  1631. static void
  1632. handle_missing_protocol_warning(const networkstatus_t *c,
  1633. const or_options_t *options)
  1634. {
  1635. const int is_server = server_mode(options);
  1636. const int is_client = options_any_client_port_set(options) || !is_server;
  1637. if (is_server)
  1638. handle_missing_protocol_warning_impl(c, 0);
  1639. if (is_client)
  1640. handle_missing_protocol_warning_impl(c, 1);
  1641. }
  1642. /**
  1643. * Check whether we received a consensus that appears to be coming
  1644. * from the future. Because we implicitly trust the directory
  1645. * authorities' idea of the current time, we produce a warning if we
  1646. * get an early consensus.
  1647. *
  1648. * If we got a consensus that is time stamped far in the past, that
  1649. * could simply have come from a stale cache. Possible ways to get a
  1650. * consensus from the future can include:
  1651. *
  1652. * - enough directory authorities have wrong clocks
  1653. * - directory authorities collude to produce misleading time stamps
  1654. * - our own clock is wrong (this is by far the most likely)
  1655. *
  1656. * We neglect highly improbable scenarios that involve actual time
  1657. * travel.
  1658. */
  1659. STATIC void
  1660. warn_early_consensus(const networkstatus_t *c, const char *flavor,
  1661. time_t now)
  1662. {
  1663. char tbuf[ISO_TIME_LEN+1];
  1664. char dbuf[64];
  1665. long delta = now - c->valid_after;
  1666. char *flavormsg = NULL;
  1667. /** If a consensus appears more than this many seconds before it could
  1668. * possibly be a sufficiently-signed consensus, declare that our clock
  1669. * is skewed. */
  1670. #define EARLY_CONSENSUS_NOTICE_SKEW 60
  1671. /* We assume that if a majority of dirauths have accurate clocks,
  1672. * the earliest that a dirauth with a skewed clock could possibly
  1673. * publish a sufficiently-signed consensus is (valid_after -
  1674. * dist_seconds). Before that time, the skewed dirauth would be
  1675. * unable to obtain enough authority signatures for the consensus to
  1676. * be valid. */
  1677. if (now >= c->valid_after - c->dist_seconds - EARLY_CONSENSUS_NOTICE_SKEW)
  1678. return;
  1679. format_iso_time(tbuf, c->valid_after);
  1680. format_time_interval(dbuf, sizeof(dbuf), delta);
  1681. log_warn(LD_GENERAL, "Our clock is %s behind the time published in the "
  1682. "consensus network status document (%s UTC). Tor needs an "
  1683. "accurate clock to work correctly. Please check your time and "
  1684. "date settings!", dbuf, tbuf);
  1685. tor_asprintf(&flavormsg, "%s flavor consensus", flavor);
  1686. clock_skew_warning(NULL, delta, 1, LD_GENERAL, flavormsg, "CONSENSUS");
  1687. tor_free(flavormsg);
  1688. }
  1689. /** Try to replace the current cached v3 networkstatus with the one in
  1690. * <b>consensus</b>. If we don't have enough certificates to validate it,
  1691. * store it in consensus_waiting_for_certs and launch a certificate fetch.
  1692. *
  1693. * If flags & NSSET_FROM_CACHE, this networkstatus has come from the disk
  1694. * cache. If flags & NSSET_WAS_WAITING_FOR_CERTS, this networkstatus was
  1695. * already received, but we were waiting for certificates on it. If flags &
  1696. * NSSET_DONT_DOWNLOAD_CERTS, do not launch certificate downloads as needed.
  1697. * If flags & NSSET_ACCEPT_OBSOLETE, then we should be willing to take this
  1698. * consensus, even if it comes from many days in the past.
  1699. *
  1700. * If source_dir is non-NULL, it's the identity digest for a directory that
  1701. * we've just successfully retrieved a consensus or certificates from, so try
  1702. * it first to fetch any missing certificates.
  1703. *
  1704. * Return 0 on success, <0 on failure. On failure, caller should increment
  1705. * the failure count as appropriate.
  1706. *
  1707. * We return -1 for mild failures that don't need to be reported to the
  1708. * user, and -2 for more serious problems.
  1709. */
  1710. int
  1711. networkstatus_set_current_consensus(const char *consensus,
  1712. size_t consensus_len,
  1713. const char *flavor,
  1714. unsigned flags,
  1715. const char *source_dir)
  1716. {
  1717. networkstatus_t *c=NULL;
  1718. int r, result = -1;
  1719. time_t now = approx_time();
  1720. const or_options_t *options = get_options();
  1721. char *unverified_fname = NULL, *consensus_fname = NULL;
  1722. int flav = networkstatus_parse_flavor_name(flavor);
  1723. const unsigned from_cache = flags & NSSET_FROM_CACHE;
  1724. const unsigned was_waiting_for_certs = flags & NSSET_WAS_WAITING_FOR_CERTS;
  1725. const unsigned dl_certs = !(flags & NSSET_DONT_DOWNLOAD_CERTS);
  1726. const unsigned accept_obsolete = flags & NSSET_ACCEPT_OBSOLETE;
  1727. const unsigned require_flavor = flags & NSSET_REQUIRE_FLAVOR;
  1728. const common_digests_t *current_digests = NULL;
  1729. consensus_waiting_for_certs_t *waiting = NULL;
  1730. time_t current_valid_after = 0;
  1731. int free_consensus = 1; /* Free 'c' at the end of the function */
  1732. int checked_protocols_already = 0;
  1733. if (flav < 0) {
  1734. /* XXXX we don't handle unrecognized flavors yet. */
  1735. log_warn(LD_BUG, "Unrecognized consensus flavor %s", flavor);
  1736. return -2;
  1737. }
  1738. /* Make sure it's parseable. */
  1739. c = networkstatus_parse_vote_from_string(consensus,
  1740. consensus_len,
  1741. NULL, NS_TYPE_CONSENSUS);
  1742. if (!c) {
  1743. log_warn(LD_DIR, "Unable to parse networkstatus consensus");
  1744. result = -2;
  1745. goto done;
  1746. }
  1747. if (from_cache && !was_waiting_for_certs) {
  1748. /* We previously stored this; check _now_ to make sure that version-kills
  1749. * really work. This happens even before we check signatures: we did so
  1750. * before when we stored this to disk. This does mean an attacker who can
  1751. * write to the datadir can make us not start: such an attacker could
  1752. * already harm us by replacing our guards, which would be worse. */
  1753. checked_protocols_already = 1;
  1754. handle_missing_protocol_warning(c, options);
  1755. }
  1756. if ((int)c->flavor != flav) {
  1757. /* This wasn't the flavor we thought we were getting. */
  1758. if (require_flavor) {
  1759. log_warn(LD_DIR, "Got consensus with unexpected flavor %s (wanted %s)",
  1760. networkstatus_get_flavor_name(c->flavor), flavor);
  1761. goto done;
  1762. }
  1763. flav = c->flavor;
  1764. flavor = networkstatus_get_flavor_name(flav);
  1765. }
  1766. if (flav != usable_consensus_flavor() &&
  1767. !we_want_to_fetch_flavor(options, flav)) {
  1768. /* This consensus is totally boring to us: we won't use it, we didn't want
  1769. * it, and we won't serve it. Drop it. */
  1770. goto done;
  1771. }
  1772. if (from_cache && !accept_obsolete &&
  1773. c->valid_until < now-OLD_ROUTER_DESC_MAX_AGE) {
  1774. log_info(LD_DIR, "Loaded an expired consensus. Discarding.");
  1775. goto done;
  1776. }
  1777. if (!strcmp(flavor, "ns")) {
  1778. consensus_fname = get_cachedir_fname("cached-consensus");
  1779. unverified_fname = get_cachedir_fname("unverified-consensus");
  1780. if (current_ns_consensus) {
  1781. current_digests = &current_ns_consensus->digests;
  1782. current_valid_after = current_ns_consensus->valid_after;
  1783. }
  1784. } else if (!strcmp(flavor, "microdesc")) {
  1785. consensus_fname = get_cachedir_fname("cached-microdesc-consensus");
  1786. unverified_fname = get_cachedir_fname("unverified-microdesc-consensus");
  1787. if (current_md_consensus) {
  1788. current_digests = &current_md_consensus->digests;
  1789. current_valid_after = current_md_consensus->valid_after;
  1790. }
  1791. } else {
  1792. tor_assert_nonfatal_unreached();
  1793. result = -2;
  1794. goto done;
  1795. }
  1796. if (current_digests &&
  1797. tor_memeq(&c->digests, current_digests, sizeof(c->digests))) {
  1798. /* We already have this one. That's a failure. */
  1799. log_info(LD_DIR, "Got a %s consensus we already have", flavor);
  1800. goto done;
  1801. }
  1802. if (current_valid_after && c->valid_after <= current_valid_after) {
  1803. /* We have a newer one. There's no point in accepting this one,
  1804. * even if it's great. */
  1805. log_info(LD_DIR, "Got a %s consensus at least as old as the one we have",
  1806. flavor);
  1807. goto done;
  1808. }
  1809. /* Make sure it's signed enough. */
  1810. if ((r=networkstatus_check_consensus_signature(c, 1))<0) {
  1811. if (r == -1) {
  1812. /* Okay, so it _might_ be signed enough if we get more certificates. */
  1813. if (!was_waiting_for_certs) {
  1814. log_info(LD_DIR,
  1815. "Not enough certificates to check networkstatus consensus");
  1816. }
  1817. if (!current_valid_after ||
  1818. c->valid_after > current_valid_after) {
  1819. waiting = &consensus_waiting_for_certs[flav];
  1820. networkstatus_vote_free(waiting->consensus);
  1821. waiting->consensus = c;
  1822. free_consensus = 0;
  1823. waiting->set_at = now;
  1824. waiting->dl_failed = 0;
  1825. if (!from_cache) {
  1826. write_bytes_to_file(unverified_fname, consensus, consensus_len, 1);
  1827. }
  1828. if (dl_certs)
  1829. authority_certs_fetch_missing(c, now, source_dir);
  1830. /* This case is not a success or a failure until we get the certs
  1831. * or fail to get the certs. */
  1832. result = 0;
  1833. } else {
  1834. /* Even if we had enough signatures, we'd never use this as the
  1835. * latest consensus. */
  1836. if (was_waiting_for_certs && from_cache)
  1837. if (unlink(unverified_fname) != 0) {
  1838. log_debug(LD_FS,
  1839. "Failed to unlink %s: %s",
  1840. unverified_fname, strerror(errno));
  1841. }
  1842. }
  1843. goto done;
  1844. } else {
  1845. /* This can never be signed enough: Kill it. */
  1846. if (!was_waiting_for_certs) {
  1847. log_warn(LD_DIR, "Not enough good signatures on networkstatus "
  1848. "consensus");
  1849. result = -2;
  1850. }
  1851. if (was_waiting_for_certs && (r < -1) && from_cache) {
  1852. if (unlink(unverified_fname) != 0) {
  1853. log_debug(LD_FS,
  1854. "Failed to unlink %s: %s",
  1855. unverified_fname, strerror(errno));
  1856. }
  1857. }
  1858. goto done;
  1859. }
  1860. }
  1861. /* Signatures from the consensus are verified */
  1862. if (from_cache && was_waiting_for_certs) {
  1863. /* We check if the consensus is loaded from disk cache and that it
  1864. * it is an unverified consensus. If it is unverified, rename it to
  1865. * cached-*-consensus since it has been verified. */
  1866. log_info(LD_DIR, "Unverified consensus signatures verified.");
  1867. tor_rename(unverified_fname, consensus_fname);
  1868. }
  1869. if (!from_cache && flav == usable_consensus_flavor())
  1870. control_event_client_status(LOG_NOTICE, "CONSENSUS_ARRIVED");
  1871. if (!checked_protocols_already) {
  1872. handle_missing_protocol_warning(c, options);
  1873. }
  1874. /* Are we missing any certificates at all? */
  1875. if (r != 1 && dl_certs)
  1876. authority_certs_fetch_missing(c, now, source_dir);
  1877. const int is_usable_flavor = flav == usable_consensus_flavor();
  1878. /* Before we switch to the new consensus, notify that we are about to change
  1879. * it using the old consensus and the new one. */
  1880. if (is_usable_flavor) {
  1881. notify_before_networkstatus_changes(networkstatus_get_latest_consensus(),
  1882. c);
  1883. }
  1884. if (flav == FLAV_NS) {
  1885. if (current_ns_consensus) {
  1886. networkstatus_copy_old_consensus_info(c, current_ns_consensus);
  1887. networkstatus_vote_free(current_ns_consensus);
  1888. /* Defensive programming : we should set current_ns_consensus very soon
  1889. * but we're about to call some stuff in the meantime, and leaving this
  1890. * dangling pointer around has proven to be trouble. */
  1891. current_ns_consensus = NULL;
  1892. }
  1893. current_ns_consensus = c;
  1894. free_consensus = 0; /* avoid free */
  1895. } else if (flav == FLAV_MICRODESC) {
  1896. if (current_md_consensus) {
  1897. networkstatus_copy_old_consensus_info(c, current_md_consensus);
  1898. networkstatus_vote_free(current_md_consensus);
  1899. /* more defensive programming */
  1900. current_md_consensus = NULL;
  1901. }
  1902. current_md_consensus = c;
  1903. free_consensus = 0; /* avoid free */
  1904. }
  1905. waiting = &consensus_waiting_for_certs[flav];
  1906. if (waiting->consensus &&
  1907. waiting->consensus->valid_after <= c->valid_after) {
  1908. networkstatus_vote_free(waiting->consensus);
  1909. waiting->consensus = NULL;
  1910. waiting->set_at = 0;
  1911. waiting->dl_failed = 0;
  1912. if (unlink(unverified_fname) != 0) {
  1913. log_debug(LD_FS,
  1914. "Failed to unlink %s: %s",
  1915. unverified_fname, strerror(errno));
  1916. }
  1917. }
  1918. if (is_usable_flavor) {
  1919. /* Notify that we just changed the consensus so the current global value
  1920. * can be looked at. */
  1921. notify_after_networkstatus_changes();
  1922. /* The "current" consensus has just been set and it is a usable flavor so
  1923. * the first thing we need to do is recalculate the voting schedule static
  1924. * object so we can use the timings in there needed by some subsystems
  1925. * such as hidden service and shared random. */
  1926. voting_schedule_recalculate_timing(options, now);
  1927. reschedule_dirvote(options);
  1928. nodelist_set_consensus(c);
  1929. update_consensus_networkstatus_fetch_time(now);
  1930. /* Change the cell EWMA settings */
  1931. cmux_ewma_set_options(options, c);
  1932. /* XXXX this call might be unnecessary here: can changing the
  1933. * current consensus really alter our view of any OR's rate limits? */
  1934. connection_or_update_token_buckets(get_connection_array(), options);
  1935. circuit_build_times_new_consensus_params(
  1936. get_circuit_build_times_mutable(), c);
  1937. channelpadding_new_consensus_params(c);
  1938. circpad_new_consensus_params(c);
  1939. }
  1940. /* Reset the failure count only if this consensus is actually valid. */
  1941. if (c->valid_after <= now && now <= c->valid_until) {
  1942. download_status_reset(&consensus_dl_status[flav]);
  1943. } else {
  1944. if (!from_cache)
  1945. download_status_failed(&consensus_dl_status[flav], 0);
  1946. }
  1947. if (we_want_to_fetch_flavor(options, flav)) {
  1948. if (dir_server_mode(get_options())) {
  1949. dirserv_set_cached_consensus_networkstatus(consensus,
  1950. consensus_len,
  1951. flavor,
  1952. &c->digests,
  1953. c->digest_sha3_as_signed,
  1954. c->valid_after);
  1955. consdiffmgr_add_consensus(consensus, consensus_len, c);
  1956. }
  1957. }
  1958. if (!from_cache) {
  1959. write_bytes_to_file(consensus_fname, consensus, consensus_len, 1);
  1960. }
  1961. warn_early_consensus(c, flavor, now);
  1962. /* We got a new consesus. Reset our md fetch fail cache */
  1963. microdesc_reset_outdated_dirservers_list();
  1964. router_dir_info_changed();
  1965. result = 0;
  1966. done:
  1967. if (free_consensus)
  1968. networkstatus_vote_free(c);
  1969. tor_free(consensus_fname);
  1970. tor_free(unverified_fname);
  1971. return result;
  1972. }
  1973. /** Called when we have gotten more certificates: see whether we can
  1974. * now verify a pending consensus.
  1975. *
  1976. * If source_dir is non-NULL, it's the identity digest for a directory that
  1977. * we've just successfully retrieved certificates from, so try it first to
  1978. * fetch any missing certificates.
  1979. */
  1980. void
  1981. networkstatus_note_certs_arrived(const char *source_dir)
  1982. {
  1983. int i;
  1984. for (i=0; i<N_CONSENSUS_FLAVORS; ++i) {
  1985. const char *flavor_name = networkstatus_get_flavor_name(i);
  1986. consensus_waiting_for_certs_t *waiting = &consensus_waiting_for_certs[i];
  1987. if (!waiting->consensus)
  1988. continue;
  1989. if (networkstatus_check_consensus_signature(waiting->consensus, 0)>=0) {
  1990. char *fname = networkstatus_get_cache_fname(i, flavor_name, 1);
  1991. reload_consensus_from_file(fname, flavor_name,
  1992. NSSET_WAS_WAITING_FOR_CERTS, source_dir);
  1993. tor_free(fname);
  1994. }
  1995. }
  1996. }
  1997. /** If the network-status list has changed since the last time we called this
  1998. * function, update the status of every routerinfo from the network-status
  1999. * list. If <b>dir_version</b> is 2, it's a v2 networkstatus that changed.
  2000. * If <b>dir_version</b> is 3, it's a v3 consensus that changed.
  2001. */
  2002. void
  2003. routers_update_all_from_networkstatus(time_t now, int dir_version)
  2004. {
  2005. routerlist_t *rl = router_get_routerlist();
  2006. networkstatus_t *consensus = networkstatus_get_reasonably_live_consensus(now,
  2007. FLAV_NS);
  2008. if (!consensus || dir_version < 3) /* nothing more we should do */
  2009. return;
  2010. /* calls router_dir_info_changed() when it's done -- more routers
  2011. * might be up or down now, which might affect whether there's enough
  2012. * directory info. */
  2013. routers_update_status_from_consensus_networkstatus(rl->routers, 0);
  2014. SMARTLIST_FOREACH(rl->routers, routerinfo_t *, ri,
  2015. ri->cache_info.routerlist_index = ri_sl_idx);
  2016. if (rl->old_routers)
  2017. signed_descs_update_status_from_consensus_networkstatus(rl->old_routers);
  2018. if (!have_warned_about_old_version) {
  2019. int is_server = server_mode(get_options());
  2020. version_status_t status;
  2021. const char *recommended = is_server ?
  2022. consensus->server_versions : consensus->client_versions;
  2023. status = tor_version_is_obsolete(VERSION, recommended);
  2024. if (status == VS_RECOMMENDED) {
  2025. log_info(LD_GENERAL, "The directory authorities say my version is ok.");
  2026. } else if (status == VS_EMPTY) {
  2027. log_info(LD_GENERAL,
  2028. "The directory authorities don't recommend any versions.");
  2029. } else if (status == VS_NEW || status == VS_NEW_IN_SERIES) {
  2030. if (!have_warned_about_new_version) {
  2031. log_notice(LD_GENERAL, "This version of Tor (%s) is newer than any "
  2032. "recommended version%s, according to the directory "
  2033. "authorities. Recommended versions are: %s",
  2034. VERSION,
  2035. status == VS_NEW_IN_SERIES ? " in its series" : "",
  2036. recommended);
  2037. have_warned_about_new_version = 1;
  2038. control_event_general_status(LOG_WARN, "DANGEROUS_VERSION "
  2039. "CURRENT=%s REASON=%s RECOMMENDED=\"%s\"",
  2040. VERSION, "NEW", recommended);
  2041. }
  2042. } else {
  2043. log_warn(LD_GENERAL, "Please upgrade! "
  2044. "This version of Tor (%s) is %s, according to the directory "
  2045. "authorities. Recommended versions are: %s",
  2046. VERSION,
  2047. status == VS_OLD ? "obsolete" : "not recommended",
  2048. recommended);
  2049. have_warned_about_old_version = 1;
  2050. control_event_general_status(LOG_WARN, "DANGEROUS_VERSION "
  2051. "CURRENT=%s REASON=%s RECOMMENDED=\"%s\"",
  2052. VERSION, status == VS_OLD ? "OBSOLETE" : "UNRECOMMENDED",
  2053. recommended);
  2054. }
  2055. }
  2056. }
  2057. /** Given a list <b>routers</b> of routerinfo_t *, update each status field
  2058. * according to our current consensus networkstatus. May re-order
  2059. * <b>routers</b>. */
  2060. void
  2061. routers_update_status_from_consensus_networkstatus(smartlist_t *routers,
  2062. int reset_failures)
  2063. {
  2064. const or_options_t *options = get_options();
  2065. int authdir = authdir_mode_v3(options);
  2066. networkstatus_t *ns = networkstatus_get_latest_consensus();
  2067. if (!ns || !smartlist_len(ns->routerstatus_list))
  2068. return;
  2069. routers_sort_by_identity(routers);
  2070. SMARTLIST_FOREACH_JOIN(ns->routerstatus_list, routerstatus_t *, rs,
  2071. routers, routerinfo_t *, router,
  2072. tor_memcmp(rs->identity_digest,
  2073. router->cache_info.identity_digest, DIGEST_LEN),
  2074. {
  2075. }) {
  2076. /* Is it the same descriptor, or only the same identity? */
  2077. if (tor_memeq(router->cache_info.signed_descriptor_digest,
  2078. rs->descriptor_digest, DIGEST_LEN)) {
  2079. if (ns->valid_until > router->cache_info.last_listed_as_valid_until)
  2080. router->cache_info.last_listed_as_valid_until = ns->valid_until;
  2081. }
  2082. if (authdir) {
  2083. /* If we _are_ an authority, we should check whether this router
  2084. * is one that will cause us to need a reachability test. */
  2085. routerinfo_t *old_router =
  2086. router_get_mutable_by_digest(router->cache_info.identity_digest);
  2087. if (old_router != router) {
  2088. router->needs_retest_if_added =
  2089. dirserv_should_launch_reachability_test(router, old_router);
  2090. }
  2091. }
  2092. if (reset_failures) {
  2093. download_status_reset(&rs->dl_status);
  2094. }
  2095. } SMARTLIST_FOREACH_JOIN_END(rs, router);
  2096. router_dir_info_changed();
  2097. }
  2098. /** Given a list of signed_descriptor_t, update their fields (mainly, when
  2099. * they were last listed) from the most recent consensus. */
  2100. void
  2101. signed_descs_update_status_from_consensus_networkstatus(smartlist_t *descs)
  2102. {
  2103. networkstatus_t *ns = current_ns_consensus;
  2104. if (!ns)
  2105. return;
  2106. if (!ns->desc_digest_map) {
  2107. char dummy[DIGEST_LEN];
  2108. /* instantiates the digest map. */
  2109. memset(dummy, 0, sizeof(dummy));
  2110. router_get_consensus_status_by_descriptor_digest(ns, dummy);
  2111. }
  2112. SMARTLIST_FOREACH(descs, signed_descriptor_t *, d,
  2113. {
  2114. const routerstatus_t *rs = digestmap_get(ns->desc_digest_map,
  2115. d->signed_descriptor_digest);
  2116. if (rs) {
  2117. if (ns->valid_until > d->last_listed_as_valid_until)
  2118. d->last_listed_as_valid_until = ns->valid_until;
  2119. }
  2120. });
  2121. }
  2122. /** Generate networkstatus lines for a single routerstatus_t object, and
  2123. * return the result in a newly allocated string. Used only by controller
  2124. * interface (for now.) */
  2125. char *
  2126. networkstatus_getinfo_helper_single(const routerstatus_t *rs)
  2127. {
  2128. return routerstatus_format_entry(rs, NULL, NULL, NS_CONTROL_PORT,
  2129. ROUTERSTATUS_FORMAT_NO_CONSENSUS_METHOD,
  2130. NULL);
  2131. }
  2132. /**
  2133. * Extract status information from <b>ri</b> and from other authority
  2134. * functions and store it in <b>rs</b>. <b>rs</b> is zeroed out before it is
  2135. * set.
  2136. *
  2137. * We assume that node-\>is_running has already been set, e.g. by
  2138. * dirserv_set_router_is_running(ri, now);
  2139. */
  2140. void
  2141. set_routerstatus_from_routerinfo(routerstatus_t *rs,
  2142. const node_t *node,
  2143. const routerinfo_t *ri)
  2144. {
  2145. memset(rs, 0, sizeof(routerstatus_t));
  2146. rs->is_authority =
  2147. router_digest_is_trusted_dir(ri->cache_info.identity_digest);
  2148. /* Set by compute_performance_thresholds or from consensus */
  2149. rs->is_exit = node->is_exit;
  2150. rs->is_stable = node->is_stable;
  2151. rs->is_fast = node->is_fast;
  2152. rs->is_flagged_running = node->is_running;
  2153. rs->is_valid = node->is_valid;
  2154. rs->is_possible_guard = node->is_possible_guard;
  2155. rs->is_bad_exit = node->is_bad_exit;
  2156. rs->is_hs_dir = node->is_hs_dir;
  2157. rs->is_named = rs->is_unnamed = 0;
  2158. rs->published_on = ri->cache_info.published_on;
  2159. memcpy(rs->identity_digest, node->identity, DIGEST_LEN);
  2160. memcpy(rs->descriptor_digest, ri->cache_info.signed_descriptor_digest,
  2161. DIGEST_LEN);
  2162. rs->addr = ri->addr;
  2163. strlcpy(rs->nickname, ri->nickname, sizeof(rs->nickname));
  2164. rs->or_port = ri->or_port;
  2165. rs->dir_port = ri->dir_port;
  2166. rs->is_v2_dir = ri->supports_tunnelled_dir_requests;
  2167. tor_addr_copy(&rs->ipv6_addr, &ri->ipv6_addr);
  2168. rs->ipv6_orport = ri->ipv6_orport;
  2169. }
  2170. /** Alloc and return a string describing routerstatuses for the most
  2171. * recent info of each router we know about that is of purpose
  2172. * <b>purpose_string</b>. Return NULL if unrecognized purpose.
  2173. *
  2174. * Right now this function is oriented toward listing bridges (you
  2175. * shouldn't use this for general-purpose routers, since those
  2176. * should be listed from the consensus, not from the routers list). */
  2177. char *
  2178. networkstatus_getinfo_by_purpose(const char *purpose_string, time_t now)
  2179. {
  2180. const time_t cutoff = now - ROUTER_MAX_AGE_TO_PUBLISH;
  2181. char *answer;
  2182. routerlist_t *rl = router_get_routerlist();
  2183. smartlist_t *statuses;
  2184. const uint8_t purpose = router_purpose_from_string(purpose_string);
  2185. routerstatus_t rs;
  2186. if (purpose == ROUTER_PURPOSE_UNKNOWN) {
  2187. log_info(LD_DIR, "Unrecognized purpose '%s' when listing router statuses.",
  2188. purpose_string);
  2189. return NULL;
  2190. }
  2191. statuses = smartlist_new();
  2192. SMARTLIST_FOREACH_BEGIN(rl->routers, routerinfo_t *, ri) {
  2193. node_t *node = node_get_mutable_by_id(ri->cache_info.identity_digest);
  2194. if (!node)
  2195. continue;
  2196. if (ri->cache_info.published_on < cutoff)
  2197. continue;
  2198. if (ri->purpose != purpose)
  2199. continue;
  2200. set_routerstatus_from_routerinfo(&rs, node, ri);
  2201. smartlist_add(statuses, networkstatus_getinfo_helper_single(&rs));
  2202. } SMARTLIST_FOREACH_END(ri);
  2203. answer = smartlist_join_strings(statuses, "", 0, NULL);
  2204. SMARTLIST_FOREACH(statuses, char *, cp, tor_free(cp));
  2205. smartlist_free(statuses);
  2206. return answer;
  2207. }
  2208. /* DOCDOC get_net_param_from_list */
  2209. static int32_t
  2210. get_net_param_from_list(smartlist_t *net_params, const char *param_name,
  2211. int32_t default_val, int32_t min_val, int32_t max_val)
  2212. {
  2213. int32_t res = default_val;
  2214. size_t name_len = strlen(param_name);
  2215. tor_assert(max_val > min_val);
  2216. tor_assert(min_val <= default_val);
  2217. tor_assert(max_val >= default_val);
  2218. SMARTLIST_FOREACH_BEGIN(net_params, const char *, p) {
  2219. if (!strcmpstart(p, param_name) && p[name_len] == '=') {
  2220. int ok=0;
  2221. long v = tor_parse_long(p+name_len+1, 10, INT32_MIN,
  2222. INT32_MAX, &ok, NULL);
  2223. if (ok) {
  2224. res = (int32_t) v;
  2225. break;
  2226. }
  2227. }
  2228. } SMARTLIST_FOREACH_END(p);
  2229. if (res < min_val) {
  2230. log_warn(LD_DIR, "Consensus parameter %s is too small. Got %d, raising to "
  2231. "%d.", param_name, res, min_val);
  2232. res = min_val;
  2233. } else if (res > max_val) {
  2234. log_warn(LD_DIR, "Consensus parameter %s is too large. Got %d, capping to "
  2235. "%d.", param_name, res, max_val);
  2236. res = max_val;
  2237. }
  2238. tor_assert(res >= min_val);
  2239. tor_assert(res <= max_val);
  2240. return res;
  2241. }
  2242. /** Return the value of a integer parameter from the networkstatus <b>ns</b>
  2243. * whose name is <b>param_name</b>. If <b>ns</b> is NULL, try loading the
  2244. * latest consensus ourselves. Return <b>default_val</b> if no latest
  2245. * consensus, or if it has no parameter called <b>param_name</b>.
  2246. * Make sure the value parsed from the consensus is at least
  2247. * <b>min_val</b> and at most <b>max_val</b> and raise/cap the parsed value
  2248. * if necessary. */
  2249. MOCK_IMPL(int32_t,
  2250. networkstatus_get_param, (const networkstatus_t *ns, const char *param_name,
  2251. int32_t default_val, int32_t min_val, int32_t max_val))
  2252. {
  2253. if (!ns) /* if they pass in null, go find it ourselves */
  2254. ns = networkstatus_get_latest_consensus();
  2255. if (!ns || !ns->net_params)
  2256. return default_val;
  2257. return get_net_param_from_list(ns->net_params, param_name,
  2258. default_val, min_val, max_val);
  2259. }
  2260. /**
  2261. * As networkstatus_get_param(), but check torrc_value before checking the
  2262. * consensus. If torrc_value is in-range, then return it instead of the
  2263. * value from the consensus.
  2264. */
  2265. int32_t
  2266. networkstatus_get_overridable_param(const networkstatus_t *ns,
  2267. int32_t torrc_value,
  2268. const char *param_name,
  2269. int32_t default_val,
  2270. int32_t min_val, int32_t max_val)
  2271. {
  2272. if (torrc_value >= min_val && torrc_value <= max_val)
  2273. return torrc_value;
  2274. else
  2275. return networkstatus_get_param(
  2276. ns, param_name, default_val, min_val, max_val);
  2277. }
  2278. /**
  2279. * Retrieve the consensus parameter that governs the
  2280. * fixed-point precision of our network balancing 'bandwidth-weights'
  2281. * (which are themselves integer consensus values). We divide them
  2282. * by this value and ensure they never exceed this value.
  2283. */
  2284. int
  2285. networkstatus_get_weight_scale_param(networkstatus_t *ns)
  2286. {
  2287. return networkstatus_get_param(ns, "bwweightscale",
  2288. BW_WEIGHT_SCALE,
  2289. BW_MIN_WEIGHT_SCALE,
  2290. BW_MAX_WEIGHT_SCALE);
  2291. }
  2292. /** Return the value of a integer bw weight parameter from the networkstatus
  2293. * <b>ns</b> whose name is <b>weight_name</b>. If <b>ns</b> is NULL, try
  2294. * loading the latest consensus ourselves. Return <b>default_val</b> if no
  2295. * latest consensus, or if it has no parameter called <b>weight_name</b>. */
  2296. int32_t
  2297. networkstatus_get_bw_weight(networkstatus_t *ns, const char *weight_name,
  2298. int32_t default_val)
  2299. {
  2300. int32_t param;
  2301. int max;
  2302. if (!ns) /* if they pass in null, go find it ourselves */
  2303. ns = networkstatus_get_latest_consensus();
  2304. if (!ns || !ns->weight_params)
  2305. return default_val;
  2306. max = networkstatus_get_weight_scale_param(ns);
  2307. param = get_net_param_from_list(ns->weight_params, weight_name,
  2308. default_val, -1,
  2309. BW_MAX_WEIGHT_SCALE);
  2310. if (param > max) {
  2311. log_warn(LD_DIR, "Value of consensus weight %s was too large, capping "
  2312. "to %d", weight_name, max);
  2313. param = max;
  2314. }
  2315. return param;
  2316. }
  2317. /** Return the name of the consensus flavor <b>flav</b> as used to identify
  2318. * the flavor in directory documents. */
  2319. const char *
  2320. networkstatus_get_flavor_name(consensus_flavor_t flav)
  2321. {
  2322. switch (flav) {
  2323. case FLAV_NS:
  2324. return "ns";
  2325. case FLAV_MICRODESC:
  2326. return "microdesc";
  2327. default:
  2328. tor_fragile_assert();
  2329. return "??";
  2330. }
  2331. }
  2332. /** Return the consensus_flavor_t value for the flavor called <b>flavname</b>,
  2333. * or -1 if the flavor is not recognized. */
  2334. int
  2335. networkstatus_parse_flavor_name(const char *flavname)
  2336. {
  2337. if (!strcmp(flavname, "ns"))
  2338. return FLAV_NS;
  2339. else if (!strcmp(flavname, "microdesc"))
  2340. return FLAV_MICRODESC;
  2341. else
  2342. return -1;
  2343. }
  2344. /** Return 0 if this routerstatus is obsolete, too new, isn't
  2345. * running, or otherwise not a descriptor that we would make any
  2346. * use of even if we had it. Else return 1. */
  2347. int
  2348. client_would_use_router(const routerstatus_t *rs, time_t now)
  2349. {
  2350. if (!rs->is_flagged_running) {
  2351. /* If we had this router descriptor, we wouldn't even bother using it.
  2352. * (Fetching and storing depends on by we_want_to_fetch_flavor().) */
  2353. return 0;
  2354. }
  2355. if (rs->published_on + OLD_ROUTER_DESC_MAX_AGE < now) {
  2356. /* We'd drop it immediately for being too old. */
  2357. return 0;
  2358. }
  2359. if (!routerstatus_version_supports_extend2_cells(rs, 1)) {
  2360. /* We'd ignore it because it doesn't support EXTEND2 cells.
  2361. * If we don't know the version, download the descriptor so we can
  2362. * check if it supports EXTEND2 cells and ntor. */
  2363. return 0;
  2364. }
  2365. return 1;
  2366. }
  2367. /** If <b>question</b> is a string beginning with "ns/" in a format the
  2368. * control interface expects for a GETINFO question, set *<b>answer</b> to a
  2369. * newly-allocated string containing networkstatus lines for the appropriate
  2370. * ORs. Return 0 on success, -1 on unrecognized question format. */
  2371. int
  2372. getinfo_helper_networkstatus(control_connection_t *conn,
  2373. const char *question, char **answer,
  2374. const char **errmsg)
  2375. {
  2376. const routerstatus_t *status;
  2377. (void) conn;
  2378. if (!networkstatus_get_latest_consensus()) {
  2379. *answer = tor_strdup("");
  2380. return 0;
  2381. }
  2382. if (!strcmp(question, "ns/all")) {
  2383. smartlist_t *statuses = smartlist_new();
  2384. SMARTLIST_FOREACH(networkstatus_get_latest_consensus()->routerstatus_list,
  2385. const routerstatus_t *, rs,
  2386. {
  2387. smartlist_add(statuses, networkstatus_getinfo_helper_single(rs));
  2388. });
  2389. *answer = smartlist_join_strings(statuses, "", 0, NULL);
  2390. SMARTLIST_FOREACH(statuses, char *, cp, tor_free(cp));
  2391. smartlist_free(statuses);
  2392. return 0;
  2393. } else if (!strcmpstart(question, "ns/id/")) {
  2394. char d[DIGEST_LEN];
  2395. const char *q = question + 6;
  2396. if (*q == '$')
  2397. ++q;
  2398. if (base16_decode(d, DIGEST_LEN, q, strlen(q)) != DIGEST_LEN) {
  2399. *errmsg = "Data not decodeable as hex";
  2400. return -1;
  2401. }
  2402. status = router_get_consensus_status_by_id(d);
  2403. } else if (!strcmpstart(question, "ns/name/")) {
  2404. const node_t *n = node_get_by_nickname(question+8, 0);
  2405. status = n ? n->rs : NULL;
  2406. } else if (!strcmpstart(question, "ns/purpose/")) {
  2407. *answer = networkstatus_getinfo_by_purpose(question+11, time(NULL));
  2408. return *answer ? 0 : -1;
  2409. } else if (!strcmp(question, "consensus/packages")) {
  2410. const networkstatus_t *ns = networkstatus_get_latest_consensus();
  2411. if (ns && ns->package_lines)
  2412. *answer = smartlist_join_strings(ns->package_lines, "\n", 0, NULL);
  2413. else
  2414. *errmsg = "No consensus available";
  2415. return *answer ? 0 : -1;
  2416. } else if (!strcmp(question, "consensus/valid-after") ||
  2417. !strcmp(question, "consensus/fresh-until") ||
  2418. !strcmp(question, "consensus/valid-until")) {
  2419. const networkstatus_t *ns = networkstatus_get_latest_consensus();
  2420. if (ns) {
  2421. time_t t;
  2422. if (!strcmp(question, "consensus/valid-after"))
  2423. t = ns->valid_after;
  2424. else if (!strcmp(question, "consensus/fresh-until"))
  2425. t = ns->fresh_until;
  2426. else
  2427. t = ns->valid_until;
  2428. char tbuf[ISO_TIME_LEN+1];
  2429. format_iso_time(tbuf, t);
  2430. *answer = tor_strdup(tbuf);
  2431. } else {
  2432. *errmsg = "No consensus available";
  2433. }
  2434. return *answer ? 0 : -1;
  2435. } else {
  2436. return 0;
  2437. }
  2438. if (status)
  2439. *answer = networkstatus_getinfo_helper_single(status);
  2440. return 0;
  2441. }
  2442. /** Check whether the networkstatus <b>ns</b> lists any protocol
  2443. * versions as "required" or "recommended" that we do not support. If
  2444. * so, set *<b>warning_out</b> to a newly allocated string describing
  2445. * the problem.
  2446. *
  2447. * Return 1 if we should exit, 0 if we should not. */
  2448. int
  2449. networkstatus_check_required_protocols(const networkstatus_t *ns,
  2450. int client_mode,
  2451. char **warning_out)
  2452. {
  2453. const char *func = client_mode ? "client" : "relay";
  2454. const char *required, *recommended;
  2455. char *missing = NULL;
  2456. const bool consensus_postdates_this_release =
  2457. ns->valid_after >= tor_get_approx_release_date();
  2458. tor_assert(warning_out);
  2459. if (client_mode) {
  2460. required = ns->required_client_protocols;
  2461. recommended = ns->recommended_client_protocols;
  2462. } else {
  2463. required = ns->required_relay_protocols;
  2464. recommended = ns->recommended_relay_protocols;
  2465. }
  2466. if (!protover_all_supported(required, &missing)) {
  2467. tor_asprintf(warning_out, "At least one protocol listed as required in "
  2468. "the consensus is not supported by this version of Tor. "
  2469. "You should upgrade. This version of Tor will not work as a "
  2470. "%s on the Tor network. The missing protocols are: %s",
  2471. func, missing);
  2472. tor_free(missing);
  2473. return consensus_postdates_this_release ? 1 : 0;
  2474. }
  2475. if (! protover_all_supported(recommended, &missing)) {
  2476. tor_asprintf(warning_out, "At least one protocol listed as recommended in "
  2477. "the consensus is not supported by this version of Tor. "
  2478. "You should upgrade. This version of Tor will eventually "
  2479. "stop working as a %s on the Tor network. The missing "
  2480. "protocols are: %s",
  2481. func, missing);
  2482. tor_free(missing);
  2483. }
  2484. tor_assert_nonfatal(missing == NULL);
  2485. return 0;
  2486. }
  2487. /** Free all storage held locally in this module. */
  2488. void
  2489. networkstatus_free_all(void)
  2490. {
  2491. int i;
  2492. networkstatus_vote_free(current_ns_consensus);
  2493. networkstatus_vote_free(current_md_consensus);
  2494. current_md_consensus = current_ns_consensus = NULL;
  2495. for (i=0; i < N_CONSENSUS_FLAVORS; ++i) {
  2496. consensus_waiting_for_certs_t *waiting = &consensus_waiting_for_certs[i];
  2497. if (waiting->consensus) {
  2498. networkstatus_vote_free(waiting->consensus);
  2499. waiting->consensus = NULL;
  2500. }
  2501. }
  2502. }