nodelist.c 78 KB

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