nodelist.c 75 KB

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