networkstatus.c 94 KB

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