nodelist.c 74 KB

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