nodelist.c 62 KB

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