networkstatus.c 92 KB

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