nodelist.c 75 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396
  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 nodelist.c
  8. *
  9. * \brief Structures and functions for tracking what we know about the routers
  10. * on the Tor network, and correlating information from networkstatus,
  11. * routerinfo, and microdescs.
  12. *
  13. * The key structure here is node_t: that's the canonical way to refer
  14. * to a Tor relay that we might want to build a circuit through. Every
  15. * node_t has either a routerinfo_t, or a routerstatus_t from the current
  16. * networkstatus consensus. If it has a routerstatus_t, it will also
  17. * need to have a microdesc_t before you can use it for circuits.
  18. *
  19. * The nodelist_t is a global singleton that maps identities to node_t
  20. * objects. Access them with the node_get_*() functions. The nodelist_t
  21. * is maintained by calls throughout the codebase
  22. *
  23. * Generally, other code should not have to reach inside a node_t to
  24. * see what information it has. Instead, you should call one of the
  25. * many accessor functions that works on a generic node_t. If there
  26. * isn't one that does what you need, it's better to make such a function,
  27. * and then use it.
  28. *
  29. * For historical reasons, some of the functions that select a node_t
  30. * from the list of all usable node_t objects are in the routerlist.c
  31. * module, since they originally selected a routerinfo_t. (TODO: They
  32. * should move!)
  33. *
  34. * (TODO: Perhaps someday we should abstract the remaining ways of
  35. * talking about a relay to also be node_t instances. Those would be
  36. * routerstatus_t as used for directory requests, and dir_server_t as
  37. * used for authorities and fallback directories.)
  38. */
  39. #define NODELIST_PRIVATE
  40. #include "or.h"
  41. #include "address.h"
  42. #include "config.h"
  43. #include "control.h"
  44. #include "dirserv.h"
  45. #include "entrynodes.h"
  46. #include "geoip.h"
  47. #include "hs_common.h"
  48. #include "hs_client.h"
  49. #include "main.h"
  50. #include "microdesc.h"
  51. #include "networkstatus.h"
  52. #include "nodelist.h"
  53. #include "policies.h"
  54. #include "protover.h"
  55. #include "rendservice.h"
  56. #include "router.h"
  57. #include "routerlist.h"
  58. #include "routerparse.h"
  59. #include "routerset.h"
  60. #include "torcert.h"
  61. #include <string.h>
  62. static void nodelist_drop_node(node_t *node, int remove_from_ht);
  63. static void node_free(node_t *node);
  64. /** count_usable_descriptors counts descriptors with these flag(s)
  65. */
  66. typedef enum {
  67. /* All descriptors regardless of flags */
  68. USABLE_DESCRIPTOR_ALL = 0,
  69. /* Only descriptors with the Exit flag */
  70. USABLE_DESCRIPTOR_EXIT_ONLY = 1
  71. } usable_descriptor_t;
  72. static void count_usable_descriptors(int *num_present,
  73. int *num_usable,
  74. smartlist_t *descs_out,
  75. const networkstatus_t *consensus,
  76. time_t now,
  77. routerset_t *in_set,
  78. usable_descriptor_t exit_only);
  79. static void update_router_have_minimum_dir_info(void);
  80. static double get_frac_paths_needed_for_circs(const or_options_t *options,
  81. const networkstatus_t *ns);
  82. /** A nodelist_t holds a node_t object for every router we're "willing to use
  83. * for something". Specifically, it should hold a node_t for every node that
  84. * is currently in the routerlist, or currently in the consensus we're using.
  85. */
  86. typedef struct nodelist_t {
  87. /* A list of all the nodes. */
  88. smartlist_t *nodes;
  89. /* Hash table to map from node ID digest to node. */
  90. HT_HEAD(nodelist_map, node_t) nodes_by_id;
  91. /* Hash table to map from node Ed25519 ID to node.
  92. *
  93. * Whenever a node's routerinfo or microdescriptor is about to change,
  94. * you should remove it from this map with node_remove_from_ed25519_map().
  95. * Whenever a node's routerinfo or microdescriptor has just chaned,
  96. * you should add it to this map with node_add_to_ed25519_map().
  97. */
  98. HT_HEAD(nodelist_ed_map, node_t) nodes_by_ed_id;
  99. } nodelist_t;
  100. static inline unsigned int
  101. node_id_hash(const node_t *node)
  102. {
  103. return (unsigned) siphash24g(node->identity, DIGEST_LEN);
  104. }
  105. static inline unsigned int
  106. node_id_eq(const node_t *node1, const node_t *node2)
  107. {
  108. return tor_memeq(node1->identity, node2->identity, DIGEST_LEN);
  109. }
  110. HT_PROTOTYPE(nodelist_map, node_t, ht_ent, node_id_hash, node_id_eq)
  111. HT_GENERATE2(nodelist_map, node_t, ht_ent, node_id_hash, node_id_eq,
  112. 0.6, tor_reallocarray_, tor_free_)
  113. static inline unsigned int
  114. node_ed_id_hash(const node_t *node)
  115. {
  116. return (unsigned) siphash24g(node->ed25519_id.pubkey, ED25519_PUBKEY_LEN);
  117. }
  118. static inline unsigned int
  119. node_ed_id_eq(const node_t *node1, const node_t *node2)
  120. {
  121. return ed25519_pubkey_eq(&node1->ed25519_id, &node2->ed25519_id);
  122. }
  123. HT_PROTOTYPE(nodelist_ed_map, node_t, ed_ht_ent, node_ed_id_hash,
  124. node_ed_id_eq)
  125. HT_GENERATE2(nodelist_ed_map, node_t, ed_ht_ent, node_ed_id_hash,
  126. node_ed_id_eq, 0.6, tor_reallocarray_, tor_free_)
  127. /** The global nodelist. */
  128. static nodelist_t *the_nodelist=NULL;
  129. /** Create an empty nodelist if we haven't done so already. */
  130. static void
  131. init_nodelist(void)
  132. {
  133. if (PREDICT_UNLIKELY(the_nodelist == NULL)) {
  134. the_nodelist = tor_malloc_zero(sizeof(nodelist_t));
  135. HT_INIT(nodelist_map, &the_nodelist->nodes_by_id);
  136. HT_INIT(nodelist_ed_map, &the_nodelist->nodes_by_ed_id);
  137. the_nodelist->nodes = smartlist_new();
  138. }
  139. }
  140. /** As node_get_by_id, but returns a non-const pointer */
  141. node_t *
  142. node_get_mutable_by_id(const char *identity_digest)
  143. {
  144. node_t search, *node;
  145. if (PREDICT_UNLIKELY(the_nodelist == NULL))
  146. return NULL;
  147. memcpy(&search.identity, identity_digest, DIGEST_LEN);
  148. node = HT_FIND(nodelist_map, &the_nodelist->nodes_by_id, &search);
  149. return node;
  150. }
  151. /** As node_get_by_ed25519_id, but returns a non-const pointer */
  152. node_t *
  153. node_get_mutable_by_ed25519_id(const ed25519_public_key_t *ed_id)
  154. {
  155. node_t search, *node;
  156. if (PREDICT_UNLIKELY(the_nodelist == NULL))
  157. return NULL;
  158. if (BUG(ed_id == NULL) || BUG(ed25519_public_key_is_zero(ed_id)))
  159. return NULL;
  160. memcpy(&search.ed25519_id, ed_id, sizeof(search.ed25519_id));
  161. node = HT_FIND(nodelist_ed_map, &the_nodelist->nodes_by_ed_id, &search);
  162. return node;
  163. }
  164. /** Return the node_t whose identity is <b>identity_digest</b>, or NULL
  165. * if no such node exists. */
  166. MOCK_IMPL(const node_t *,
  167. node_get_by_id,(const char *identity_digest))
  168. {
  169. return node_get_mutable_by_id(identity_digest);
  170. }
  171. /** Return the node_t whose ed25519 identity is <b>ed_id</b>, or NULL
  172. * if no such node exists. */
  173. MOCK_IMPL(const node_t *,
  174. node_get_by_ed25519_id,(const ed25519_public_key_t *ed_id))
  175. {
  176. return node_get_mutable_by_ed25519_id(ed_id);
  177. }
  178. /** Internal: return the node_t whose identity_digest is
  179. * <b>identity_digest</b>. If none exists, create a new one, add it to the
  180. * nodelist, and return it.
  181. *
  182. * Requires that the nodelist be initialized.
  183. */
  184. static node_t *
  185. node_get_or_create(const char *identity_digest)
  186. {
  187. node_t *node;
  188. if ((node = node_get_mutable_by_id(identity_digest)))
  189. return node;
  190. node = tor_malloc_zero(sizeof(node_t));
  191. memcpy(node->identity, identity_digest, DIGEST_LEN);
  192. HT_INSERT(nodelist_map, &the_nodelist->nodes_by_id, node);
  193. smartlist_add(the_nodelist->nodes, node);
  194. node->nodelist_idx = smartlist_len(the_nodelist->nodes) - 1;
  195. node->hsdir_index = tor_malloc_zero(sizeof(hsdir_index_t));
  196. node->country = -1;
  197. return node;
  198. }
  199. /** Remove <b>node</b> from the ed25519 map (if it present), and
  200. * set its ed25519_id field to zero. */
  201. static int
  202. node_remove_from_ed25519_map(node_t *node)
  203. {
  204. tor_assert(the_nodelist);
  205. tor_assert(node);
  206. if (ed25519_public_key_is_zero(&node->ed25519_id)) {
  207. return 0;
  208. }
  209. int rv = 0;
  210. node_t *search =
  211. HT_FIND(nodelist_ed_map, &the_nodelist->nodes_by_ed_id, node);
  212. if (BUG(search != node)) {
  213. goto clear_and_return;
  214. }
  215. search = HT_REMOVE(nodelist_ed_map, &the_nodelist->nodes_by_ed_id, node);
  216. tor_assert(search == node);
  217. rv = 1;
  218. clear_and_return:
  219. memset(&node->ed25519_id, 0, sizeof(node->ed25519_id));
  220. return rv;
  221. }
  222. /** If <b>node</b> has an ed25519 id, and it is not already in the ed25519 id
  223. * map, set its ed25519_id field, and add it to the ed25519 map.
  224. */
  225. static int
  226. node_add_to_ed25519_map(node_t *node)
  227. {
  228. tor_assert(the_nodelist);
  229. tor_assert(node);
  230. if (! ed25519_public_key_is_zero(&node->ed25519_id)) {
  231. return 0;
  232. }
  233. const ed25519_public_key_t *key = node_get_ed25519_id(node);
  234. if (!key) {
  235. return 0;
  236. }
  237. node_t *old;
  238. memcpy(&node->ed25519_id, key, sizeof(node->ed25519_id));
  239. old = HT_FIND(nodelist_ed_map, &the_nodelist->nodes_by_ed_id, node);
  240. if (BUG(old)) {
  241. /* XXXX order matters here, and this may mean that authorities aren't
  242. * pinning. */
  243. if (old != node)
  244. memset(&node->ed25519_id, 0, sizeof(node->ed25519_id));
  245. return 0;
  246. }
  247. HT_INSERT(nodelist_ed_map, &the_nodelist->nodes_by_ed_id, node);
  248. return 1;
  249. }
  250. /* For a given <b>node</b> for the consensus <b>ns</b>, set the hsdir index
  251. * for the node, both current and next if possible. This can only fails if the
  252. * node_t ed25519 identity key can't be found which would be a bug. */
  253. STATIC void
  254. node_set_hsdir_index(node_t *node, const networkstatus_t *ns)
  255. {
  256. time_t now = approx_time();
  257. const ed25519_public_key_t *node_identity_pk;
  258. uint8_t *fetch_srv = NULL, *store_first_srv = NULL, *store_second_srv = NULL;
  259. uint64_t next_time_period_num, current_time_period_num;
  260. uint64_t fetch_tp, store_first_tp, store_second_tp;
  261. tor_assert(node);
  262. tor_assert(ns);
  263. if (!networkstatus_is_live(ns, now)) {
  264. static struct ratelim_t live_consensus_ratelim = RATELIM_INIT(30 * 60);
  265. log_fn_ratelim(&live_consensus_ratelim, LOG_INFO, LD_GENERAL,
  266. "Not setting hsdir index with a non-live consensus.");
  267. goto done;
  268. }
  269. node_identity_pk = node_get_ed25519_id(node);
  270. if (node_identity_pk == NULL) {
  271. log_debug(LD_GENERAL, "ed25519 identity public key not found when "
  272. "trying to build the hsdir indexes for node %s",
  273. node_describe(node));
  274. goto done;
  275. }
  276. /* Get the current and next time period number. */
  277. current_time_period_num = hs_get_time_period_num(0);
  278. next_time_period_num = hs_get_next_time_period_num(0);
  279. /* We always use the current time period for fetching descs */
  280. fetch_tp = current_time_period_num;
  281. /* Now extract the needed SRVs and time periods for building hsdir indices */
  282. if (hs_in_period_between_tp_and_srv(ns, now)) {
  283. fetch_srv = hs_get_current_srv(fetch_tp, ns);
  284. store_first_tp = hs_get_previous_time_period_num(0);
  285. store_second_tp = current_time_period_num;
  286. } else {
  287. fetch_srv = hs_get_previous_srv(fetch_tp, ns);
  288. store_first_tp = current_time_period_num;
  289. store_second_tp = next_time_period_num;
  290. }
  291. /* We always use the old SRV for storing the first descriptor and the latest
  292. * SRV for storing the second descriptor */
  293. store_first_srv = hs_get_previous_srv(store_first_tp, ns);
  294. store_second_srv = hs_get_current_srv(store_second_tp, ns);
  295. /* Build the fetch index. */
  296. hs_build_hsdir_index(node_identity_pk, fetch_srv, fetch_tp,
  297. node->hsdir_index->fetch);
  298. /* If we are in the time segment between SRV#N and TP#N, the fetch index is
  299. the same as the first store index */
  300. if (!hs_in_period_between_tp_and_srv(ns, now)) {
  301. memcpy(node->hsdir_index->store_first, node->hsdir_index->fetch,
  302. sizeof(node->hsdir_index->store_first));
  303. } else {
  304. hs_build_hsdir_index(node_identity_pk, store_first_srv, store_first_tp,
  305. node->hsdir_index->store_first);
  306. }
  307. /* If we are in the time segment between TP#N and SRV#N+1, the fetch index is
  308. the same as the second store index */
  309. if (hs_in_period_between_tp_and_srv(ns, now)) {
  310. memcpy(node->hsdir_index->store_second, node->hsdir_index->fetch,
  311. sizeof(node->hsdir_index->store_second));
  312. } else {
  313. hs_build_hsdir_index(node_identity_pk, store_second_srv, store_second_tp,
  314. node->hsdir_index->store_second);
  315. }
  316. done:
  317. tor_free(fetch_srv);
  318. tor_free(store_first_srv);
  319. tor_free(store_second_srv);
  320. return;
  321. }
  322. /** Recompute all node hsdir indices. */
  323. void
  324. nodelist_recompute_all_hsdir_indices(void)
  325. {
  326. networkstatus_t *consensus;
  327. if (!the_nodelist) {
  328. return;
  329. }
  330. /* Get a live consensus. Abort if not found */
  331. consensus = networkstatus_get_live_consensus(approx_time());
  332. if (!consensus) {
  333. return;
  334. }
  335. /* Recompute all hsdir indices */
  336. SMARTLIST_FOREACH_BEGIN(the_nodelist->nodes, node_t *, node) {
  337. node_set_hsdir_index(node, consensus);
  338. } SMARTLIST_FOREACH_END(node);
  339. }
  340. /** Called when a node's address changes. */
  341. static void
  342. node_addrs_changed(node_t *node)
  343. {
  344. node->last_reachable = node->last_reachable6 = 0;
  345. node->country = -1;
  346. }
  347. /** Add <b>ri</b> to an appropriate node in the nodelist. If we replace an
  348. * old routerinfo, and <b>ri_old_out</b> is not NULL, set *<b>ri_old_out</b>
  349. * to the previous routerinfo.
  350. */
  351. node_t *
  352. nodelist_set_routerinfo(routerinfo_t *ri, routerinfo_t **ri_old_out)
  353. {
  354. node_t *node;
  355. const char *id_digest;
  356. int had_router = 0;
  357. tor_assert(ri);
  358. init_nodelist();
  359. id_digest = ri->cache_info.identity_digest;
  360. node = node_get_or_create(id_digest);
  361. node_remove_from_ed25519_map(node);
  362. if (node->ri) {
  363. if (!routers_have_same_or_addrs(node->ri, ri)) {
  364. node_addrs_changed(node);
  365. }
  366. had_router = 1;
  367. if (ri_old_out)
  368. *ri_old_out = node->ri;
  369. } else {
  370. if (ri_old_out)
  371. *ri_old_out = NULL;
  372. }
  373. node->ri = ri;
  374. node_add_to_ed25519_map(node);
  375. if (node->country == -1)
  376. node_set_country(node);
  377. if (authdir_mode(get_options()) && !had_router) {
  378. const char *discard=NULL;
  379. uint32_t status = dirserv_router_get_status(ri, &discard, LOG_INFO);
  380. dirserv_set_node_flags_from_authoritative_status(node, status);
  381. }
  382. /* Setting the HSDir index requires the ed25519 identity key which can
  383. * only be found either in the ri or md. This is why this is called here.
  384. * Only nodes supporting HSDir=2 protocol version needs this index. */
  385. if (node->rs && node->rs->supports_v3_hsdir) {
  386. node_set_hsdir_index(node,
  387. networkstatus_get_latest_consensus());
  388. }
  389. return node;
  390. }
  391. /** Set the appropriate node_t to use <b>md</b> as its microdescriptor.
  392. *
  393. * Called when a new microdesc has arrived and the usable consensus flavor
  394. * is "microdesc".
  395. **/
  396. node_t *
  397. nodelist_add_microdesc(microdesc_t *md)
  398. {
  399. networkstatus_t *ns =
  400. networkstatus_get_latest_consensus_by_flavor(FLAV_MICRODESC);
  401. const routerstatus_t *rs;
  402. node_t *node;
  403. if (ns == NULL)
  404. return NULL;
  405. init_nodelist();
  406. /* Microdescriptors don't carry an identity digest, so we need to figure
  407. * it out by looking up the routerstatus. */
  408. rs = router_get_consensus_status_by_descriptor_digest(ns, md->digest);
  409. if (rs == NULL)
  410. return NULL;
  411. node = node_get_mutable_by_id(rs->identity_digest);
  412. if (node) {
  413. node_remove_from_ed25519_map(node);
  414. if (node->md)
  415. node->md->held_by_nodes--;
  416. node->md = md;
  417. md->held_by_nodes++;
  418. /* Setting the HSDir index requires the ed25519 identity key which can
  419. * only be found either in the ri or md. This is why this is called here.
  420. * Only nodes supporting HSDir=2 protocol version needs this index. */
  421. if (rs->supports_v3_hsdir) {
  422. node_set_hsdir_index(node, ns);
  423. }
  424. node_add_to_ed25519_map(node);
  425. }
  426. return node;
  427. }
  428. /** Tell the nodelist that the current usable consensus is <b>ns</b>.
  429. * This makes the nodelist change all of the routerstatus entries for
  430. * the nodes, drop nodes that no longer have enough info to get used,
  431. * and grab microdescriptors into nodes as appropriate.
  432. */
  433. void
  434. nodelist_set_consensus(networkstatus_t *ns)
  435. {
  436. const or_options_t *options = get_options();
  437. int authdir = authdir_mode_v3(options);
  438. init_nodelist();
  439. if (ns->flavor == FLAV_MICRODESC)
  440. (void) get_microdesc_cache(); /* Make sure it exists first. */
  441. SMARTLIST_FOREACH(the_nodelist->nodes, node_t *, node,
  442. node->rs = NULL);
  443. SMARTLIST_FOREACH_BEGIN(ns->routerstatus_list, routerstatus_t *, rs) {
  444. node_t *node = node_get_or_create(rs->identity_digest);
  445. node->rs = rs;
  446. if (ns->flavor == FLAV_MICRODESC) {
  447. if (node->md == NULL ||
  448. tor_memneq(node->md->digest,rs->descriptor_digest,DIGEST256_LEN)) {
  449. node_remove_from_ed25519_map(node);
  450. if (node->md)
  451. node->md->held_by_nodes--;
  452. node->md = microdesc_cache_lookup_by_digest256(NULL,
  453. rs->descriptor_digest);
  454. if (node->md)
  455. node->md->held_by_nodes++;
  456. node_add_to_ed25519_map(node);
  457. }
  458. }
  459. if (rs->supports_v3_hsdir) {
  460. node_set_hsdir_index(node, ns);
  461. }
  462. node_set_country(node);
  463. /* If we're not an authdir, believe others. */
  464. if (!authdir) {
  465. node->is_valid = rs->is_valid;
  466. node->is_running = rs->is_flagged_running;
  467. node->is_fast = rs->is_fast;
  468. node->is_stable = rs->is_stable;
  469. node->is_possible_guard = rs->is_possible_guard;
  470. node->is_exit = rs->is_exit;
  471. node->is_bad_exit = rs->is_bad_exit;
  472. node->is_hs_dir = rs->is_hs_dir;
  473. node->ipv6_preferred = 0;
  474. if (fascist_firewall_prefer_ipv6_orport(options) &&
  475. (tor_addr_is_null(&rs->ipv6_addr) == 0 ||
  476. (node->md && tor_addr_is_null(&node->md->ipv6_addr) == 0)))
  477. node->ipv6_preferred = 1;
  478. }
  479. } SMARTLIST_FOREACH_END(rs);
  480. nodelist_purge();
  481. if (! authdir) {
  482. SMARTLIST_FOREACH_BEGIN(the_nodelist->nodes, node_t *, node) {
  483. /* We have no routerstatus for this router. Clear flags so we can skip
  484. * it, maybe.*/
  485. if (!node->rs) {
  486. tor_assert(node->ri); /* if it had only an md, or nothing, purge
  487. * would have removed it. */
  488. if (node->ri->purpose == ROUTER_PURPOSE_GENERAL) {
  489. /* Clear all flags. */
  490. node->is_valid = node->is_running = node->is_hs_dir =
  491. node->is_fast = node->is_stable =
  492. node->is_possible_guard = node->is_exit =
  493. node->is_bad_exit = node->ipv6_preferred = 0;
  494. }
  495. }
  496. } SMARTLIST_FOREACH_END(node);
  497. }
  498. }
  499. /** Helper: return true iff a node has a usable amount of information*/
  500. static inline int
  501. node_is_usable(const node_t *node)
  502. {
  503. return (node->rs) || (node->ri);
  504. }
  505. /** Tell the nodelist that <b>md</b> is no longer a microdescriptor for the
  506. * node with <b>identity_digest</b>. */
  507. void
  508. nodelist_remove_microdesc(const char *identity_digest, microdesc_t *md)
  509. {
  510. node_t *node = node_get_mutable_by_id(identity_digest);
  511. if (node && node->md == md) {
  512. node->md = NULL;
  513. md->held_by_nodes--;
  514. if (! node_get_ed25519_id(node)) {
  515. node_remove_from_ed25519_map(node);
  516. }
  517. }
  518. }
  519. /** Tell the nodelist that <b>ri</b> is no longer in the routerlist. */
  520. void
  521. nodelist_remove_routerinfo(routerinfo_t *ri)
  522. {
  523. node_t *node = node_get_mutable_by_id(ri->cache_info.identity_digest);
  524. if (node && node->ri == ri) {
  525. node->ri = NULL;
  526. if (! node_is_usable(node)) {
  527. nodelist_drop_node(node, 1);
  528. node_free(node);
  529. }
  530. }
  531. }
  532. /** Remove <b>node</b> from the nodelist. (Asserts that it was there to begin
  533. * with.) */
  534. static void
  535. nodelist_drop_node(node_t *node, int remove_from_ht)
  536. {
  537. node_t *tmp;
  538. int idx;
  539. if (remove_from_ht) {
  540. tmp = HT_REMOVE(nodelist_map, &the_nodelist->nodes_by_id, node);
  541. tor_assert(tmp == node);
  542. }
  543. node_remove_from_ed25519_map(node);
  544. idx = node->nodelist_idx;
  545. tor_assert(idx >= 0);
  546. tor_assert(node == smartlist_get(the_nodelist->nodes, idx));
  547. smartlist_del(the_nodelist->nodes, idx);
  548. if (idx < smartlist_len(the_nodelist->nodes)) {
  549. tmp = smartlist_get(the_nodelist->nodes, idx);
  550. tmp->nodelist_idx = idx;
  551. }
  552. node->nodelist_idx = -1;
  553. }
  554. /** Return a newly allocated smartlist of the nodes that have <b>md</b> as
  555. * their microdescriptor. */
  556. smartlist_t *
  557. nodelist_find_nodes_with_microdesc(const microdesc_t *md)
  558. {
  559. smartlist_t *result = smartlist_new();
  560. if (the_nodelist == NULL)
  561. return result;
  562. SMARTLIST_FOREACH_BEGIN(the_nodelist->nodes, node_t *, node) {
  563. if (node->md == md) {
  564. smartlist_add(result, node);
  565. }
  566. } SMARTLIST_FOREACH_END(node);
  567. return result;
  568. }
  569. /** Release storage held by <b>node</b> */
  570. static void
  571. node_free(node_t *node)
  572. {
  573. if (!node)
  574. return;
  575. if (node->md)
  576. node->md->held_by_nodes--;
  577. tor_assert(node->nodelist_idx == -1);
  578. tor_free(node->hsdir_index);
  579. tor_free(node);
  580. }
  581. /** Remove all entries from the nodelist that don't have enough info to be
  582. * usable for anything. */
  583. void
  584. nodelist_purge(void)
  585. {
  586. node_t **iter;
  587. if (PREDICT_UNLIKELY(the_nodelist == NULL))
  588. return;
  589. /* Remove the non-usable nodes. */
  590. for (iter = HT_START(nodelist_map, &the_nodelist->nodes_by_id); iter; ) {
  591. node_t *node = *iter;
  592. if (node->md && !node->rs) {
  593. /* An md is only useful if there is an rs. */
  594. node->md->held_by_nodes--;
  595. node->md = NULL;
  596. }
  597. if (node_is_usable(node)) {
  598. iter = HT_NEXT(nodelist_map, &the_nodelist->nodes_by_id, iter);
  599. } else {
  600. iter = HT_NEXT_RMV(nodelist_map, &the_nodelist->nodes_by_id, iter);
  601. nodelist_drop_node(node, 0);
  602. node_free(node);
  603. }
  604. }
  605. nodelist_assert_ok();
  606. }
  607. /** Release all storage held by the nodelist. */
  608. void
  609. nodelist_free_all(void)
  610. {
  611. if (PREDICT_UNLIKELY(the_nodelist == NULL))
  612. return;
  613. HT_CLEAR(nodelist_map, &the_nodelist->nodes_by_id);
  614. HT_CLEAR(nodelist_ed_map, &the_nodelist->nodes_by_ed_id);
  615. SMARTLIST_FOREACH_BEGIN(the_nodelist->nodes, node_t *, node) {
  616. node->nodelist_idx = -1;
  617. node_free(node);
  618. } SMARTLIST_FOREACH_END(node);
  619. smartlist_free(the_nodelist->nodes);
  620. tor_free(the_nodelist);
  621. }
  622. /** Check that the nodelist is internally consistent, and consistent with
  623. * the directory info it's derived from.
  624. */
  625. void
  626. nodelist_assert_ok(void)
  627. {
  628. routerlist_t *rl = router_get_routerlist();
  629. networkstatus_t *ns = networkstatus_get_latest_consensus();
  630. digestmap_t *dm;
  631. if (!the_nodelist)
  632. return;
  633. dm = digestmap_new();
  634. /* every routerinfo in rl->routers should be in the nodelist. */
  635. if (rl) {
  636. SMARTLIST_FOREACH_BEGIN(rl->routers, routerinfo_t *, ri) {
  637. const node_t *node = node_get_by_id(ri->cache_info.identity_digest);
  638. tor_assert(node && node->ri == ri);
  639. tor_assert(fast_memeq(ri->cache_info.identity_digest,
  640. node->identity, DIGEST_LEN));
  641. tor_assert(! digestmap_get(dm, node->identity));
  642. digestmap_set(dm, node->identity, (void*)node);
  643. } SMARTLIST_FOREACH_END(ri);
  644. }
  645. /* every routerstatus in ns should be in the nodelist */
  646. if (ns) {
  647. SMARTLIST_FOREACH_BEGIN(ns->routerstatus_list, routerstatus_t *, rs) {
  648. const node_t *node = node_get_by_id(rs->identity_digest);
  649. tor_assert(node && node->rs == rs);
  650. tor_assert(fast_memeq(rs->identity_digest, node->identity, DIGEST_LEN));
  651. digestmap_set(dm, node->identity, (void*)node);
  652. if (ns->flavor == FLAV_MICRODESC) {
  653. /* If it's a microdesc consensus, every entry that has a
  654. * microdescriptor should be in the nodelist.
  655. */
  656. microdesc_t *md =
  657. microdesc_cache_lookup_by_digest256(NULL, rs->descriptor_digest);
  658. tor_assert(md == node->md);
  659. if (md)
  660. tor_assert(md->held_by_nodes >= 1);
  661. }
  662. } SMARTLIST_FOREACH_END(rs);
  663. }
  664. /* The nodelist should have no other entries, and its entries should be
  665. * well-formed. */
  666. SMARTLIST_FOREACH_BEGIN(the_nodelist->nodes, node_t *, node) {
  667. tor_assert(digestmap_get(dm, node->identity) != NULL);
  668. tor_assert(node_sl_idx == node->nodelist_idx);
  669. } SMARTLIST_FOREACH_END(node);
  670. /* Every node listed with an ed25519 identity should be listed by that
  671. * identity.
  672. */
  673. SMARTLIST_FOREACH_BEGIN(the_nodelist->nodes, node_t *, node) {
  674. if (!ed25519_public_key_is_zero(&node->ed25519_id)) {
  675. tor_assert(node == node_get_by_ed25519_id(&node->ed25519_id));
  676. }
  677. } SMARTLIST_FOREACH_END(node);
  678. node_t **idx;
  679. HT_FOREACH(idx, nodelist_ed_map, &the_nodelist->nodes_by_ed_id) {
  680. node_t *node = *idx;
  681. tor_assert(node == node_get_by_ed25519_id(&node->ed25519_id));
  682. }
  683. tor_assert((long)smartlist_len(the_nodelist->nodes) ==
  684. (long)HT_SIZE(&the_nodelist->nodes_by_id));
  685. tor_assert((long)smartlist_len(the_nodelist->nodes) >=
  686. (long)HT_SIZE(&the_nodelist->nodes_by_ed_id));
  687. digestmap_free(dm, NULL);
  688. }
  689. /** Return a list of a node_t * for every node we know about. The caller
  690. * MUST NOT modify the list. (You can set and clear flags in the nodes if
  691. * you must, but you must not add or remove nodes.) */
  692. MOCK_IMPL(smartlist_t *,
  693. nodelist_get_list,(void))
  694. {
  695. init_nodelist();
  696. return the_nodelist->nodes;
  697. }
  698. /** Given a hex-encoded nickname of the format DIGEST, $DIGEST, $DIGEST=name,
  699. * or $DIGEST~name, return the node with the matching identity digest and
  700. * nickname (if any). Return NULL if no such node exists, or if <b>hex_id</b>
  701. * is not well-formed. DOCDOC flags */
  702. const node_t *
  703. node_get_by_hex_id(const char *hex_id, unsigned flags)
  704. {
  705. char digest_buf[DIGEST_LEN];
  706. char nn_buf[MAX_NICKNAME_LEN+1];
  707. char nn_char='\0';
  708. (void) flags; // XXXX
  709. if (hex_digest_nickname_decode(hex_id, digest_buf, &nn_char, nn_buf)==0) {
  710. const node_t *node = node_get_by_id(digest_buf);
  711. if (!node)
  712. return NULL;
  713. if (nn_char == '=') {
  714. /* "=" indicates a Named relay, but there aren't any of those now. */
  715. return NULL;
  716. }
  717. return node;
  718. }
  719. return NULL;
  720. }
  721. /** Given a nickname (possibly verbose, possibly a hexadecimal digest), return
  722. * the corresponding node_t, or NULL if none exists. Warn the user if they
  723. * have specified a router by nickname, unless the NNF_NO_WARN_UNNAMED bit is
  724. * set in <b>flags</b>. */
  725. MOCK_IMPL(const node_t *,
  726. node_get_by_nickname,(const char *nickname, unsigned flags))
  727. {
  728. const int warn_if_unnamed = !(flags & NNF_NO_WARN_UNNAMED);
  729. if (!the_nodelist)
  730. return NULL;
  731. /* Handle these cases: DIGEST, $DIGEST, $DIGEST=name, $DIGEST~name. */
  732. {
  733. const node_t *node;
  734. if ((node = node_get_by_hex_id(nickname, flags)) != NULL)
  735. return node;
  736. }
  737. if (!strcasecmp(nickname, UNNAMED_ROUTER_NICKNAME))
  738. return NULL;
  739. /* Okay, so the name is not canonical for anybody. */
  740. {
  741. smartlist_t *matches = smartlist_new();
  742. const node_t *choice = NULL;
  743. SMARTLIST_FOREACH_BEGIN(the_nodelist->nodes, node_t *, node) {
  744. if (!strcasecmp(node_get_nickname(node), nickname))
  745. smartlist_add(matches, node);
  746. } SMARTLIST_FOREACH_END(node);
  747. if (smartlist_len(matches)>1 && warn_if_unnamed) {
  748. int any_unwarned = 0;
  749. SMARTLIST_FOREACH_BEGIN(matches, node_t *, node) {
  750. if (!node->name_lookup_warned) {
  751. node->name_lookup_warned = 1;
  752. any_unwarned = 1;
  753. }
  754. } SMARTLIST_FOREACH_END(node);
  755. if (any_unwarned) {
  756. log_warn(LD_CONFIG, "There are multiple matches for the name %s, "
  757. "but none is listed as Named in the directory consensus. "
  758. "Choosing one arbitrarily.", nickname);
  759. }
  760. } else if (smartlist_len(matches)==1 && warn_if_unnamed) {
  761. char fp[HEX_DIGEST_LEN+1];
  762. node_t *node = smartlist_get(matches, 0);
  763. if (! node->name_lookup_warned) {
  764. base16_encode(fp, sizeof(fp), node->identity, DIGEST_LEN);
  765. log_warn(LD_CONFIG,
  766. "You specified a relay \"%s\" by name, but nicknames can be "
  767. "used by any relay, not just the one you meant. "
  768. "To make sure you get the same relay in the future, refer "
  769. "to it by key, as \"$%s\".", nickname, fp);
  770. node->name_lookup_warned = 1;
  771. }
  772. }
  773. if (smartlist_len(matches))
  774. choice = smartlist_get(matches, 0);
  775. smartlist_free(matches);
  776. return choice;
  777. }
  778. }
  779. /** Return the Ed25519 identity key for the provided node, or NULL if it
  780. * doesn't have one. */
  781. const ed25519_public_key_t *
  782. node_get_ed25519_id(const node_t *node)
  783. {
  784. const ed25519_public_key_t *ri_pk = NULL;
  785. const ed25519_public_key_t *md_pk = NULL;
  786. if (node->ri) {
  787. if (node->ri->cache_info.signing_key_cert) {
  788. ri_pk = &node->ri->cache_info.signing_key_cert->signing_key;
  789. if (BUG(ed25519_public_key_is_zero(ri_pk)))
  790. ri_pk = NULL;
  791. }
  792. }
  793. if (node->md) {
  794. if (node->md->ed25519_identity_pkey) {
  795. md_pk = node->md->ed25519_identity_pkey;
  796. }
  797. }
  798. if (ri_pk && md_pk) {
  799. if (ed25519_pubkey_eq(ri_pk, md_pk)) {
  800. return ri_pk;
  801. } else {
  802. /* This can happen if the relay gets flagged NoEdConsensus which will be
  803. * triggered on all relays of the network. Thus a protocol warning. */
  804. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  805. "Inconsistent ed25519 identities in the nodelist");
  806. return NULL;
  807. }
  808. } else if (ri_pk) {
  809. return ri_pk;
  810. } else {
  811. return md_pk;
  812. }
  813. }
  814. /** Return true iff this node's Ed25519 identity matches <b>id</b>.
  815. * (An absent Ed25519 identity matches NULL or zero.) */
  816. int
  817. node_ed25519_id_matches(const node_t *node, const ed25519_public_key_t *id)
  818. {
  819. const ed25519_public_key_t *node_id = node_get_ed25519_id(node);
  820. if (node_id == NULL || ed25519_public_key_is_zero(node_id)) {
  821. return id == NULL || ed25519_public_key_is_zero(id);
  822. } else {
  823. return id && ed25519_pubkey_eq(node_id, id);
  824. }
  825. }
  826. /** Return true iff <b>node</b> supports authenticating itself
  827. * by ed25519 ID during the link handshake. If <b>compatible_with_us</b>,
  828. * it needs to be using a link authentication method that we understand.
  829. * If not, any plausible link authentication method will do. */
  830. int
  831. node_supports_ed25519_link_authentication(const node_t *node,
  832. int compatible_with_us)
  833. {
  834. if (! node_get_ed25519_id(node))
  835. return 0;
  836. if (node->ri) {
  837. const char *protos = node->ri->protocol_list;
  838. if (protos == NULL)
  839. return 0;
  840. if (compatible_with_us)
  841. return protocol_list_supports_protocol(protos, PRT_LINKAUTH, 3);
  842. else
  843. return protocol_list_supports_protocol_or_later(protos, PRT_LINKAUTH, 3);
  844. }
  845. if (node->rs) {
  846. if (compatible_with_us)
  847. return node->rs->supports_ed25519_link_handshake_compat;
  848. else
  849. return node->rs->supports_ed25519_link_handshake_any;
  850. }
  851. tor_assert_nonfatal_unreached_once();
  852. return 0;
  853. }
  854. /** Return true iff <b>node</b> supports the hidden service directory version
  855. * 3 protocol (proposal 224). */
  856. int
  857. node_supports_v3_hsdir(const node_t *node)
  858. {
  859. tor_assert(node);
  860. if (node->rs) {
  861. return node->rs->supports_v3_hsdir;
  862. }
  863. if (node->ri) {
  864. if (node->ri->protocol_list == NULL) {
  865. return 0;
  866. }
  867. /* Bug #22447 forces us to filter on tor version:
  868. * If platform is a Tor version, and older than 0.3.0.8, return False.
  869. * Else, obey the protocol list. */
  870. if (node->ri->platform) {
  871. if (!strcmpstart(node->ri->platform, "Tor ") &&
  872. !tor_version_as_new_as(node->ri->platform, "0.3.0.8")) {
  873. return 0;
  874. }
  875. }
  876. return protocol_list_supports_protocol(node->ri->protocol_list,
  877. PRT_HSDIR, PROTOVER_HSDIR_V3);
  878. }
  879. tor_assert_nonfatal_unreached_once();
  880. return 0;
  881. }
  882. /** Return true iff <b>node</b> supports ed25519 authentication as an hidden
  883. * service introduction point.*/
  884. int
  885. node_supports_ed25519_hs_intro(const node_t *node)
  886. {
  887. tor_assert(node);
  888. if (node->rs) {
  889. return node->rs->supports_ed25519_hs_intro;
  890. }
  891. if (node->ri) {
  892. if (node->ri->protocol_list == NULL) {
  893. return 0;
  894. }
  895. return protocol_list_supports_protocol(node->ri->protocol_list,
  896. PRT_HSINTRO, PROTOVER_HS_INTRO_V3);
  897. }
  898. tor_assert_nonfatal_unreached_once();
  899. return 0;
  900. }
  901. /** Return true iff <b>node</b> supports to be a rendezvous point for hidden
  902. * service version 3 (HSRend=2). */
  903. int
  904. node_supports_v3_rendezvous_point(const node_t *node)
  905. {
  906. tor_assert(node);
  907. if (node->rs) {
  908. return node->rs->supports_v3_rendezvous_point;
  909. }
  910. if (node->ri) {
  911. if (node->ri->protocol_list == NULL) {
  912. return 0;
  913. }
  914. return protocol_list_supports_protocol(node->ri->protocol_list,
  915. PRT_HSREND,
  916. PROTOVER_HS_RENDEZVOUS_POINT_V3);
  917. }
  918. tor_assert_nonfatal_unreached_once();
  919. return 0;
  920. }
  921. /** Return the RSA ID key's SHA1 digest for the provided node. */
  922. const uint8_t *
  923. node_get_rsa_id_digest(const node_t *node)
  924. {
  925. tor_assert(node);
  926. return (const uint8_t*)node->identity;
  927. }
  928. /** Return the nickname of <b>node</b>, or NULL if we can't find one. */
  929. const char *
  930. node_get_nickname(const node_t *node)
  931. {
  932. tor_assert(node);
  933. if (node->rs)
  934. return node->rs->nickname;
  935. else if (node->ri)
  936. return node->ri->nickname;
  937. else
  938. return NULL;
  939. }
  940. /** Return true iff <b>node</b> appears to be a directory authority or
  941. * directory cache */
  942. int
  943. node_is_dir(const node_t *node)
  944. {
  945. if (node->rs) {
  946. routerstatus_t * rs = node->rs;
  947. /* This is true if supports_tunnelled_dir_requests is true which
  948. * indicates that we support directory request tunnelled or through the
  949. * DirPort. */
  950. return rs->is_v2_dir;
  951. } else if (node->ri) {
  952. routerinfo_t * ri = node->ri;
  953. /* Both tunnelled request is supported or DirPort is set. */
  954. return ri->supports_tunnelled_dir_requests;
  955. } else {
  956. return 0;
  957. }
  958. }
  959. /** Return true iff <b>node</b> has either kind of usable descriptor -- that
  960. * is, a routerdescriptor or a microdescriptor. */
  961. int
  962. node_has_descriptor(const node_t *node)
  963. {
  964. return (node->ri ||
  965. (node->rs && node->md));
  966. }
  967. /** Return the router_purpose of <b>node</b>. */
  968. int
  969. node_get_purpose(const node_t *node)
  970. {
  971. if (node->ri)
  972. return node->ri->purpose;
  973. else
  974. return ROUTER_PURPOSE_GENERAL;
  975. }
  976. /** Compute the verbose ("extended") nickname of <b>node</b> and store it
  977. * into the MAX_VERBOSE_NICKNAME_LEN+1 character buffer at
  978. * <b>verbose_name_out</b> */
  979. void
  980. node_get_verbose_nickname(const node_t *node,
  981. char *verbose_name_out)
  982. {
  983. const char *nickname = node_get_nickname(node);
  984. verbose_name_out[0] = '$';
  985. base16_encode(verbose_name_out+1, HEX_DIGEST_LEN+1, node->identity,
  986. DIGEST_LEN);
  987. if (!nickname)
  988. return;
  989. verbose_name_out[1+HEX_DIGEST_LEN] = '~';
  990. strlcpy(verbose_name_out+1+HEX_DIGEST_LEN+1, nickname, MAX_NICKNAME_LEN+1);
  991. }
  992. /** Compute the verbose ("extended") nickname of node with
  993. * given <b>id_digest</b> and store it into the MAX_VERBOSE_NICKNAME_LEN+1
  994. * character buffer at <b>verbose_name_out</b>
  995. *
  996. * If node_get_by_id() returns NULL, base 16 encoding of
  997. * <b>id_digest</b> is returned instead. */
  998. void
  999. node_get_verbose_nickname_by_id(const char *id_digest,
  1000. char *verbose_name_out)
  1001. {
  1002. const node_t *node = node_get_by_id(id_digest);
  1003. if (!node) {
  1004. verbose_name_out[0] = '$';
  1005. base16_encode(verbose_name_out+1, HEX_DIGEST_LEN+1, id_digest, DIGEST_LEN);
  1006. } else {
  1007. node_get_verbose_nickname(node, verbose_name_out);
  1008. }
  1009. }
  1010. /** Return true iff it seems that <b>node</b> allows circuits to exit
  1011. * through it directlry from the client. */
  1012. int
  1013. node_allows_single_hop_exits(const node_t *node)
  1014. {
  1015. if (node && node->ri)
  1016. return node->ri->allow_single_hop_exits;
  1017. else
  1018. return 0;
  1019. }
  1020. /** Return true iff it seems that <b>node</b> has an exit policy that doesn't
  1021. * actually permit anything to exit, or we don't know its exit policy */
  1022. int
  1023. node_exit_policy_rejects_all(const node_t *node)
  1024. {
  1025. if (node->rejects_all)
  1026. return 1;
  1027. if (node->ri)
  1028. return node->ri->policy_is_reject_star;
  1029. else if (node->md)
  1030. return node->md->exit_policy == NULL ||
  1031. short_policy_is_reject_star(node->md->exit_policy);
  1032. else
  1033. return 1;
  1034. }
  1035. /** Return true iff the exit policy for <b>node</b> is such that we can treat
  1036. * rejecting an address of type <b>family</b> unexpectedly as a sign of that
  1037. * node's failure. */
  1038. int
  1039. node_exit_policy_is_exact(const node_t *node, sa_family_t family)
  1040. {
  1041. if (family == AF_UNSPEC) {
  1042. return 1; /* Rejecting an address but not telling us what address
  1043. * is a bad sign. */
  1044. } else if (family == AF_INET) {
  1045. return node->ri != NULL;
  1046. } else if (family == AF_INET6) {
  1047. return 0;
  1048. }
  1049. tor_fragile_assert();
  1050. return 1;
  1051. }
  1052. /* Check if the "addr" and port_field fields from r are a valid non-listening
  1053. * address/port. If so, set valid to true and add a newly allocated
  1054. * tor_addr_port_t containing "addr" and port_field to sl.
  1055. * "addr" is an IPv4 host-order address and port_field is a uint16_t.
  1056. * r is typically a routerinfo_t or routerstatus_t.
  1057. */
  1058. #define SL_ADD_NEW_IPV4_AP(r, port_field, sl, valid) \
  1059. STMT_BEGIN \
  1060. if (tor_addr_port_is_valid_ipv4h((r)->addr, (r)->port_field, 0)) { \
  1061. valid = 1; \
  1062. tor_addr_port_t *ap = tor_malloc(sizeof(tor_addr_port_t)); \
  1063. tor_addr_from_ipv4h(&ap->addr, (r)->addr); \
  1064. ap->port = (r)->port_field; \
  1065. smartlist_add((sl), ap); \
  1066. } \
  1067. STMT_END
  1068. /* Check if the "addr" and port_field fields from r are a valid non-listening
  1069. * address/port. If so, set valid to true and add a newly allocated
  1070. * tor_addr_port_t containing "addr" and port_field to sl.
  1071. * "addr" is a tor_addr_t and port_field is a uint16_t.
  1072. * r is typically a routerinfo_t or routerstatus_t.
  1073. */
  1074. #define SL_ADD_NEW_IPV6_AP(r, port_field, sl, valid) \
  1075. STMT_BEGIN \
  1076. if (tor_addr_port_is_valid(&(r)->ipv6_addr, (r)->port_field, 0)) { \
  1077. valid = 1; \
  1078. tor_addr_port_t *ap = tor_malloc(sizeof(tor_addr_port_t)); \
  1079. tor_addr_copy(&ap->addr, &(r)->ipv6_addr); \
  1080. ap->port = (r)->port_field; \
  1081. smartlist_add((sl), ap); \
  1082. } \
  1083. STMT_END
  1084. /** Return list of tor_addr_port_t with all OR ports (in the sense IP
  1085. * addr + TCP port) for <b>node</b>. Caller must free all elements
  1086. * using tor_free() and free the list using smartlist_free().
  1087. *
  1088. * XXX this is potentially a memory fragmentation hog -- if on
  1089. * critical path consider the option of having the caller allocate the
  1090. * memory
  1091. */
  1092. smartlist_t *
  1093. node_get_all_orports(const node_t *node)
  1094. {
  1095. smartlist_t *sl = smartlist_new();
  1096. int valid = 0;
  1097. /* Find a valid IPv4 address and port */
  1098. if (node->ri != NULL) {
  1099. SL_ADD_NEW_IPV4_AP(node->ri, or_port, sl, valid);
  1100. }
  1101. /* If we didn't find a valid address/port in the ri, try the rs */
  1102. if (!valid && node->rs != NULL) {
  1103. SL_ADD_NEW_IPV4_AP(node->rs, or_port, sl, valid);
  1104. }
  1105. /* Find a valid IPv6 address and port */
  1106. valid = 0;
  1107. if (node->ri != NULL) {
  1108. SL_ADD_NEW_IPV6_AP(node->ri, ipv6_orport, sl, valid);
  1109. }
  1110. if (!valid && node->rs != NULL) {
  1111. SL_ADD_NEW_IPV6_AP(node->rs, ipv6_orport, sl, valid);
  1112. }
  1113. if (!valid && node->md != NULL) {
  1114. SL_ADD_NEW_IPV6_AP(node->md, ipv6_orport, sl, valid);
  1115. }
  1116. return sl;
  1117. }
  1118. #undef SL_ADD_NEW_IPV4_AP
  1119. #undef SL_ADD_NEW_IPV6_AP
  1120. /** Wrapper around node_get_prim_orport for backward
  1121. compatibility. */
  1122. void
  1123. node_get_addr(const node_t *node, tor_addr_t *addr_out)
  1124. {
  1125. tor_addr_port_t ap;
  1126. node_get_prim_orport(node, &ap);
  1127. tor_addr_copy(addr_out, &ap.addr);
  1128. }
  1129. /** Return the host-order IPv4 address for <b>node</b>, or 0 if it doesn't
  1130. * seem to have one. */
  1131. uint32_t
  1132. node_get_prim_addr_ipv4h(const node_t *node)
  1133. {
  1134. /* Don't check the ORPort or DirPort, as this function isn't port-specific,
  1135. * and the node might have a valid IPv4 address, yet have a zero
  1136. * ORPort or DirPort.
  1137. */
  1138. if (node->ri && tor_addr_is_valid_ipv4h(node->ri->addr, 0)) {
  1139. return node->ri->addr;
  1140. } else if (node->rs && tor_addr_is_valid_ipv4h(node->rs->addr, 0)) {
  1141. return node->rs->addr;
  1142. }
  1143. return 0;
  1144. }
  1145. /** Copy a string representation of an IP address for <b>node</b> into
  1146. * the <b>len</b>-byte buffer at <b>buf</b>. */
  1147. void
  1148. node_get_address_string(const node_t *node, char *buf, size_t len)
  1149. {
  1150. uint32_t ipv4_addr = node_get_prim_addr_ipv4h(node);
  1151. if (tor_addr_is_valid_ipv4h(ipv4_addr, 0)) {
  1152. tor_addr_t addr;
  1153. tor_addr_from_ipv4h(&addr, ipv4_addr);
  1154. tor_addr_to_str(buf, &addr, len, 0);
  1155. } else if (len > 0) {
  1156. buf[0] = '\0';
  1157. }
  1158. }
  1159. /** Return <b>node</b>'s declared uptime, or -1 if it doesn't seem to have
  1160. * one. */
  1161. long
  1162. node_get_declared_uptime(const node_t *node)
  1163. {
  1164. if (node->ri)
  1165. return node->ri->uptime;
  1166. else
  1167. return -1;
  1168. }
  1169. /** Return <b>node</b>'s platform string, or NULL if we don't know it. */
  1170. const char *
  1171. node_get_platform(const node_t *node)
  1172. {
  1173. /* If we wanted, we could record the version in the routerstatus_t, since
  1174. * the consensus lists it. We don't, though, so this function just won't
  1175. * work with microdescriptors. */
  1176. if (node->ri)
  1177. return node->ri->platform;
  1178. else
  1179. return NULL;
  1180. }
  1181. /** Return true iff <b>node</b> is one representing this router. */
  1182. int
  1183. node_is_me(const node_t *node)
  1184. {
  1185. return router_digest_is_me(node->identity);
  1186. }
  1187. /** Return <b>node</b> declared family (as a list of names), or NULL if
  1188. * the node didn't declare a family. */
  1189. const smartlist_t *
  1190. node_get_declared_family(const node_t *node)
  1191. {
  1192. if (node->ri && node->ri->declared_family)
  1193. return node->ri->declared_family;
  1194. else if (node->md && node->md->family)
  1195. return node->md->family;
  1196. else
  1197. return NULL;
  1198. }
  1199. /* Does this node have a valid IPv6 address?
  1200. * Prefer node_has_ipv6_orport() or node_has_ipv6_dirport() for
  1201. * checking specific ports. */
  1202. int
  1203. node_has_ipv6_addr(const node_t *node)
  1204. {
  1205. /* Don't check the ORPort or DirPort, as this function isn't port-specific,
  1206. * and the node might have a valid IPv6 address, yet have a zero
  1207. * ORPort or DirPort.
  1208. */
  1209. if (node->ri && tor_addr_is_valid(&node->ri->ipv6_addr, 0))
  1210. return 1;
  1211. if (node->rs && tor_addr_is_valid(&node->rs->ipv6_addr, 0))
  1212. return 1;
  1213. if (node->md && tor_addr_is_valid(&node->md->ipv6_addr, 0))
  1214. return 1;
  1215. return 0;
  1216. }
  1217. /* Does this node have a valid IPv6 ORPort? */
  1218. int
  1219. node_has_ipv6_orport(const node_t *node)
  1220. {
  1221. tor_addr_port_t ipv6_orport;
  1222. node_get_pref_ipv6_orport(node, &ipv6_orport);
  1223. return tor_addr_port_is_valid_ap(&ipv6_orport, 0);
  1224. }
  1225. /* Does this node have a valid IPv6 DirPort? */
  1226. int
  1227. node_has_ipv6_dirport(const node_t *node)
  1228. {
  1229. tor_addr_port_t ipv6_dirport;
  1230. node_get_pref_ipv6_dirport(node, &ipv6_dirport);
  1231. return tor_addr_port_is_valid_ap(&ipv6_dirport, 0);
  1232. }
  1233. /** Return 1 if we prefer the IPv6 address and OR TCP port of
  1234. * <b>node</b>, else 0.
  1235. *
  1236. * We prefer the IPv6 address if the router has an IPv6 address,
  1237. * and we can use IPv6 addresses, and:
  1238. * i) the node_t says that it prefers IPv6
  1239. * or
  1240. * ii) the router has no IPv4 OR address.
  1241. *
  1242. * If you don't have a node, consider looking it up.
  1243. * If there is no node, use fascist_firewall_prefer_ipv6_orport().
  1244. */
  1245. int
  1246. node_ipv6_or_preferred(const node_t *node)
  1247. {
  1248. const or_options_t *options = get_options();
  1249. tor_addr_port_t ipv4_addr;
  1250. node_assert_ok(node);
  1251. /* XX/teor - node->ipv6_preferred is set from
  1252. * fascist_firewall_prefer_ipv6_orport() each time the consensus is loaded.
  1253. */
  1254. if (!fascist_firewall_use_ipv6(options)) {
  1255. return 0;
  1256. } else if (node->ipv6_preferred || node_get_prim_orport(node, &ipv4_addr)) {
  1257. return node_has_ipv6_orport(node);
  1258. }
  1259. return 0;
  1260. }
  1261. #define RETURN_IPV4_AP(r, port_field, ap_out) \
  1262. STMT_BEGIN \
  1263. if (r && tor_addr_port_is_valid_ipv4h((r)->addr, (r)->port_field, 0)) { \
  1264. tor_addr_from_ipv4h(&(ap_out)->addr, (r)->addr); \
  1265. (ap_out)->port = (r)->port_field; \
  1266. return 0; \
  1267. } \
  1268. STMT_END
  1269. /** Copy the primary (IPv4) OR port (IP address and TCP port) for
  1270. * <b>node</b> into *<b>ap_out</b>. Return 0 if a valid address and
  1271. * port was copied, else return non-zero.*/
  1272. int
  1273. node_get_prim_orport(const node_t *node, tor_addr_port_t *ap_out)
  1274. {
  1275. node_assert_ok(node);
  1276. tor_assert(ap_out);
  1277. /* Clear the address, as a safety precaution if calling functions ignore the
  1278. * return value */
  1279. tor_addr_make_null(&ap_out->addr, AF_INET);
  1280. ap_out->port = 0;
  1281. /* Check ri first, because rewrite_node_address_for_bridge() updates
  1282. * node->ri with the configured bridge address. */
  1283. RETURN_IPV4_AP(node->ri, or_port, ap_out);
  1284. RETURN_IPV4_AP(node->rs, or_port, ap_out);
  1285. /* Microdescriptors only have an IPv6 address */
  1286. return -1;
  1287. }
  1288. /** Copy the preferred OR port (IP address and TCP port) for
  1289. * <b>node</b> into *<b>ap_out</b>. */
  1290. void
  1291. node_get_pref_orport(const node_t *node, tor_addr_port_t *ap_out)
  1292. {
  1293. tor_assert(ap_out);
  1294. if (node_ipv6_or_preferred(node)) {
  1295. node_get_pref_ipv6_orport(node, ap_out);
  1296. } else {
  1297. /* the primary ORPort is always on IPv4 */
  1298. node_get_prim_orport(node, ap_out);
  1299. }
  1300. }
  1301. /** Copy the preferred IPv6 OR port (IP address and TCP port) for
  1302. * <b>node</b> into *<b>ap_out</b>. */
  1303. void
  1304. node_get_pref_ipv6_orport(const node_t *node, tor_addr_port_t *ap_out)
  1305. {
  1306. node_assert_ok(node);
  1307. tor_assert(ap_out);
  1308. /* Check ri first, because rewrite_node_address_for_bridge() updates
  1309. * node->ri with the configured bridge address.
  1310. * Prefer rs over md for consistency with the fascist_firewall_* functions.
  1311. * Check if the address or port are valid, and try another alternative
  1312. * if they are not. */
  1313. if (node->ri && tor_addr_port_is_valid(&node->ri->ipv6_addr,
  1314. node->ri->ipv6_orport, 0)) {
  1315. tor_addr_copy(&ap_out->addr, &node->ri->ipv6_addr);
  1316. ap_out->port = node->ri->ipv6_orport;
  1317. } else if (node->rs && tor_addr_port_is_valid(&node->rs->ipv6_addr,
  1318. node->rs->ipv6_orport, 0)) {
  1319. tor_addr_copy(&ap_out->addr, &node->rs->ipv6_addr);
  1320. ap_out->port = node->rs->ipv6_orport;
  1321. } else if (node->md && tor_addr_port_is_valid(&node->md->ipv6_addr,
  1322. node->md->ipv6_orport, 0)) {
  1323. tor_addr_copy(&ap_out->addr, &node->md->ipv6_addr);
  1324. ap_out->port = node->md->ipv6_orport;
  1325. } else {
  1326. tor_addr_make_null(&ap_out->addr, AF_INET6);
  1327. ap_out->port = 0;
  1328. }
  1329. }
  1330. /** Return 1 if we prefer the IPv6 address and Dir TCP port of
  1331. * <b>node</b>, else 0.
  1332. *
  1333. * We prefer the IPv6 address if the router has an IPv6 address,
  1334. * and we can use IPv6 addresses, and:
  1335. * i) the router has no IPv4 Dir address.
  1336. * or
  1337. * ii) our preference is for IPv6 Dir addresses.
  1338. *
  1339. * If there is no node, use fascist_firewall_prefer_ipv6_dirport().
  1340. */
  1341. int
  1342. node_ipv6_dir_preferred(const node_t *node)
  1343. {
  1344. const or_options_t *options = get_options();
  1345. tor_addr_port_t ipv4_addr;
  1346. node_assert_ok(node);
  1347. /* node->ipv6_preferred is set from fascist_firewall_prefer_ipv6_orport(),
  1348. * so we can't use it to determine DirPort IPv6 preference.
  1349. * This means that bridge clients will use IPv4 DirPorts by default.
  1350. */
  1351. if (!fascist_firewall_use_ipv6(options)) {
  1352. return 0;
  1353. } else if (node_get_prim_dirport(node, &ipv4_addr)
  1354. || fascist_firewall_prefer_ipv6_dirport(get_options())) {
  1355. return node_has_ipv6_dirport(node);
  1356. }
  1357. return 0;
  1358. }
  1359. /** Copy the primary (IPv4) Dir port (IP address and TCP port) for
  1360. * <b>node</b> into *<b>ap_out</b>. Return 0 if a valid address and
  1361. * port was copied, else return non-zero.*/
  1362. int
  1363. node_get_prim_dirport(const node_t *node, tor_addr_port_t *ap_out)
  1364. {
  1365. node_assert_ok(node);
  1366. tor_assert(ap_out);
  1367. /* Check ri first, because rewrite_node_address_for_bridge() updates
  1368. * node->ri with the configured bridge address. */
  1369. RETURN_IPV4_AP(node->ri, dir_port, ap_out);
  1370. RETURN_IPV4_AP(node->rs, dir_port, ap_out);
  1371. /* Microdescriptors only have an IPv6 address */
  1372. return -1;
  1373. }
  1374. #undef RETURN_IPV4_AP
  1375. /** Copy the preferred Dir port (IP address and TCP port) for
  1376. * <b>node</b> into *<b>ap_out</b>. */
  1377. void
  1378. node_get_pref_dirport(const node_t *node, tor_addr_port_t *ap_out)
  1379. {
  1380. tor_assert(ap_out);
  1381. if (node_ipv6_dir_preferred(node)) {
  1382. node_get_pref_ipv6_dirport(node, ap_out);
  1383. } else {
  1384. /* the primary DirPort is always on IPv4 */
  1385. node_get_prim_dirport(node, ap_out);
  1386. }
  1387. }
  1388. /** Copy the preferred IPv6 Dir port (IP address and TCP port) for
  1389. * <b>node</b> into *<b>ap_out</b>. */
  1390. void
  1391. node_get_pref_ipv6_dirport(const node_t *node, tor_addr_port_t *ap_out)
  1392. {
  1393. node_assert_ok(node);
  1394. tor_assert(ap_out);
  1395. /* Check ri first, because rewrite_node_address_for_bridge() updates
  1396. * node->ri with the configured bridge address.
  1397. * Prefer rs over md for consistency with the fascist_firewall_* functions.
  1398. * Check if the address or port are valid, and try another alternative
  1399. * if they are not. */
  1400. /* Assume IPv4 and IPv6 dirports are the same */
  1401. if (node->ri && tor_addr_port_is_valid(&node->ri->ipv6_addr,
  1402. node->ri->dir_port, 0)) {
  1403. tor_addr_copy(&ap_out->addr, &node->ri->ipv6_addr);
  1404. ap_out->port = node->ri->dir_port;
  1405. } else if (node->rs && tor_addr_port_is_valid(&node->rs->ipv6_addr,
  1406. node->rs->dir_port, 0)) {
  1407. tor_addr_copy(&ap_out->addr, &node->rs->ipv6_addr);
  1408. ap_out->port = node->rs->dir_port;
  1409. } else {
  1410. tor_addr_make_null(&ap_out->addr, AF_INET6);
  1411. ap_out->port = 0;
  1412. }
  1413. }
  1414. /** Return true iff <b>md</b> has a curve25519 onion key.
  1415. * Use node_has_curve25519_onion_key() instead of calling this directly. */
  1416. static int
  1417. microdesc_has_curve25519_onion_key(const microdesc_t *md)
  1418. {
  1419. if (!md) {
  1420. return 0;
  1421. }
  1422. if (!md->onion_curve25519_pkey) {
  1423. return 0;
  1424. }
  1425. if (tor_mem_is_zero((const char*)md->onion_curve25519_pkey->public_key,
  1426. CURVE25519_PUBKEY_LEN)) {
  1427. return 0;
  1428. }
  1429. return 1;
  1430. }
  1431. /** Return true iff <b>node</b> has a curve25519 onion key. */
  1432. int
  1433. node_has_curve25519_onion_key(const node_t *node)
  1434. {
  1435. if (!node)
  1436. return 0;
  1437. if (node->ri)
  1438. return routerinfo_has_curve25519_onion_key(node->ri);
  1439. else if (node->md)
  1440. return microdesc_has_curve25519_onion_key(node->md);
  1441. else
  1442. return 0;
  1443. }
  1444. /** Return the curve25519 key of <b>node</b>, or NULL if none. */
  1445. const curve25519_public_key_t *
  1446. node_get_curve25519_onion_key(const node_t *node)
  1447. {
  1448. if (node->ri)
  1449. return node->ri->onion_curve25519_pkey;
  1450. else if (node->md)
  1451. return node->md->onion_curve25519_pkey;
  1452. else
  1453. return NULL;
  1454. }
  1455. /** Refresh the country code of <b>ri</b>. This function MUST be called on
  1456. * each router when the GeoIP database is reloaded, and on all new routers. */
  1457. void
  1458. node_set_country(node_t *node)
  1459. {
  1460. tor_addr_t addr = TOR_ADDR_NULL;
  1461. /* XXXXipv6 */
  1462. if (node->rs)
  1463. tor_addr_from_ipv4h(&addr, node->rs->addr);
  1464. else if (node->ri)
  1465. tor_addr_from_ipv4h(&addr, node->ri->addr);
  1466. node->country = geoip_get_country_by_addr(&addr);
  1467. }
  1468. /** Set the country code of all routers in the routerlist. */
  1469. void
  1470. nodelist_refresh_countries(void)
  1471. {
  1472. smartlist_t *nodes = nodelist_get_list();
  1473. SMARTLIST_FOREACH(nodes, node_t *, node,
  1474. node_set_country(node));
  1475. }
  1476. /** Return true iff router1 and router2 have similar enough network addresses
  1477. * that we should treat them as being in the same family */
  1478. int
  1479. addrs_in_same_network_family(const tor_addr_t *a1,
  1480. const tor_addr_t *a2)
  1481. {
  1482. return 0 == tor_addr_compare_masked(a1, a2, 16, CMP_SEMANTIC);
  1483. }
  1484. /** Return true if <b>node</b>'s nickname matches <b>nickname</b>
  1485. * (case-insensitive), or if <b>node's</b> identity key digest
  1486. * matches a hexadecimal value stored in <b>nickname</b>. Return
  1487. * false otherwise. */
  1488. static int
  1489. node_nickname_matches(const node_t *node, const char *nickname)
  1490. {
  1491. const char *n = node_get_nickname(node);
  1492. if (n && nickname[0]!='$' && !strcasecmp(n, nickname))
  1493. return 1;
  1494. return hex_digest_nickname_matches(nickname,
  1495. node->identity,
  1496. n);
  1497. }
  1498. /** Return true iff <b>node</b> is named by some nickname in <b>lst</b>. */
  1499. static inline int
  1500. node_in_nickname_smartlist(const smartlist_t *lst, const node_t *node)
  1501. {
  1502. if (!lst) return 0;
  1503. SMARTLIST_FOREACH(lst, const char *, name, {
  1504. if (node_nickname_matches(node, name))
  1505. return 1;
  1506. });
  1507. return 0;
  1508. }
  1509. /** Return true iff r1 and r2 are in the same family, but not the same
  1510. * router. */
  1511. int
  1512. nodes_in_same_family(const node_t *node1, const node_t *node2)
  1513. {
  1514. const or_options_t *options = get_options();
  1515. /* Are they in the same family because of their addresses? */
  1516. if (options->EnforceDistinctSubnets) {
  1517. tor_addr_t a1, a2;
  1518. node_get_addr(node1, &a1);
  1519. node_get_addr(node2, &a2);
  1520. if (addrs_in_same_network_family(&a1, &a2))
  1521. return 1;
  1522. }
  1523. /* Are they in the same family because the agree they are? */
  1524. {
  1525. const smartlist_t *f1, *f2;
  1526. f1 = node_get_declared_family(node1);
  1527. f2 = node_get_declared_family(node2);
  1528. if (f1 && f2 &&
  1529. node_in_nickname_smartlist(f1, node2) &&
  1530. node_in_nickname_smartlist(f2, node1))
  1531. return 1;
  1532. }
  1533. /* Are they in the same option because the user says they are? */
  1534. if (options->NodeFamilySets) {
  1535. SMARTLIST_FOREACH(options->NodeFamilySets, const routerset_t *, rs, {
  1536. if (routerset_contains_node(rs, node1) &&
  1537. routerset_contains_node(rs, node2))
  1538. return 1;
  1539. });
  1540. }
  1541. return 0;
  1542. }
  1543. /**
  1544. * Add all the family of <b>node</b>, including <b>node</b> itself, to
  1545. * the smartlist <b>sl</b>.
  1546. *
  1547. * This is used to make sure we don't pick siblings in a single path, or
  1548. * pick more than one relay from a family for our entry guard list.
  1549. * Note that a node may be added to <b>sl</b> more than once if it is
  1550. * part of <b>node</b>'s family for more than one reason.
  1551. */
  1552. void
  1553. nodelist_add_node_and_family(smartlist_t *sl, const node_t *node)
  1554. {
  1555. const smartlist_t *all_nodes = nodelist_get_list();
  1556. const smartlist_t *declared_family;
  1557. const or_options_t *options = get_options();
  1558. tor_assert(node);
  1559. declared_family = node_get_declared_family(node);
  1560. /* Let's make sure that we have the node itself, if it's a real node. */
  1561. {
  1562. const node_t *real_node = node_get_by_id(node->identity);
  1563. if (real_node)
  1564. smartlist_add(sl, (node_t*)real_node);
  1565. }
  1566. /* First, add any nodes with similar network addresses. */
  1567. if (options->EnforceDistinctSubnets) {
  1568. tor_addr_t node_addr;
  1569. node_get_addr(node, &node_addr);
  1570. SMARTLIST_FOREACH_BEGIN(all_nodes, const node_t *, node2) {
  1571. tor_addr_t a;
  1572. node_get_addr(node2, &a);
  1573. if (addrs_in_same_network_family(&a, &node_addr))
  1574. smartlist_add(sl, (void*)node2);
  1575. } SMARTLIST_FOREACH_END(node2);
  1576. }
  1577. /* Now, add all nodes in the declared_family of this node, if they
  1578. * also declare this node to be in their family. */
  1579. if (declared_family) {
  1580. /* Add every r such that router declares familyness with node, and node
  1581. * declares familyhood with router. */
  1582. SMARTLIST_FOREACH_BEGIN(declared_family, const char *, name) {
  1583. const node_t *node2;
  1584. const smartlist_t *family2;
  1585. if (!(node2 = node_get_by_nickname(name, NNF_NO_WARN_UNNAMED)))
  1586. continue;
  1587. if (!(family2 = node_get_declared_family(node2)))
  1588. continue;
  1589. SMARTLIST_FOREACH_BEGIN(family2, const char *, name2) {
  1590. if (node_nickname_matches(node, name2)) {
  1591. smartlist_add(sl, (void*)node2);
  1592. break;
  1593. }
  1594. } SMARTLIST_FOREACH_END(name2);
  1595. } SMARTLIST_FOREACH_END(name);
  1596. }
  1597. /* If the user declared any families locally, honor those too. */
  1598. if (options->NodeFamilySets) {
  1599. SMARTLIST_FOREACH(options->NodeFamilySets, const routerset_t *, rs, {
  1600. if (routerset_contains_node(rs, node)) {
  1601. routerset_get_all_nodes(sl, rs, NULL, 0);
  1602. }
  1603. });
  1604. }
  1605. }
  1606. /** Find a router that's up, that has this IP address, and
  1607. * that allows exit to this address:port, or return NULL if there
  1608. * isn't a good one.
  1609. * Don't exit enclave to excluded relays -- it wouldn't actually
  1610. * hurt anything, but this way there are fewer confused users.
  1611. */
  1612. const node_t *
  1613. router_find_exact_exit_enclave(const char *address, uint16_t port)
  1614. {/*XXXX MOVE*/
  1615. uint32_t addr;
  1616. struct in_addr in;
  1617. tor_addr_t a;
  1618. const or_options_t *options = get_options();
  1619. if (!tor_inet_aton(address, &in))
  1620. return NULL; /* it's not an IP already */
  1621. addr = ntohl(in.s_addr);
  1622. tor_addr_from_ipv4h(&a, addr);
  1623. SMARTLIST_FOREACH(nodelist_get_list(), const node_t *, node, {
  1624. if (node_get_addr_ipv4h(node) == addr &&
  1625. node->is_running &&
  1626. compare_tor_addr_to_node_policy(&a, port, node) ==
  1627. ADDR_POLICY_ACCEPTED &&
  1628. !routerset_contains_node(options->ExcludeExitNodesUnion_, node))
  1629. return node;
  1630. });
  1631. return NULL;
  1632. }
  1633. /** Return 1 if <b>router</b> is not suitable for these parameters, else 0.
  1634. * If <b>need_uptime</b> is non-zero, we require a minimum uptime.
  1635. * If <b>need_capacity</b> is non-zero, we require a minimum advertised
  1636. * bandwidth.
  1637. * If <b>need_guard</b>, we require that the router is a possible entry guard.
  1638. */
  1639. int
  1640. node_is_unreliable(const node_t *node, int need_uptime,
  1641. int need_capacity, int need_guard)
  1642. {
  1643. if (need_uptime && !node->is_stable)
  1644. return 1;
  1645. if (need_capacity && !node->is_fast)
  1646. return 1;
  1647. if (need_guard && !node->is_possible_guard)
  1648. return 1;
  1649. return 0;
  1650. }
  1651. /** Return 1 if all running sufficiently-stable routers we can use will reject
  1652. * addr:port. Return 0 if any might accept it. */
  1653. int
  1654. router_exit_policy_all_nodes_reject(const tor_addr_t *addr, uint16_t port,
  1655. int need_uptime)
  1656. {
  1657. addr_policy_result_t r;
  1658. SMARTLIST_FOREACH_BEGIN(nodelist_get_list(), const node_t *, node) {
  1659. if (node->is_running &&
  1660. !node_is_unreliable(node, need_uptime, 0, 0)) {
  1661. r = compare_tor_addr_to_node_policy(addr, port, node);
  1662. if (r != ADDR_POLICY_REJECTED && r != ADDR_POLICY_PROBABLY_REJECTED)
  1663. return 0; /* this one could be ok. good enough. */
  1664. }
  1665. } SMARTLIST_FOREACH_END(node);
  1666. return 1; /* all will reject. */
  1667. }
  1668. /** Mark the router with ID <b>digest</b> as running or non-running
  1669. * in our routerlist. */
  1670. void
  1671. router_set_status(const char *digest, int up)
  1672. {
  1673. node_t *node;
  1674. tor_assert(digest);
  1675. SMARTLIST_FOREACH(router_get_fallback_dir_servers(),
  1676. dir_server_t *, d,
  1677. if (tor_memeq(d->digest, digest, DIGEST_LEN))
  1678. d->is_running = up);
  1679. SMARTLIST_FOREACH(router_get_trusted_dir_servers(),
  1680. dir_server_t *, d,
  1681. if (tor_memeq(d->digest, digest, DIGEST_LEN))
  1682. d->is_running = up);
  1683. node = node_get_mutable_by_id(digest);
  1684. if (node) {
  1685. #if 0
  1686. log_debug(LD_DIR,"Marking router %s as %s.",
  1687. node_describe(node), up ? "up" : "down");
  1688. #endif
  1689. if (!up && node_is_me(node) && !net_is_disabled())
  1690. log_warn(LD_NET, "We just marked ourself as down. Are your external "
  1691. "addresses reachable?");
  1692. if (bool_neq(node->is_running, up))
  1693. router_dir_info_changed();
  1694. node->is_running = up;
  1695. }
  1696. }
  1697. /** True iff, the last time we checked whether we had enough directory info
  1698. * to build circuits, the answer was "yes". If there are no exits in the
  1699. * consensus, we act as if we have 100% of the exit directory info. */
  1700. static int have_min_dir_info = 0;
  1701. /** Does the consensus contain nodes that can exit? */
  1702. static consensus_path_type_t have_consensus_path = CONSENSUS_PATH_UNKNOWN;
  1703. /** True iff enough has changed since the last time we checked whether we had
  1704. * enough directory info to build circuits that our old answer can no longer
  1705. * be trusted. */
  1706. static int need_to_update_have_min_dir_info = 1;
  1707. /** String describing what we're missing before we have enough directory
  1708. * info. */
  1709. static char dir_info_status[512] = "";
  1710. /** Return true iff we have enough consensus information to
  1711. * start building circuits. Right now, this means "a consensus that's
  1712. * less than a day old, and at least 60% of router descriptors (configurable),
  1713. * weighted by bandwidth. Treat the exit fraction as 100% if there are
  1714. * no exits in the consensus."
  1715. * To obtain the final weighted bandwidth, we multiply the
  1716. * weighted bandwidth fraction for each position (guard, middle, exit). */
  1717. MOCK_IMPL(int,
  1718. router_have_minimum_dir_info,(void))
  1719. {
  1720. static int logged_delay=0;
  1721. const char *delay_fetches_msg = NULL;
  1722. if (should_delay_dir_fetches(get_options(), &delay_fetches_msg)) {
  1723. if (!logged_delay)
  1724. log_notice(LD_DIR, "Delaying directory fetches: %s", delay_fetches_msg);
  1725. logged_delay=1;
  1726. strlcpy(dir_info_status, delay_fetches_msg, sizeof(dir_info_status));
  1727. return 0;
  1728. }
  1729. logged_delay = 0; /* reset it if we get this far */
  1730. if (PREDICT_UNLIKELY(need_to_update_have_min_dir_info)) {
  1731. update_router_have_minimum_dir_info();
  1732. }
  1733. return have_min_dir_info;
  1734. }
  1735. /** Set to CONSENSUS_PATH_EXIT if there is at least one exit node
  1736. * in the consensus. We update this flag in compute_frac_paths_available if
  1737. * there is at least one relay that has an Exit flag in the consensus.
  1738. * Used to avoid building exit circuits when they will almost certainly fail.
  1739. * Set to CONSENSUS_PATH_INTERNAL if there are no exits in the consensus.
  1740. * (This situation typically occurs during bootstrap of a test network.)
  1741. * Set to CONSENSUS_PATH_UNKNOWN if we have never checked, or have
  1742. * reason to believe our last known value was invalid or has expired.
  1743. * If we're in a network with TestingDirAuthVoteExit set,
  1744. * this can cause router_have_consensus_path() to be set to
  1745. * CONSENSUS_PATH_EXIT, even if there are no nodes with accept exit policies.
  1746. */
  1747. MOCK_IMPL(consensus_path_type_t,
  1748. router_have_consensus_path, (void))
  1749. {
  1750. return have_consensus_path;
  1751. }
  1752. /** Called when our internal view of the directory has changed. This can be
  1753. * when the authorities change, networkstatuses change, the list of routerdescs
  1754. * changes, or number of running routers changes.
  1755. */
  1756. void
  1757. router_dir_info_changed(void)
  1758. {
  1759. need_to_update_have_min_dir_info = 1;
  1760. rend_hsdir_routers_changed();
  1761. hs_service_dir_info_changed();
  1762. hs_client_dir_info_changed();
  1763. }
  1764. /** Return a string describing what we're missing before we have enough
  1765. * directory info. */
  1766. const char *
  1767. get_dir_info_status_string(void)
  1768. {
  1769. return dir_info_status;
  1770. }
  1771. /** Iterate over the servers listed in <b>consensus</b>, and count how many of
  1772. * them seem like ones we'd use (store this in *<b>num_usable</b>), and how
  1773. * many of <em>those</em> we have descriptors for (store this in
  1774. * *<b>num_present</b>).
  1775. *
  1776. * If <b>in_set</b> is non-NULL, only consider those routers in <b>in_set</b>.
  1777. * If <b>exit_only</b> is USABLE_DESCRIPTOR_EXIT_ONLY, only consider nodes
  1778. * with the Exit flag.
  1779. * If *<b>descs_out</b> is present, add a node_t for each usable descriptor
  1780. * to it.
  1781. */
  1782. static void
  1783. count_usable_descriptors(int *num_present, int *num_usable,
  1784. smartlist_t *descs_out,
  1785. const networkstatus_t *consensus,
  1786. time_t now,
  1787. routerset_t *in_set,
  1788. usable_descriptor_t exit_only)
  1789. {
  1790. const int md = (consensus->flavor == FLAV_MICRODESC);
  1791. *num_present = 0, *num_usable = 0;
  1792. SMARTLIST_FOREACH_BEGIN(consensus->routerstatus_list, routerstatus_t *, rs)
  1793. {
  1794. const node_t *node = node_get_by_id(rs->identity_digest);
  1795. if (!node)
  1796. continue; /* This would be a bug: every entry in the consensus is
  1797. * supposed to have a node. */
  1798. if (exit_only == USABLE_DESCRIPTOR_EXIT_ONLY && ! rs->is_exit)
  1799. continue;
  1800. if (in_set && ! routerset_contains_routerstatus(in_set, rs, -1))
  1801. continue;
  1802. if (client_would_use_router(rs, now)) {
  1803. const char * const digest = rs->descriptor_digest;
  1804. int present;
  1805. ++*num_usable; /* the consensus says we want it. */
  1806. if (md)
  1807. present = NULL != microdesc_cache_lookup_by_digest256(NULL, digest);
  1808. else
  1809. present = NULL != router_get_by_descriptor_digest(digest);
  1810. if (present) {
  1811. /* we have the descriptor listed in the consensus. */
  1812. ++*num_present;
  1813. }
  1814. if (descs_out)
  1815. smartlist_add(descs_out, (node_t*)node);
  1816. }
  1817. }
  1818. SMARTLIST_FOREACH_END(rs);
  1819. log_debug(LD_DIR, "%d usable, %d present (%s%s).",
  1820. *num_usable, *num_present,
  1821. md ? "microdesc" : "desc",
  1822. exit_only == USABLE_DESCRIPTOR_EXIT_ONLY ? " exits" : "s");
  1823. }
  1824. /** Return an estimate of which fraction of usable paths through the Tor
  1825. * network we have available for use. Count how many routers seem like ones
  1826. * we'd use (store this in *<b>num_usable_out</b>), and how many of
  1827. * <em>those</em> we have descriptors for (store this in
  1828. * *<b>num_present_out</b>.)
  1829. *
  1830. * If **<b>status_out</b> is present, allocate a new string and print the
  1831. * available percentages of guard, middle, and exit nodes to it, noting
  1832. * whether there are exits in the consensus.
  1833. * If there are no exits in the consensus, we treat the exit fraction as 100%,
  1834. * but set router_have_consensus_path() so that we can only build internal
  1835. * paths. */
  1836. static double
  1837. compute_frac_paths_available(const networkstatus_t *consensus,
  1838. const or_options_t *options, time_t now,
  1839. int *num_present_out, int *num_usable_out,
  1840. char **status_out)
  1841. {
  1842. smartlist_t *guards = smartlist_new();
  1843. smartlist_t *mid = smartlist_new();
  1844. smartlist_t *exits = smartlist_new();
  1845. double f_guard, f_mid, f_exit;
  1846. double f_path = 0.0;
  1847. /* Used to determine whether there are any exits in the consensus */
  1848. int np = 0;
  1849. /* Used to determine whether there are any exits with descriptors */
  1850. int nu = 0;
  1851. const int authdir = authdir_mode_v3(options);
  1852. count_usable_descriptors(num_present_out, num_usable_out,
  1853. mid, consensus, now, NULL,
  1854. USABLE_DESCRIPTOR_ALL);
  1855. if (options->EntryNodes) {
  1856. count_usable_descriptors(&np, &nu, guards, consensus, now,
  1857. options->EntryNodes, USABLE_DESCRIPTOR_ALL);
  1858. } else {
  1859. SMARTLIST_FOREACH(mid, const node_t *, node, {
  1860. if (authdir) {
  1861. if (node->rs && node->rs->is_possible_guard)
  1862. smartlist_add(guards, (node_t*)node);
  1863. } else {
  1864. if (node->is_possible_guard)
  1865. smartlist_add(guards, (node_t*)node);
  1866. }
  1867. });
  1868. }
  1869. /* All nodes with exit flag
  1870. * If we're in a network with TestingDirAuthVoteExit set,
  1871. * this can cause false positives on have_consensus_path,
  1872. * incorrectly setting it to CONSENSUS_PATH_EXIT. This is
  1873. * an unavoidable feature of forcing authorities to declare
  1874. * certain nodes as exits.
  1875. */
  1876. count_usable_descriptors(&np, &nu, exits, consensus, now,
  1877. NULL, USABLE_DESCRIPTOR_EXIT_ONLY);
  1878. log_debug(LD_NET,
  1879. "%s: %d present, %d usable",
  1880. "exits",
  1881. np,
  1882. nu);
  1883. /* We need at least 1 exit present in the consensus to consider
  1884. * building exit paths */
  1885. /* Update our understanding of whether the consensus has exits */
  1886. consensus_path_type_t old_have_consensus_path = have_consensus_path;
  1887. have_consensus_path = ((nu > 0) ?
  1888. CONSENSUS_PATH_EXIT :
  1889. CONSENSUS_PATH_INTERNAL);
  1890. if (have_consensus_path == CONSENSUS_PATH_INTERNAL
  1891. && old_have_consensus_path != have_consensus_path) {
  1892. log_notice(LD_NET,
  1893. "The current consensus has no exit nodes. "
  1894. "Tor can only build internal paths, "
  1895. "such as paths to hidden services.");
  1896. /* However, exit nodes can reachability self-test using this consensus,
  1897. * join the network, and appear in a later consensus. This will allow
  1898. * the network to build exit paths, such as paths for world wide web
  1899. * browsing (as distinct from hidden service web browsing). */
  1900. }
  1901. f_guard = frac_nodes_with_descriptors(guards, WEIGHT_FOR_GUARD);
  1902. f_mid = frac_nodes_with_descriptors(mid, WEIGHT_FOR_MID);
  1903. f_exit = frac_nodes_with_descriptors(exits, WEIGHT_FOR_EXIT);
  1904. log_debug(LD_NET,
  1905. "f_guard: %.2f, f_mid: %.2f, f_exit: %.2f",
  1906. f_guard,
  1907. f_mid,
  1908. f_exit);
  1909. smartlist_free(guards);
  1910. smartlist_free(mid);
  1911. smartlist_free(exits);
  1912. if (options->ExitNodes) {
  1913. double f_myexit, f_myexit_unflagged;
  1914. smartlist_t *myexits= smartlist_new();
  1915. smartlist_t *myexits_unflagged = smartlist_new();
  1916. /* All nodes with exit flag in ExitNodes option */
  1917. count_usable_descriptors(&np, &nu, myexits, consensus, now,
  1918. options->ExitNodes, USABLE_DESCRIPTOR_EXIT_ONLY);
  1919. log_debug(LD_NET,
  1920. "%s: %d present, %d usable",
  1921. "myexits",
  1922. np,
  1923. nu);
  1924. /* Now compute the nodes in the ExitNodes option where which we don't know
  1925. * what their exit policy is, or we know it permits something. */
  1926. count_usable_descriptors(&np, &nu, myexits_unflagged,
  1927. consensus, now,
  1928. options->ExitNodes, USABLE_DESCRIPTOR_ALL);
  1929. log_debug(LD_NET,
  1930. "%s: %d present, %d usable",
  1931. "myexits_unflagged (initial)",
  1932. np,
  1933. nu);
  1934. SMARTLIST_FOREACH_BEGIN(myexits_unflagged, const node_t *, node) {
  1935. if (node_has_descriptor(node) && node_exit_policy_rejects_all(node)) {
  1936. SMARTLIST_DEL_CURRENT(myexits_unflagged, node);
  1937. /* this node is not actually an exit */
  1938. np--;
  1939. /* this node is unusable as an exit */
  1940. nu--;
  1941. }
  1942. } SMARTLIST_FOREACH_END(node);
  1943. log_debug(LD_NET,
  1944. "%s: %d present, %d usable",
  1945. "myexits_unflagged (final)",
  1946. np,
  1947. nu);
  1948. f_myexit= frac_nodes_with_descriptors(myexits,WEIGHT_FOR_EXIT);
  1949. f_myexit_unflagged=
  1950. frac_nodes_with_descriptors(myexits_unflagged,WEIGHT_FOR_EXIT);
  1951. log_debug(LD_NET,
  1952. "f_exit: %.2f, f_myexit: %.2f, f_myexit_unflagged: %.2f",
  1953. f_exit,
  1954. f_myexit,
  1955. f_myexit_unflagged);
  1956. /* If our ExitNodes list has eliminated every possible Exit node, and there
  1957. * were some possible Exit nodes, then instead consider nodes that permit
  1958. * exiting to some ports. */
  1959. if (smartlist_len(myexits) == 0 &&
  1960. smartlist_len(myexits_unflagged)) {
  1961. f_myexit = f_myexit_unflagged;
  1962. }
  1963. smartlist_free(myexits);
  1964. smartlist_free(myexits_unflagged);
  1965. /* This is a tricky point here: we don't want to make it easy for a
  1966. * directory to trickle exits to us until it learns which exits we have
  1967. * configured, so require that we have a threshold both of total exits
  1968. * and usable exits. */
  1969. if (f_myexit < f_exit)
  1970. f_exit = f_myexit;
  1971. }
  1972. /* if the consensus has no exits, treat the exit fraction as 100% */
  1973. if (router_have_consensus_path() != CONSENSUS_PATH_EXIT) {
  1974. f_exit = 1.0;
  1975. }
  1976. f_path = f_guard * f_mid * f_exit;
  1977. if (status_out)
  1978. tor_asprintf(status_out,
  1979. "%d%% of guards bw, "
  1980. "%d%% of midpoint bw, and "
  1981. "%d%% of exit bw%s = "
  1982. "%d%% of path bw",
  1983. (int)(f_guard*100),
  1984. (int)(f_mid*100),
  1985. (int)(f_exit*100),
  1986. (router_have_consensus_path() == CONSENSUS_PATH_EXIT ?
  1987. "" :
  1988. " (no exits in consensus)"),
  1989. (int)(f_path*100));
  1990. return f_path;
  1991. }
  1992. /** We just fetched a new set of descriptors. Compute how far through
  1993. * the "loading descriptors" bootstrapping phase we are, so we can inform
  1994. * the controller of our progress. */
  1995. int
  1996. count_loading_descriptors_progress(void)
  1997. {
  1998. int num_present = 0, num_usable=0;
  1999. time_t now = time(NULL);
  2000. const or_options_t *options = get_options();
  2001. const networkstatus_t *consensus =
  2002. networkstatus_get_reasonably_live_consensus(now,usable_consensus_flavor());
  2003. double paths, fraction;
  2004. if (!consensus)
  2005. return 0; /* can't count descriptors if we have no list of them */
  2006. paths = compute_frac_paths_available(consensus, options, now,
  2007. &num_present, &num_usable,
  2008. NULL);
  2009. fraction = paths / get_frac_paths_needed_for_circs(options,consensus);
  2010. if (fraction > 1.0)
  2011. return 0; /* it's not the number of descriptors holding us back */
  2012. return BOOTSTRAP_STATUS_LOADING_DESCRIPTORS + (int)
  2013. (fraction*(BOOTSTRAP_STATUS_CONN_OR-1 -
  2014. BOOTSTRAP_STATUS_LOADING_DESCRIPTORS));
  2015. }
  2016. /** Return the fraction of paths needed before we're willing to build
  2017. * circuits, as configured in <b>options</b>, or in the consensus <b>ns</b>. */
  2018. static double
  2019. get_frac_paths_needed_for_circs(const or_options_t *options,
  2020. const networkstatus_t *ns)
  2021. {
  2022. #define DFLT_PCT_USABLE_NEEDED 60
  2023. if (options->PathsNeededToBuildCircuits >= 0.0) {
  2024. return options->PathsNeededToBuildCircuits;
  2025. } else {
  2026. return networkstatus_get_param(ns, "min_paths_for_circs_pct",
  2027. DFLT_PCT_USABLE_NEEDED,
  2028. 25, 95)/100.0;
  2029. }
  2030. }
  2031. /** Change the value of have_min_dir_info, setting it true iff we have enough
  2032. * network and router information to build circuits. Clear the value of
  2033. * need_to_update_have_min_dir_info. */
  2034. static void
  2035. update_router_have_minimum_dir_info(void)
  2036. {
  2037. time_t now = time(NULL);
  2038. int res;
  2039. int num_present=0, num_usable=0;
  2040. const or_options_t *options = get_options();
  2041. const networkstatus_t *consensus =
  2042. networkstatus_get_reasonably_live_consensus(now,usable_consensus_flavor());
  2043. int using_md;
  2044. if (!consensus) {
  2045. if (!networkstatus_get_latest_consensus())
  2046. strlcpy(dir_info_status, "We have no usable consensus.",
  2047. sizeof(dir_info_status));
  2048. else
  2049. strlcpy(dir_info_status, "We have no recent usable consensus.",
  2050. sizeof(dir_info_status));
  2051. res = 0;
  2052. goto done;
  2053. }
  2054. using_md = consensus->flavor == FLAV_MICRODESC;
  2055. /* Check fraction of available paths */
  2056. {
  2057. char *status = NULL;
  2058. double paths = compute_frac_paths_available(consensus, options, now,
  2059. &num_present, &num_usable,
  2060. &status);
  2061. if (paths < get_frac_paths_needed_for_circs(options,consensus)) {
  2062. tor_snprintf(dir_info_status, sizeof(dir_info_status),
  2063. "We need more %sdescriptors: we have %d/%d, and "
  2064. "can only build %d%% of likely paths. (We have %s.)",
  2065. using_md?"micro":"", num_present, num_usable,
  2066. (int)(paths*100), status);
  2067. tor_free(status);
  2068. res = 0;
  2069. control_event_bootstrap(BOOTSTRAP_STATUS_REQUESTING_DESCRIPTORS, 0);
  2070. goto done;
  2071. }
  2072. tor_free(status);
  2073. res = 1;
  2074. }
  2075. { /* Check entry guard dirinfo status */
  2076. char *guard_error = entry_guards_get_err_str_if_dir_info_missing(using_md,
  2077. num_present,
  2078. num_usable);
  2079. if (guard_error) {
  2080. strlcpy(dir_info_status, guard_error, sizeof(dir_info_status));
  2081. tor_free(guard_error);
  2082. res = 0;
  2083. goto done;
  2084. }
  2085. }
  2086. done:
  2087. /* If paths have just become available in this update. */
  2088. if (res && !have_min_dir_info) {
  2089. control_event_client_status(LOG_NOTICE, "ENOUGH_DIR_INFO");
  2090. if (control_event_bootstrap(BOOTSTRAP_STATUS_CONN_OR, 0) == 0) {
  2091. log_notice(LD_DIR,
  2092. "We now have enough directory information to build circuits.");
  2093. }
  2094. }
  2095. /* If paths have just become unavailable in this update. */
  2096. if (!res && have_min_dir_info) {
  2097. int quiet = directory_too_idle_to_fetch_descriptors(options, now);
  2098. tor_log(quiet ? LOG_INFO : LOG_NOTICE, LD_DIR,
  2099. "Our directory information is no longer up-to-date "
  2100. "enough to build circuits: %s", dir_info_status);
  2101. /* a) make us log when we next complete a circuit, so we know when Tor
  2102. * is back up and usable, and b) disable some activities that Tor
  2103. * should only do while circuits are working, like reachability tests
  2104. * and fetching bridge descriptors only over circuits. */
  2105. note_that_we_maybe_cant_complete_circuits();
  2106. have_consensus_path = CONSENSUS_PATH_UNKNOWN;
  2107. control_event_client_status(LOG_NOTICE, "NOT_ENOUGH_DIR_INFO");
  2108. }
  2109. have_min_dir_info = res;
  2110. need_to_update_have_min_dir_info = 0;
  2111. }