entrynodes.c 81 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327
  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-2013, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  6. /**
  7. * \file entrynodes.c
  8. * \brief Code to manage our fixed first nodes for various functions.
  9. *
  10. * Entry nodes can be guards (for general use) or bridges (for censorship
  11. * circumvention).
  12. **/
  13. #include "or.h"
  14. #include "circpathbias.h"
  15. #include "circuitbuild.h"
  16. #include "circuitstats.h"
  17. #include "config.h"
  18. #include "confparse.h"
  19. #include "connection.h"
  20. #include "connection_or.h"
  21. #include "control.h"
  22. #include "directory.h"
  23. #include "entrynodes.h"
  24. #include "main.h"
  25. #include "microdesc.h"
  26. #include "networkstatus.h"
  27. #include "nodelist.h"
  28. #include "policies.h"
  29. #include "router.h"
  30. #include "routerlist.h"
  31. #include "routerparse.h"
  32. #include "routerset.h"
  33. #include "transports.h"
  34. #include "statefile.h"
  35. /** Information about a configured bridge. Currently this just matches the
  36. * ones in the torrc file, but one day we may be able to learn about new
  37. * bridges on our own, and remember them in the state file. */
  38. typedef struct {
  39. /** Address of the bridge. */
  40. tor_addr_t addr;
  41. /** TLS port for the bridge. */
  42. uint16_t port;
  43. /** Boolean: We are re-parsing our bridge list, and we are going to remove
  44. * this one if we don't find it in the list of configured bridges. */
  45. unsigned marked_for_removal : 1;
  46. /** Expected identity digest, or all zero bytes if we don't know what the
  47. * digest should be. */
  48. char identity[DIGEST_LEN];
  49. /** Name of pluggable transport protocol taken from its config line. */
  50. char *transport_name;
  51. /** When should we next try to fetch a descriptor for this bridge? */
  52. download_status_t fetch_status;
  53. /** A smartlist of k=v values to be passed to the SOCKS proxy, if
  54. transports are used for this bridge. */
  55. smartlist_t *socks_args;
  56. } bridge_info_t;
  57. /** A list of our chosen entry guards. */
  58. static smartlist_t *entry_guards = NULL;
  59. /** A value of 1 means that the entry_guards list has changed
  60. * and those changes need to be flushed to disk. */
  61. static int entry_guards_dirty = 0;
  62. static void bridge_free(bridge_info_t *bridge);
  63. static const node_t *choose_random_entry_impl(cpath_build_state_t *state,
  64. int for_directory,
  65. dirinfo_type_t dirtype,
  66. int *n_options_out);
  67. static int num_bridges_usable(void);
  68. /** Return the list of entry guards, creating it if necessary. */
  69. const smartlist_t *
  70. get_entry_guards(void)
  71. {
  72. if (! entry_guards)
  73. entry_guards = smartlist_new();
  74. return entry_guards;
  75. }
  76. /** Check whether the entry guard <b>e</b> is usable, given the directory
  77. * authorities' opinion about the router (stored in <b>ri</b>) and the user's
  78. * configuration (in <b>options</b>). Set <b>e</b>-&gt;bad_since
  79. * accordingly. Return true iff the entry guard's status changes.
  80. *
  81. * If it's not usable, set *<b>reason</b> to a static string explaining why.
  82. */
  83. static int
  84. entry_guard_set_status(entry_guard_t *e, const node_t *node,
  85. time_t now, const or_options_t *options,
  86. const char **reason)
  87. {
  88. char buf[HEX_DIGEST_LEN+1];
  89. int changed = 0;
  90. *reason = NULL;
  91. /* Do we want to mark this guard as bad? */
  92. if (!node)
  93. *reason = "unlisted";
  94. else if (!node->is_running)
  95. *reason = "down";
  96. else if (options->UseBridges && (!node->ri ||
  97. node->ri->purpose != ROUTER_PURPOSE_BRIDGE))
  98. *reason = "not a bridge";
  99. else if (options->UseBridges && !node_is_a_configured_bridge(node))
  100. *reason = "not a configured bridge";
  101. else if (!options->UseBridges && !node->is_possible_guard &&
  102. !routerset_contains_node(options->EntryNodes,node))
  103. *reason = "not recommended as a guard";
  104. else if (routerset_contains_node(options->ExcludeNodes, node))
  105. *reason = "excluded";
  106. else if (e->path_bias_disabled)
  107. *reason = "path-biased";
  108. if (*reason && ! e->bad_since) {
  109. /* Router is newly bad. */
  110. base16_encode(buf, sizeof(buf), e->identity, DIGEST_LEN);
  111. log_info(LD_CIRC, "Entry guard %s (%s) is %s: marking as unusable.",
  112. e->nickname, buf, *reason);
  113. e->bad_since = now;
  114. control_event_guard(e->nickname, e->identity, "BAD");
  115. changed = 1;
  116. } else if (!*reason && e->bad_since) {
  117. /* There's nothing wrong with the router any more. */
  118. base16_encode(buf, sizeof(buf), e->identity, DIGEST_LEN);
  119. log_info(LD_CIRC, "Entry guard %s (%s) is no longer unusable: "
  120. "marking as ok.", e->nickname, buf);
  121. e->bad_since = 0;
  122. control_event_guard(e->nickname, e->identity, "GOOD");
  123. changed = 1;
  124. }
  125. if (node) {
  126. int is_dir = node_is_dir(node) && node->rs &&
  127. node->rs->version_supports_microdesc_cache;
  128. if (options->UseBridges && node_is_a_configured_bridge(node))
  129. is_dir = 1;
  130. if (e->is_dir_cache != is_dir) {
  131. e->is_dir_cache = is_dir;
  132. changed = 1;
  133. }
  134. }
  135. return changed;
  136. }
  137. /** Return true iff enough time has passed since we last tried to connect
  138. * to the unreachable guard <b>e</b> that we're willing to try again. */
  139. static int
  140. entry_is_time_to_retry(entry_guard_t *e, time_t now)
  141. {
  142. long diff;
  143. if (e->last_attempted < e->unreachable_since)
  144. return 1;
  145. diff = now - e->unreachable_since;
  146. if (diff < 6*60*60)
  147. return now > (e->last_attempted + 60*60);
  148. else if (diff < 3*24*60*60)
  149. return now > (e->last_attempted + 4*60*60);
  150. else if (diff < 7*24*60*60)
  151. return now > (e->last_attempted + 18*60*60);
  152. else
  153. return now > (e->last_attempted + 36*60*60);
  154. }
  155. /** Return the node corresponding to <b>e</b>, if <b>e</b> is
  156. * working well enough that we are willing to use it as an entry
  157. * right now. (Else return NULL.) In particular, it must be
  158. * - Listed as either up or never yet contacted;
  159. * - Present in the routerlist;
  160. * - Listed as 'stable' or 'fast' by the current dirserver consensus,
  161. * if demanded by <b>need_uptime</b> or <b>need_capacity</b>
  162. * (unless it's a configured EntryNode);
  163. * - Allowed by our current ReachableORAddresses config option; and
  164. * - Currently thought to be reachable by us (unless <b>assume_reachable</b>
  165. * is true).
  166. *
  167. * If the answer is no, set *<b>msg</b> to an explanation of why.
  168. *
  169. * If need_descriptor is true, only return the node if we currently have
  170. * a descriptor (routerinfo or microdesc) for it.
  171. */
  172. static INLINE const node_t *
  173. entry_is_live(entry_guard_t *e, int need_uptime, int need_capacity,
  174. int assume_reachable, int need_descriptor, const char **msg)
  175. {
  176. const node_t *node;
  177. const or_options_t *options = get_options();
  178. tor_assert(msg);
  179. if (e->path_bias_disabled) {
  180. *msg = "path-biased";
  181. return NULL;
  182. }
  183. if (e->bad_since) {
  184. *msg = "bad";
  185. return NULL;
  186. }
  187. /* no good if it's unreachable, unless assume_unreachable or can_retry. */
  188. if (!assume_reachable && !e->can_retry &&
  189. e->unreachable_since && !entry_is_time_to_retry(e, time(NULL))) {
  190. *msg = "unreachable";
  191. return NULL;
  192. }
  193. node = node_get_by_id(e->identity);
  194. if (!node) {
  195. *msg = "no node info";
  196. return NULL;
  197. }
  198. if (need_descriptor && !node_has_descriptor(node)) {
  199. *msg = "no descriptor";
  200. return NULL;
  201. }
  202. if (get_options()->UseBridges) {
  203. if (node_get_purpose(node) != ROUTER_PURPOSE_BRIDGE) {
  204. *msg = "not a bridge";
  205. return NULL;
  206. }
  207. if (!node_is_a_configured_bridge(node)) {
  208. *msg = "not a configured bridge";
  209. return NULL;
  210. }
  211. } else { /* !get_options()->UseBridges */
  212. if (node_get_purpose(node) != ROUTER_PURPOSE_GENERAL) {
  213. *msg = "not general-purpose";
  214. return NULL;
  215. }
  216. }
  217. if (routerset_contains_node(options->EntryNodes, node)) {
  218. /* they asked for it, they get it */
  219. need_uptime = need_capacity = 0;
  220. }
  221. if (node_is_unreliable(node, need_uptime, need_capacity, 0)) {
  222. *msg = "not fast/stable";
  223. return NULL;
  224. }
  225. if (!fascist_firewall_allows_node(node)) {
  226. *msg = "unreachable by config";
  227. return NULL;
  228. }
  229. return node;
  230. }
  231. /** Return the number of entry guards that we think are usable. */
  232. int
  233. num_live_entry_guards(int for_directory)
  234. {
  235. int n = 0;
  236. const char *msg;
  237. if (! entry_guards)
  238. return 0;
  239. SMARTLIST_FOREACH_BEGIN(entry_guards, entry_guard_t *, entry) {
  240. if (for_directory && !entry->is_dir_cache)
  241. continue;
  242. if (entry_is_live(entry, 0, 1, 0, !for_directory, &msg))
  243. ++n;
  244. } SMARTLIST_FOREACH_END(entry);
  245. return n;
  246. }
  247. /** If <b>digest</b> matches the identity of any node in the
  248. * entry_guards list, return that node. Else return NULL. */
  249. entry_guard_t *
  250. entry_guard_get_by_id_digest(const char *digest)
  251. {
  252. SMARTLIST_FOREACH(entry_guards, entry_guard_t *, entry,
  253. if (tor_memeq(digest, entry->identity, DIGEST_LEN))
  254. return entry;
  255. );
  256. return NULL;
  257. }
  258. /** Dump a description of our list of entry guards to the log at level
  259. * <b>severity</b>. */
  260. static void
  261. log_entry_guards(int severity)
  262. {
  263. smartlist_t *elements = smartlist_new();
  264. char *s;
  265. SMARTLIST_FOREACH_BEGIN(entry_guards, entry_guard_t *, e)
  266. {
  267. const char *msg = NULL;
  268. if (entry_is_live(e, 0, 1, 0, 0, &msg))
  269. smartlist_add_asprintf(elements, "%s [%s] (up %s)",
  270. e->nickname,
  271. hex_str(e->identity, DIGEST_LEN),
  272. e->made_contact ? "made-contact" : "never-contacted");
  273. else
  274. smartlist_add_asprintf(elements, "%s [%s] (%s, %s)",
  275. e->nickname,
  276. hex_str(e->identity, DIGEST_LEN),
  277. msg,
  278. e->made_contact ? "made-contact" : "never-contacted");
  279. }
  280. SMARTLIST_FOREACH_END(e);
  281. s = smartlist_join_strings(elements, ",", 0, NULL);
  282. SMARTLIST_FOREACH(elements, char*, cp, tor_free(cp));
  283. smartlist_free(elements);
  284. log_fn(severity,LD_CIRC,"%s",s);
  285. tor_free(s);
  286. }
  287. /** Called when one or more guards that we would previously have used for some
  288. * purpose are no longer in use because a higher-priority guard has become
  289. * usable again. */
  290. static void
  291. control_event_guard_deferred(void)
  292. {
  293. /* XXXX We don't actually have a good way to figure out _how many_ entries
  294. * are live for some purpose. We need an entry_is_even_slightly_live()
  295. * function for this to work right. NumEntryGuards isn't reliable: if we
  296. * need guards with weird properties, we can have more than that number
  297. * live.
  298. **/
  299. #if 0
  300. int n = 0;
  301. const char *msg;
  302. const or_options_t *options = get_options();
  303. if (!entry_guards)
  304. return;
  305. SMARTLIST_FOREACH(entry_guards, entry_guard_t *, entry,
  306. {
  307. if (entry_is_live(entry, 0, 1, 0, &msg)) {
  308. if (n++ == options->NumEntryGuards) {
  309. control_event_guard(entry->nickname, entry->identity, "DEFERRED");
  310. return;
  311. }
  312. }
  313. });
  314. #endif
  315. }
  316. /** Largest amount that we'll backdate chosen_on_date */
  317. #define CHOSEN_ON_DATE_SLOP (30*86400)
  318. /** Add a new (preferably stable and fast) router to our
  319. * entry_guards list. Return a pointer to the router if we succeed,
  320. * or NULL if we can't find any more suitable entries.
  321. *
  322. * If <b>chosen</b> is defined, use that one, and if it's not
  323. * already in our entry_guards list, put it at the *beginning*.
  324. * Else, put the one we pick at the end of the list. */
  325. static const node_t *
  326. add_an_entry_guard(const node_t *chosen, int reset_status, int prepend,
  327. int for_discovery, int for_directory)
  328. {
  329. const node_t *node;
  330. entry_guard_t *entry;
  331. if (chosen) {
  332. node = chosen;
  333. entry = entry_guard_get_by_id_digest(node->identity);
  334. if (entry) {
  335. if (reset_status) {
  336. entry->bad_since = 0;
  337. entry->can_retry = 1;
  338. }
  339. entry->is_dir_cache = node->rs &&
  340. node->rs->version_supports_microdesc_cache;
  341. if (get_options()->UseBridges && node_is_a_configured_bridge(node))
  342. entry->is_dir_cache = 1;
  343. return NULL;
  344. }
  345. } else if (!for_directory) {
  346. node = choose_good_entry_server(CIRCUIT_PURPOSE_C_GENERAL, NULL);
  347. if (!node)
  348. return NULL;
  349. } else {
  350. const routerstatus_t *rs;
  351. rs = router_pick_directory_server(MICRODESC_DIRINFO|V3_DIRINFO,
  352. PDS_FOR_GUARD);
  353. if (!rs)
  354. return NULL;
  355. node = node_get_by_id(rs->identity_digest);
  356. if (!node)
  357. return NULL;
  358. }
  359. if (node->using_as_guard)
  360. return NULL;
  361. if (entry_guard_get_by_id_digest(node->identity) != NULL) {
  362. log_info(LD_CIRC, "I was about to add a duplicate entry guard.");
  363. /* This can happen if we choose a guard, then the node goes away, then
  364. * comes back. */
  365. ((node_t*) node)->using_as_guard = 1;
  366. return NULL;
  367. }
  368. entry = tor_malloc_zero(sizeof(entry_guard_t));
  369. log_info(LD_CIRC, "Chose %s as new entry guard.",
  370. node_describe(node));
  371. strlcpy(entry->nickname, node_get_nickname(node), sizeof(entry->nickname));
  372. memcpy(entry->identity, node->identity, DIGEST_LEN);
  373. entry->is_dir_cache = node_is_dir(node) && node->rs &&
  374. node->rs->version_supports_microdesc_cache;
  375. if (get_options()->UseBridges && node_is_a_configured_bridge(node))
  376. entry->is_dir_cache = 1;
  377. /* Choose expiry time smudged over the past month. The goal here
  378. * is to a) spread out when Tor clients rotate their guards, so they
  379. * don't all select them on the same day, and b) avoid leaving a
  380. * precise timestamp in the state file about when we first picked
  381. * this guard. For details, see the Jan 2010 or-dev thread. */
  382. entry->chosen_on_date = time(NULL) - crypto_rand_int(3600*24*30);
  383. entry->chosen_by_version = tor_strdup(VERSION);
  384. /* Are we picking this guard because all of our current guards are
  385. * down so we need another one (for_discovery is 1), or because we
  386. * decided we need more variety in our guard list (for_discovery is 0)?
  387. *
  388. * Currently we hack this behavior into place by setting "made_contact"
  389. * for guards of the latter variety, so we'll be willing to use any of
  390. * them right off the bat.
  391. */
  392. if (!for_discovery)
  393. entry->made_contact = 1;
  394. ((node_t*)node)->using_as_guard = 1;
  395. if (prepend)
  396. smartlist_insert(entry_guards, 0, entry);
  397. else
  398. smartlist_add(entry_guards, entry);
  399. control_event_guard(entry->nickname, entry->identity, "NEW");
  400. control_event_guard_deferred();
  401. log_entry_guards(LOG_INFO);
  402. return node;
  403. }
  404. /** Choose how many entry guards or directory guards we'll use. If
  405. * <b>for_directory</b> is true, we return how many directory guards to
  406. * use; else we return how many entry guards to use. */
  407. static int
  408. decide_num_guards(const or_options_t *options, int for_directory)
  409. {
  410. if (for_directory && options->NumDirectoryGuards != 0)
  411. return options->NumDirectoryGuards;
  412. return options->NumEntryGuards;
  413. }
  414. /** If the use of entry guards is configured, choose more entry guards
  415. * until we have enough in the list. */
  416. static void
  417. pick_entry_guards(const or_options_t *options, int for_directory)
  418. {
  419. int changed = 0;
  420. const int num_needed = decide_num_guards(options, for_directory);
  421. tor_assert(entry_guards);
  422. while (num_live_entry_guards(for_directory) < num_needed) {
  423. if (!add_an_entry_guard(NULL, 0, 0, 0, for_directory))
  424. break;
  425. changed = 1;
  426. }
  427. if (changed)
  428. entry_guards_changed();
  429. }
  430. /** How long (in seconds) do we allow an entry guard to be nonfunctional,
  431. * unlisted, excluded, or otherwise nonusable before we give up on it? */
  432. #define ENTRY_GUARD_REMOVE_AFTER (30*24*60*60)
  433. /** Release all storage held by <b>e</b>. */
  434. static void
  435. entry_guard_free(entry_guard_t *e)
  436. {
  437. if (!e)
  438. return;
  439. tor_free(e->chosen_by_version);
  440. tor_free(e);
  441. }
  442. /**
  443. * Return the minimum lifetime of working entry guard, in seconds,
  444. * as given in the consensus networkstatus. (Plus CHOSEN_ON_DATE_SLOP,
  445. * so that we can do the chosen_on_date randomization while achieving the
  446. * desired minimum lifetime.)
  447. */
  448. static int32_t
  449. guards_get_lifetime(void)
  450. {
  451. const or_options_t *options = get_options();
  452. #define DFLT_GUARD_LIFETIME (86400 * 60) /* Two months. */
  453. #define MIN_GUARD_LIFETIME (86400 * 30) /* One months. */
  454. #define MAX_GUARD_LIFETIME (86400 * 1826) /* Five years. */
  455. if (options->GuardLifetime >= 1) {
  456. return CLAMP(MIN_GUARD_LIFETIME,
  457. options->GuardLifetime,
  458. MAX_GUARD_LIFETIME) + CHOSEN_ON_DATE_SLOP;
  459. }
  460. return networkstatus_get_param(NULL, "GuardLifetime",
  461. DFLT_GUARD_LIFETIME,
  462. MIN_GUARD_LIFETIME,
  463. MAX_GUARD_LIFETIME) + CHOSEN_ON_DATE_SLOP;
  464. }
  465. /** Remove any entry guard which was selected by an unknown version of Tor,
  466. * or which was selected by a version of Tor that's known to select
  467. * entry guards badly, or which was selected more 2 months ago. */
  468. /* XXXX The "obsolete guards" and "chosen long ago guards" things should
  469. * probably be different functions. */
  470. static int
  471. remove_obsolete_entry_guards(time_t now)
  472. {
  473. int changed = 0, i;
  474. int32_t guard_lifetime = guards_get_lifetime();
  475. for (i = 0; i < smartlist_len(entry_guards); ++i) {
  476. entry_guard_t *entry = smartlist_get(entry_guards, i);
  477. const char *ver = entry->chosen_by_version;
  478. const char *msg = NULL;
  479. tor_version_t v;
  480. int version_is_bad = 0, date_is_bad = 0;
  481. if (!ver) {
  482. msg = "does not say what version of Tor it was selected by";
  483. version_is_bad = 1;
  484. } else if (tor_version_parse(ver, &v)) {
  485. msg = "does not seem to be from any recognized version of Tor";
  486. version_is_bad = 1;
  487. } else {
  488. char *tor_ver = NULL;
  489. tor_asprintf(&tor_ver, "Tor %s", ver);
  490. if ((tor_version_as_new_as(tor_ver, "0.1.0.10-alpha") &&
  491. !tor_version_as_new_as(tor_ver, "0.1.2.16-dev")) ||
  492. (tor_version_as_new_as(tor_ver, "0.2.0.0-alpha") &&
  493. !tor_version_as_new_as(tor_ver, "0.2.0.6-alpha")) ||
  494. /* above are bug 440; below are bug 1217 */
  495. (tor_version_as_new_as(tor_ver, "0.2.1.3-alpha") &&
  496. !tor_version_as_new_as(tor_ver, "0.2.1.23")) ||
  497. (tor_version_as_new_as(tor_ver, "0.2.2.0-alpha") &&
  498. !tor_version_as_new_as(tor_ver, "0.2.2.7-alpha"))) {
  499. msg = "was selected without regard for guard bandwidth";
  500. version_is_bad = 1;
  501. }
  502. tor_free(tor_ver);
  503. }
  504. if (!version_is_bad && entry->chosen_on_date + guard_lifetime < now) {
  505. /* It's been too long since the date listed in our state file. */
  506. msg = "was selected several months ago";
  507. date_is_bad = 1;
  508. }
  509. if (version_is_bad || date_is_bad) { /* we need to drop it */
  510. char dbuf[HEX_DIGEST_LEN+1];
  511. tor_assert(msg);
  512. base16_encode(dbuf, sizeof(dbuf), entry->identity, DIGEST_LEN);
  513. log_fn(version_is_bad ? LOG_NOTICE : LOG_INFO, LD_CIRC,
  514. "Entry guard '%s' (%s) %s. (Version=%s.) Replacing it.",
  515. entry->nickname, dbuf, msg, ver?escaped(ver):"none");
  516. control_event_guard(entry->nickname, entry->identity, "DROPPED");
  517. entry_guard_free(entry);
  518. smartlist_del_keeporder(entry_guards, i--);
  519. log_entry_guards(LOG_INFO);
  520. changed = 1;
  521. }
  522. }
  523. return changed ? 1 : 0;
  524. }
  525. /** Remove all entry guards that have been down or unlisted for so
  526. * long that we don't think they'll come up again. Return 1 if we
  527. * removed any, or 0 if we did nothing. */
  528. static int
  529. remove_dead_entry_guards(time_t now)
  530. {
  531. char dbuf[HEX_DIGEST_LEN+1];
  532. char tbuf[ISO_TIME_LEN+1];
  533. int i;
  534. int changed = 0;
  535. for (i = 0; i < smartlist_len(entry_guards); ) {
  536. entry_guard_t *entry = smartlist_get(entry_guards, i);
  537. if (entry->bad_since &&
  538. ! entry->path_bias_disabled &&
  539. entry->bad_since + ENTRY_GUARD_REMOVE_AFTER < now) {
  540. base16_encode(dbuf, sizeof(dbuf), entry->identity, DIGEST_LEN);
  541. format_local_iso_time(tbuf, entry->bad_since);
  542. log_info(LD_CIRC, "Entry guard '%s' (%s) has been down or unlisted "
  543. "since %s local time; removing.",
  544. entry->nickname, dbuf, tbuf);
  545. control_event_guard(entry->nickname, entry->identity, "DROPPED");
  546. entry_guard_free(entry);
  547. smartlist_del_keeporder(entry_guards, i);
  548. log_entry_guards(LOG_INFO);
  549. changed = 1;
  550. } else
  551. ++i;
  552. }
  553. return changed ? 1 : 0;
  554. }
  555. /** Remove all currently listed entry guards. So new ones will be chosen. */
  556. void
  557. remove_all_entry_guards(void)
  558. {
  559. char dbuf[HEX_DIGEST_LEN+1];
  560. while (smartlist_len(entry_guards)) {
  561. entry_guard_t *entry = smartlist_get(entry_guards, 0);
  562. base16_encode(dbuf, sizeof(dbuf), entry->identity, DIGEST_LEN);
  563. log_info(LD_CIRC, "Entry guard '%s' (%s) has been dropped.",
  564. entry->nickname, dbuf);
  565. control_event_guard(entry->nickname, entry->identity, "DROPPED");
  566. entry_guard_free(entry);
  567. smartlist_del(entry_guards, 0);
  568. }
  569. log_entry_guards(LOG_INFO);
  570. entry_guards_changed();
  571. }
  572. /** A new directory or router-status has arrived; update the down/listed
  573. * status of the entry guards.
  574. *
  575. * An entry is 'down' if the directory lists it as nonrunning.
  576. * An entry is 'unlisted' if the directory doesn't include it.
  577. *
  578. * Don't call this on startup; only on a fresh download. Otherwise we'll
  579. * think that things are unlisted.
  580. */
  581. void
  582. entry_guards_compute_status(const or_options_t *options, time_t now)
  583. {
  584. int changed = 0;
  585. digestmap_t *reasons;
  586. if (! entry_guards)
  587. return;
  588. if (options->EntryNodes) /* reshuffle the entry guard list if needed */
  589. entry_nodes_should_be_added();
  590. reasons = digestmap_new();
  591. SMARTLIST_FOREACH_BEGIN(entry_guards, entry_guard_t *, entry)
  592. {
  593. const node_t *r = node_get_by_id(entry->identity);
  594. const char *reason = NULL;
  595. if (entry_guard_set_status(entry, r, now, options, &reason))
  596. changed = 1;
  597. if (entry->bad_since)
  598. tor_assert(reason);
  599. if (reason)
  600. digestmap_set(reasons, entry->identity, (char*)reason);
  601. }
  602. SMARTLIST_FOREACH_END(entry);
  603. if (remove_dead_entry_guards(now))
  604. changed = 1;
  605. if (remove_obsolete_entry_guards(now))
  606. changed = 1;
  607. if (changed) {
  608. SMARTLIST_FOREACH_BEGIN(entry_guards, entry_guard_t *, entry) {
  609. const char *reason = digestmap_get(reasons, entry->identity);
  610. const char *live_msg = "";
  611. const node_t *r = entry_is_live(entry, 0, 1, 0, 0, &live_msg);
  612. log_info(LD_CIRC, "Summary: Entry %s [%s] is %s, %s%s%s, and %s%s.",
  613. entry->nickname,
  614. hex_str(entry->identity, DIGEST_LEN),
  615. entry->unreachable_since ? "unreachable" : "reachable",
  616. entry->bad_since ? "unusable" : "usable",
  617. reason ? ", ": "",
  618. reason ? reason : "",
  619. r ? "live" : "not live / ",
  620. r ? "" : live_msg);
  621. } SMARTLIST_FOREACH_END(entry);
  622. log_info(LD_CIRC, " (%d/%d entry guards are usable/new)",
  623. num_live_entry_guards(0), smartlist_len(entry_guards));
  624. log_entry_guards(LOG_INFO);
  625. entry_guards_changed();
  626. }
  627. digestmap_free(reasons, NULL);
  628. }
  629. /** Called when a connection to an OR with the identity digest <b>digest</b>
  630. * is established (<b>succeeded</b>==1) or has failed (<b>succeeded</b>==0).
  631. * If the OR is an entry, change that entry's up/down status.
  632. * Return 0 normally, or -1 if we want to tear down the new connection.
  633. *
  634. * If <b>mark_relay_status</b>, also call router_set_status() on this
  635. * relay.
  636. *
  637. * XXX024 change succeeded and mark_relay_status into 'int flags'.
  638. */
  639. int
  640. entry_guard_register_connect_status(const char *digest, int succeeded,
  641. int mark_relay_status, time_t now)
  642. {
  643. int changed = 0;
  644. int refuse_conn = 0;
  645. int first_contact = 0;
  646. entry_guard_t *entry = NULL;
  647. int idx = -1;
  648. char buf[HEX_DIGEST_LEN+1];
  649. if (! entry_guards)
  650. return 0;
  651. SMARTLIST_FOREACH_BEGIN(entry_guards, entry_guard_t *, e) {
  652. tor_assert(e);
  653. if (tor_memeq(e->identity, digest, DIGEST_LEN)) {
  654. entry = e;
  655. idx = e_sl_idx;
  656. break;
  657. }
  658. } SMARTLIST_FOREACH_END(e);
  659. if (!entry)
  660. return 0;
  661. base16_encode(buf, sizeof(buf), entry->identity, DIGEST_LEN);
  662. if (succeeded) {
  663. if (entry->unreachable_since) {
  664. log_info(LD_CIRC, "Entry guard '%s' (%s) is now reachable again. Good.",
  665. entry->nickname, buf);
  666. entry->can_retry = 0;
  667. entry->unreachable_since = 0;
  668. entry->last_attempted = now;
  669. control_event_guard(entry->nickname, entry->identity, "UP");
  670. changed = 1;
  671. }
  672. if (!entry->made_contact) {
  673. entry->made_contact = 1;
  674. first_contact = changed = 1;
  675. }
  676. } else { /* ! succeeded */
  677. if (!entry->made_contact) {
  678. /* We've never connected to this one. */
  679. log_info(LD_CIRC,
  680. "Connection to never-contacted entry guard '%s' (%s) failed. "
  681. "Removing from the list. %d/%d entry guards usable/new.",
  682. entry->nickname, buf,
  683. num_live_entry_guards(0)-1, smartlist_len(entry_guards)-1);
  684. control_event_guard(entry->nickname, entry->identity, "DROPPED");
  685. entry_guard_free(entry);
  686. smartlist_del_keeporder(entry_guards, idx);
  687. log_entry_guards(LOG_INFO);
  688. changed = 1;
  689. } else if (!entry->unreachable_since) {
  690. log_info(LD_CIRC, "Unable to connect to entry guard '%s' (%s). "
  691. "Marking as unreachable.", entry->nickname, buf);
  692. entry->unreachable_since = entry->last_attempted = now;
  693. control_event_guard(entry->nickname, entry->identity, "DOWN");
  694. changed = 1;
  695. entry->can_retry = 0; /* We gave it an early chance; no good. */
  696. } else {
  697. char tbuf[ISO_TIME_LEN+1];
  698. format_iso_time(tbuf, entry->unreachable_since);
  699. log_debug(LD_CIRC, "Failed to connect to unreachable entry guard "
  700. "'%s' (%s). It has been unreachable since %s.",
  701. entry->nickname, buf, tbuf);
  702. entry->last_attempted = now;
  703. entry->can_retry = 0; /* We gave it an early chance; no good. */
  704. }
  705. }
  706. /* if the caller asked us to, also update the is_running flags for this
  707. * relay */
  708. if (mark_relay_status)
  709. router_set_status(digest, succeeded);
  710. if (first_contact) {
  711. /* We've just added a new long-term entry guard. Perhaps the network just
  712. * came back? We should give our earlier entries another try too,
  713. * and close this connection so we don't use it before we've given
  714. * the others a shot. */
  715. SMARTLIST_FOREACH_BEGIN(entry_guards, entry_guard_t *, e) {
  716. if (e == entry)
  717. break;
  718. if (e->made_contact) {
  719. const char *msg;
  720. const node_t *r = entry_is_live(e, 0, 1, 1, 0, &msg);
  721. if (r && e->unreachable_since) {
  722. refuse_conn = 1;
  723. e->can_retry = 1;
  724. }
  725. }
  726. } SMARTLIST_FOREACH_END(e);
  727. if (refuse_conn) {
  728. log_info(LD_CIRC,
  729. "Connected to new entry guard '%s' (%s). Marking earlier "
  730. "entry guards up. %d/%d entry guards usable/new.",
  731. entry->nickname, buf,
  732. num_live_entry_guards(0), smartlist_len(entry_guards));
  733. log_entry_guards(LOG_INFO);
  734. changed = 1;
  735. }
  736. }
  737. if (changed)
  738. entry_guards_changed();
  739. return refuse_conn ? -1 : 0;
  740. }
  741. /** When we try to choose an entry guard, should we parse and add
  742. * config's EntryNodes first? */
  743. static int should_add_entry_nodes = 0;
  744. /** Called when the value of EntryNodes changes in our configuration. */
  745. void
  746. entry_nodes_should_be_added(void)
  747. {
  748. log_info(LD_CIRC, "EntryNodes config option set. Putting configured "
  749. "relays at the front of the entry guard list.");
  750. should_add_entry_nodes = 1;
  751. }
  752. /** Update the using_as_guard fields of all the nodes. We do this after we
  753. * remove entry guards from the list: This is the only function that clears
  754. * the using_as_guard field. */
  755. static void
  756. update_node_guard_status(void)
  757. {
  758. smartlist_t *nodes = nodelist_get_list();
  759. SMARTLIST_FOREACH(nodes, node_t *, node, node->using_as_guard = 0);
  760. SMARTLIST_FOREACH_BEGIN(entry_guards, entry_guard_t *, entry) {
  761. node_t *node = node_get_mutable_by_id(entry->identity);
  762. if (node)
  763. node->using_as_guard = 1;
  764. } SMARTLIST_FOREACH_END(entry);
  765. }
  766. /** Adjust the entry guards list so that it only contains entries from
  767. * EntryNodes, adding new entries from EntryNodes to the list as needed. */
  768. static void
  769. entry_guards_set_from_config(const or_options_t *options)
  770. {
  771. smartlist_t *entry_nodes, *worse_entry_nodes, *entry_fps;
  772. smartlist_t *old_entry_guards_on_list, *old_entry_guards_not_on_list;
  773. tor_assert(entry_guards);
  774. should_add_entry_nodes = 0;
  775. if (!options->EntryNodes) {
  776. /* It's possible that a controller set EntryNodes, thus making
  777. * should_add_entry_nodes set, then cleared it again, all before the
  778. * call to choose_random_entry() that triggered us. If so, just return.
  779. */
  780. return;
  781. }
  782. {
  783. char *string = routerset_to_string(options->EntryNodes);
  784. log_info(LD_CIRC,"Adding configured EntryNodes '%s'.", string);
  785. tor_free(string);
  786. }
  787. entry_nodes = smartlist_new();
  788. worse_entry_nodes = smartlist_new();
  789. entry_fps = smartlist_new();
  790. old_entry_guards_on_list = smartlist_new();
  791. old_entry_guards_not_on_list = smartlist_new();
  792. /* Split entry guards into those on the list and those not. */
  793. routerset_get_all_nodes(entry_nodes, options->EntryNodes,
  794. options->ExcludeNodes, 0);
  795. SMARTLIST_FOREACH(entry_nodes, const node_t *,node,
  796. smartlist_add(entry_fps, (void*)node->identity));
  797. SMARTLIST_FOREACH(entry_guards, entry_guard_t *, e, {
  798. if (smartlist_contains_digest(entry_fps, e->identity))
  799. smartlist_add(old_entry_guards_on_list, e);
  800. else
  801. smartlist_add(old_entry_guards_not_on_list, e);
  802. });
  803. /* Remove all currently configured guard nodes, excluded nodes, unreachable
  804. * nodes, or non-Guard nodes from entry_nodes. */
  805. SMARTLIST_FOREACH_BEGIN(entry_nodes, const node_t *, node) {
  806. if (entry_guard_get_by_id_digest(node->identity)) {
  807. SMARTLIST_DEL_CURRENT(entry_nodes, node);
  808. continue;
  809. } else if (routerset_contains_node(options->ExcludeNodes, node)) {
  810. SMARTLIST_DEL_CURRENT(entry_nodes, node);
  811. continue;
  812. } else if (!fascist_firewall_allows_node(node)) {
  813. SMARTLIST_DEL_CURRENT(entry_nodes, node);
  814. continue;
  815. } else if (! node->is_possible_guard) {
  816. smartlist_add(worse_entry_nodes, (node_t*)node);
  817. SMARTLIST_DEL_CURRENT(entry_nodes, node);
  818. }
  819. } SMARTLIST_FOREACH_END(node);
  820. /* Now build the new entry_guards list. */
  821. smartlist_clear(entry_guards);
  822. /* First, the previously configured guards that are in EntryNodes. */
  823. smartlist_add_all(entry_guards, old_entry_guards_on_list);
  824. /* Next, scramble the rest of EntryNodes, putting the guards first. */
  825. smartlist_shuffle(entry_nodes);
  826. smartlist_shuffle(worse_entry_nodes);
  827. smartlist_add_all(entry_nodes, worse_entry_nodes);
  828. /* Next, the rest of EntryNodes */
  829. SMARTLIST_FOREACH_BEGIN(entry_nodes, const node_t *, node) {
  830. add_an_entry_guard(node, 0, 0, 1, 0);
  831. if (smartlist_len(entry_guards) > options->NumEntryGuards * 10)
  832. break;
  833. } SMARTLIST_FOREACH_END(node);
  834. log_notice(LD_GENERAL, "%d entries in guards", smartlist_len(entry_guards));
  835. /* Finally, free the remaining previously configured guards that are not in
  836. * EntryNodes. */
  837. SMARTLIST_FOREACH(old_entry_guards_not_on_list, entry_guard_t *, e,
  838. entry_guard_free(e));
  839. update_node_guard_status();
  840. smartlist_free(entry_nodes);
  841. smartlist_free(worse_entry_nodes);
  842. smartlist_free(entry_fps);
  843. smartlist_free(old_entry_guards_on_list);
  844. smartlist_free(old_entry_guards_not_on_list);
  845. entry_guards_changed();
  846. }
  847. /** Return 0 if we're fine adding arbitrary routers out of the
  848. * directory to our entry guard list, or return 1 if we have a
  849. * list already and we must stick to it.
  850. */
  851. int
  852. entry_list_is_constrained(const or_options_t *options)
  853. {
  854. if (options->EntryNodes)
  855. return 1;
  856. if (options->UseBridges)
  857. return 1;
  858. return 0;
  859. }
  860. /** Return true iff this node can answer directory questions about
  861. * microdescriptors. */
  862. static int
  863. node_understands_microdescriptors(const node_t *node)
  864. {
  865. tor_assert(node);
  866. if (node->rs && node->rs->version_supports_microdesc_cache)
  867. return 1;
  868. if (node->ri && tor_version_supports_microdescriptors(node->ri->platform))
  869. return 1;
  870. return 0;
  871. }
  872. /** Return true iff <b>node</b> is able to answer directory questions
  873. * of type <b>dirinfo</b>. */
  874. static int
  875. node_can_handle_dirinfo(const node_t *node, dirinfo_type_t dirinfo)
  876. {
  877. /* Checking dirinfo for any type other than microdescriptors isn't required
  878. yet, since we only choose directory guards that can support microdescs,
  879. routerinfos, and networkstatuses, AND we don't use directory guards if
  880. we're configured to do direct downloads of anything else. The only case
  881. where we might have a guard that doesn't know about a type of directory
  882. information is when we're retrieving directory information from a
  883. bridge. */
  884. if ((dirinfo & MICRODESC_DIRINFO) &&
  885. !node_understands_microdescriptors(node))
  886. return 0;
  887. return 1;
  888. }
  889. /** Pick a live (up and listed) entry guard from entry_guards. If
  890. * <b>state</b> is non-NULL, this is for a specific circuit --
  891. * make sure not to pick this circuit's exit or any node in the
  892. * exit's family. If <b>state</b> is NULL, we're looking for a random
  893. * guard (likely a bridge). If <b>dirinfo</b> is not NO_DIRINFO, then
  894. * only select from nodes that know how to answer directory questions
  895. * of that type. */
  896. const node_t *
  897. choose_random_entry(cpath_build_state_t *state)
  898. {
  899. return choose_random_entry_impl(state, 0, 0, NULL);
  900. }
  901. /** Pick a live (up and listed) directory guard from entry_guards for
  902. * downloading information of type <b>type</b>. */
  903. const node_t *
  904. choose_random_dirguard(dirinfo_type_t type)
  905. {
  906. return choose_random_entry_impl(NULL, 1, type, NULL);
  907. }
  908. /** Helper for choose_random{entry,dirguard}. */
  909. static const node_t *
  910. choose_random_entry_impl(cpath_build_state_t *state, int for_directory,
  911. dirinfo_type_t dirinfo_type, int *n_options_out)
  912. {
  913. const or_options_t *options = get_options();
  914. smartlist_t *live_entry_guards = smartlist_new();
  915. smartlist_t *exit_family = smartlist_new();
  916. const node_t *chosen_exit =
  917. state?build_state_get_exit_node(state) : NULL;
  918. const node_t *node = NULL;
  919. int need_uptime = state ? state->need_uptime : 0;
  920. int need_capacity = state ? state->need_capacity : 0;
  921. int preferred_min, consider_exit_family = 0;
  922. int need_descriptor = !for_directory;
  923. const int num_needed = decide_num_guards(options, for_directory);
  924. if (n_options_out)
  925. *n_options_out = 0;
  926. if (chosen_exit) {
  927. nodelist_add_node_and_family(exit_family, chosen_exit);
  928. consider_exit_family = 1;
  929. }
  930. if (!entry_guards)
  931. entry_guards = smartlist_new();
  932. if (should_add_entry_nodes)
  933. entry_guards_set_from_config(options);
  934. if (!entry_list_is_constrained(options) &&
  935. smartlist_len(entry_guards) < num_needed)
  936. pick_entry_guards(options, for_directory);
  937. retry:
  938. smartlist_clear(live_entry_guards);
  939. SMARTLIST_FOREACH_BEGIN(entry_guards, entry_guard_t *, entry) {
  940. const char *msg;
  941. node = entry_is_live(entry, need_uptime, need_capacity, 0,
  942. need_descriptor, &msg);
  943. if (!node)
  944. continue; /* down, no point */
  945. if (for_directory) {
  946. if (!entry->is_dir_cache)
  947. continue; /* We need a directory and didn't get one. */
  948. }
  949. if (node == chosen_exit)
  950. continue; /* don't pick the same node for entry and exit */
  951. if (consider_exit_family && smartlist_contains(exit_family, node))
  952. continue; /* avoid relays that are family members of our exit */
  953. if (dirinfo_type != NO_DIRINFO &&
  954. !node_can_handle_dirinfo(node, dirinfo_type))
  955. continue; /* this node won't be able to answer our dir questions */
  956. #if 0 /* since EntryNodes is always strict now, this clause is moot */
  957. if (options->EntryNodes &&
  958. !routerset_contains_node(options->EntryNodes, node)) {
  959. /* We've come to the end of our preferred entry nodes. */
  960. if (smartlist_len(live_entry_guards))
  961. goto choose_and_finish; /* only choose from the ones we like */
  962. if (options->StrictNodes) {
  963. /* in theory this case should never happen, since
  964. * entry_guards_set_from_config() drops unwanted relays */
  965. tor_fragile_assert();
  966. } else {
  967. log_info(LD_CIRC,
  968. "No relays from EntryNodes available. Using others.");
  969. }
  970. }
  971. #endif
  972. smartlist_add(live_entry_guards, (void*)node);
  973. if (!entry->made_contact) {
  974. /* Always start with the first not-yet-contacted entry
  975. * guard. Otherwise we might add several new ones, pick
  976. * the second new one, and now we've expanded our entry
  977. * guard list without needing to. */
  978. goto choose_and_finish;
  979. }
  980. if (smartlist_len(live_entry_guards) >= num_needed)
  981. goto choose_and_finish; /* we have enough */
  982. } SMARTLIST_FOREACH_END(entry);
  983. if (entry_list_is_constrained(options)) {
  984. /* If we prefer the entry nodes we've got, and we have at least
  985. * one choice, that's great. Use it. */
  986. preferred_min = 1;
  987. } else {
  988. /* Try to have at least 2 choices available. This way we don't
  989. * get stuck with a single live-but-crummy entry and just keep
  990. * using him.
  991. * (We might get 2 live-but-crummy entry guards, but so be it.) */
  992. preferred_min = 2;
  993. }
  994. if (smartlist_len(live_entry_guards) < preferred_min) {
  995. if (!entry_list_is_constrained(options)) {
  996. /* still no? try adding a new entry then */
  997. /* XXX if guard doesn't imply fast and stable, then we need
  998. * to tell add_an_entry_guard below what we want, or it might
  999. * be a long time til we get it. -RD */
  1000. node = add_an_entry_guard(NULL, 0, 0, 1, for_directory);
  1001. if (node) {
  1002. entry_guards_changed();
  1003. /* XXX we start over here in case the new node we added shares
  1004. * a family with our exit node. There's a chance that we'll just
  1005. * load up on entry guards here, if the network we're using is
  1006. * one big family. Perhaps we should teach add_an_entry_guard()
  1007. * to understand nodes-to-avoid-if-possible? -RD */
  1008. goto retry;
  1009. }
  1010. }
  1011. if (!node && need_uptime) {
  1012. need_uptime = 0; /* try without that requirement */
  1013. goto retry;
  1014. }
  1015. if (!node && need_capacity) {
  1016. /* still no? last attempt, try without requiring capacity */
  1017. need_capacity = 0;
  1018. goto retry;
  1019. }
  1020. #if 0
  1021. /* Removing this retry logic: if we only allow one exit, and it is in the
  1022. same family as all our entries, then we are just plain not going to win
  1023. here. */
  1024. if (!node && entry_list_is_constrained(options) && consider_exit_family) {
  1025. /* still no? if we're using bridges or have strictentrynodes
  1026. * set, and our chosen exit is in the same family as all our
  1027. * bridges/entry guards, then be flexible about families. */
  1028. consider_exit_family = 0;
  1029. goto retry;
  1030. }
  1031. #endif
  1032. /* live_entry_guards may be empty below. Oh well, we tried. */
  1033. }
  1034. choose_and_finish:
  1035. if (entry_list_is_constrained(options)) {
  1036. /* We need to weight by bandwidth, because our bridges or entryguards
  1037. * were not already selected proportional to their bandwidth. */
  1038. node = node_sl_choose_by_bandwidth(live_entry_guards, WEIGHT_FOR_GUARD);
  1039. } else {
  1040. /* We choose uniformly at random here, because choose_good_entry_server()
  1041. * already weights its choices by bandwidth, so we don't want to
  1042. * *double*-weight our guard selection. */
  1043. node = smartlist_choose(live_entry_guards);
  1044. }
  1045. if (n_options_out)
  1046. *n_options_out = smartlist_len(live_entry_guards);
  1047. smartlist_free(live_entry_guards);
  1048. smartlist_free(exit_family);
  1049. return node;
  1050. }
  1051. /** Parse <b>state</b> and learn about the entry guards it describes.
  1052. * If <b>set</b> is true, and there are no errors, replace the global
  1053. * entry_list with what we find.
  1054. * On success, return 0. On failure, alloc into *<b>msg</b> a string
  1055. * describing the error, and return -1.
  1056. */
  1057. int
  1058. entry_guards_parse_state(or_state_t *state, int set, char **msg)
  1059. {
  1060. entry_guard_t *node = NULL;
  1061. smartlist_t *new_entry_guards = smartlist_new();
  1062. config_line_t *line;
  1063. time_t now = time(NULL);
  1064. const char *state_version = state->TorVersion;
  1065. digestmap_t *added_by = digestmap_new();
  1066. *msg = NULL;
  1067. for (line = state->EntryGuards; line; line = line->next) {
  1068. if (!strcasecmp(line->key, "EntryGuard")) {
  1069. smartlist_t *args = smartlist_new();
  1070. node = tor_malloc_zero(sizeof(entry_guard_t));
  1071. /* all entry guards on disk have been contacted */
  1072. node->made_contact = 1;
  1073. smartlist_add(new_entry_guards, node);
  1074. smartlist_split_string(args, line->value, " ",
  1075. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1076. if (smartlist_len(args)<2) {
  1077. *msg = tor_strdup("Unable to parse entry nodes: "
  1078. "Too few arguments to EntryGuard");
  1079. } else if (!is_legal_nickname(smartlist_get(args,0))) {
  1080. *msg = tor_strdup("Unable to parse entry nodes: "
  1081. "Bad nickname for EntryGuard");
  1082. } else {
  1083. strlcpy(node->nickname, smartlist_get(args,0), MAX_NICKNAME_LEN+1);
  1084. if (base16_decode(node->identity, DIGEST_LEN, smartlist_get(args,1),
  1085. strlen(smartlist_get(args,1)))<0) {
  1086. *msg = tor_strdup("Unable to parse entry nodes: "
  1087. "Bad hex digest for EntryGuard");
  1088. }
  1089. }
  1090. if (smartlist_len(args) >= 3) {
  1091. const char *is_cache = smartlist_get(args, 2);
  1092. if (!strcasecmp(is_cache, "DirCache")) {
  1093. node->is_dir_cache = 1;
  1094. } else if (!strcasecmp(is_cache, "NoDirCache")) {
  1095. node->is_dir_cache = 0;
  1096. } else {
  1097. log_warn(LD_CONFIG, "Bogus third argument to EntryGuard line: %s",
  1098. escaped(is_cache));
  1099. }
  1100. }
  1101. SMARTLIST_FOREACH(args, char*, cp, tor_free(cp));
  1102. smartlist_free(args);
  1103. if (*msg)
  1104. break;
  1105. } else if (!strcasecmp(line->key, "EntryGuardDownSince") ||
  1106. !strcasecmp(line->key, "EntryGuardUnlistedSince")) {
  1107. time_t when;
  1108. time_t last_try = 0;
  1109. if (!node) {
  1110. *msg = tor_strdup("Unable to parse entry nodes: "
  1111. "EntryGuardDownSince/UnlistedSince without EntryGuard");
  1112. break;
  1113. }
  1114. if (parse_iso_time(line->value, &when)<0) {
  1115. *msg = tor_strdup("Unable to parse entry nodes: "
  1116. "Bad time in EntryGuardDownSince/UnlistedSince");
  1117. break;
  1118. }
  1119. if (when > now) {
  1120. /* It's a bad idea to believe info in the future: you can wind
  1121. * up with timeouts that aren't allowed to happen for years. */
  1122. continue;
  1123. }
  1124. if (strlen(line->value) >= ISO_TIME_LEN+ISO_TIME_LEN+1) {
  1125. /* ignore failure */
  1126. (void) parse_iso_time(line->value+ISO_TIME_LEN+1, &last_try);
  1127. }
  1128. if (!strcasecmp(line->key, "EntryGuardDownSince")) {
  1129. node->unreachable_since = when;
  1130. node->last_attempted = last_try;
  1131. } else {
  1132. node->bad_since = when;
  1133. }
  1134. } else if (!strcasecmp(line->key, "EntryGuardAddedBy")) {
  1135. char d[DIGEST_LEN];
  1136. /* format is digest version date */
  1137. if (strlen(line->value) < HEX_DIGEST_LEN+1+1+1+ISO_TIME_LEN) {
  1138. log_warn(LD_BUG, "EntryGuardAddedBy line is not long enough.");
  1139. continue;
  1140. }
  1141. if (base16_decode(d, sizeof(d), line->value, HEX_DIGEST_LEN)<0 ||
  1142. line->value[HEX_DIGEST_LEN] != ' ') {
  1143. log_warn(LD_BUG, "EntryGuardAddedBy line %s does not begin with "
  1144. "hex digest", escaped(line->value));
  1145. continue;
  1146. }
  1147. digestmap_set(added_by, d, tor_strdup(line->value+HEX_DIGEST_LEN+1));
  1148. } else if (!strcasecmp(line->key, "EntryGuardPathUseBias")) {
  1149. const or_options_t *options = get_options();
  1150. double use_cnt, success_cnt;
  1151. if (!node) {
  1152. *msg = tor_strdup("Unable to parse entry nodes: "
  1153. "EntryGuardPathUseBias without EntryGuard");
  1154. break;
  1155. }
  1156. if (tor_sscanf(line->value, "%lf %lf",
  1157. &use_cnt, &success_cnt) != 2) {
  1158. log_info(LD_GENERAL, "Malformed path use bias line for node %s",
  1159. node->nickname);
  1160. continue;
  1161. }
  1162. if (use_cnt < success_cnt) {
  1163. int severity = LOG_INFO;
  1164. /* If this state file was written by a Tor that would have
  1165. * already fixed it, then the overcounting bug is still there.. */
  1166. if (tor_version_as_new_as(state_version, "0.2.4.13-alpha")) {
  1167. severity = LOG_NOTICE;
  1168. }
  1169. log_fn(severity, LD_BUG,
  1170. "State file contains unexpectedly high usage success "
  1171. "counts %lf/%lf for Guard %s ($%s)",
  1172. success_cnt, use_cnt,
  1173. node->nickname, hex_str(node->identity, DIGEST_LEN));
  1174. success_cnt = use_cnt;
  1175. }
  1176. node->use_attempts = use_cnt;
  1177. node->use_successes = success_cnt;
  1178. log_info(LD_GENERAL, "Read %f/%f path use bias for node %s",
  1179. node->use_successes, node->use_attempts, node->nickname);
  1180. /* Note: We rely on the < comparison here to allow us to set a 0
  1181. * rate and disable the feature entirely. If refactoring, don't
  1182. * change to <= */
  1183. if (pathbias_get_use_success_count(node)/node->use_attempts
  1184. < pathbias_get_extreme_use_rate(options) &&
  1185. pathbias_get_dropguards(options)) {
  1186. node->path_bias_disabled = 1;
  1187. log_info(LD_GENERAL,
  1188. "Path use bias is too high (%f/%f); disabling node %s",
  1189. node->circ_successes, node->circ_attempts, node->nickname);
  1190. }
  1191. } else if (!strcasecmp(line->key, "EntryGuardPathBias")) {
  1192. const or_options_t *options = get_options();
  1193. double hop_cnt, success_cnt, timeouts, collapsed, successful_closed,
  1194. unusable;
  1195. if (!node) {
  1196. *msg = tor_strdup("Unable to parse entry nodes: "
  1197. "EntryGuardPathBias without EntryGuard");
  1198. break;
  1199. }
  1200. /* First try 3 params, then 2. */
  1201. /* In the long run: circuit_success ~= successful_circuit_close +
  1202. * collapsed_circuits +
  1203. * unusable_circuits */
  1204. if (tor_sscanf(line->value, "%lf %lf %lf %lf %lf %lf",
  1205. &hop_cnt, &success_cnt, &successful_closed,
  1206. &collapsed, &unusable, &timeouts) != 6) {
  1207. int old_success, old_hops;
  1208. if (tor_sscanf(line->value, "%u %u", &old_success, &old_hops) != 2) {
  1209. continue;
  1210. }
  1211. log_info(LD_GENERAL, "Reading old-style EntryGuardPathBias %s",
  1212. escaped(line->value));
  1213. success_cnt = old_success;
  1214. successful_closed = old_success;
  1215. hop_cnt = old_hops;
  1216. timeouts = 0;
  1217. collapsed = 0;
  1218. unusable = 0;
  1219. }
  1220. if (hop_cnt < success_cnt) {
  1221. int severity = LOG_INFO;
  1222. /* If this state file was written by a Tor that would have
  1223. * already fixed it, then the overcounting bug is still there.. */
  1224. if (tor_version_as_new_as(state_version, "0.2.4.13-alpha")) {
  1225. severity = LOG_NOTICE;
  1226. }
  1227. log_fn(severity, LD_BUG,
  1228. "State file contains unexpectedly high success counts "
  1229. "%lf/%lf for Guard %s ($%s)",
  1230. success_cnt, hop_cnt,
  1231. node->nickname, hex_str(node->identity, DIGEST_LEN));
  1232. success_cnt = hop_cnt;
  1233. }
  1234. node->circ_attempts = hop_cnt;
  1235. node->circ_successes = success_cnt;
  1236. node->successful_circuits_closed = successful_closed;
  1237. node->timeouts = timeouts;
  1238. node->collapsed_circuits = collapsed;
  1239. node->unusable_circuits = unusable;
  1240. log_info(LD_GENERAL, "Read %f/%f path bias for node %s",
  1241. node->circ_successes, node->circ_attempts, node->nickname);
  1242. /* Note: We rely on the < comparison here to allow us to set a 0
  1243. * rate and disable the feature entirely. If refactoring, don't
  1244. * change to <= */
  1245. if (pathbias_get_close_success_count(node)/node->circ_attempts
  1246. < pathbias_get_extreme_rate(options) &&
  1247. pathbias_get_dropguards(options)) {
  1248. node->path_bias_disabled = 1;
  1249. log_info(LD_GENERAL,
  1250. "Path bias is too high (%f/%f); disabling node %s",
  1251. node->circ_successes, node->circ_attempts, node->nickname);
  1252. }
  1253. } else {
  1254. log_warn(LD_BUG, "Unexpected key %s", line->key);
  1255. }
  1256. }
  1257. SMARTLIST_FOREACH_BEGIN(new_entry_guards, entry_guard_t *, e) {
  1258. char *sp;
  1259. char *val = digestmap_get(added_by, e->identity);
  1260. if (val && (sp = strchr(val, ' '))) {
  1261. time_t when;
  1262. *sp++ = '\0';
  1263. if (parse_iso_time(sp, &when)<0) {
  1264. log_warn(LD_BUG, "Can't read time %s in EntryGuardAddedBy", sp);
  1265. } else {
  1266. e->chosen_by_version = tor_strdup(val);
  1267. e->chosen_on_date = when;
  1268. }
  1269. } else {
  1270. if (state_version) {
  1271. e->chosen_by_version = tor_strdup(state_version);
  1272. e->chosen_on_date = time(NULL) - crypto_rand_int(3600*24*30);
  1273. }
  1274. }
  1275. if (e->path_bias_disabled && !e->bad_since)
  1276. e->bad_since = time(NULL);
  1277. }
  1278. SMARTLIST_FOREACH_END(e);
  1279. if (*msg || !set) {
  1280. SMARTLIST_FOREACH(new_entry_guards, entry_guard_t *, e,
  1281. entry_guard_free(e));
  1282. smartlist_free(new_entry_guards);
  1283. } else { /* !err && set */
  1284. if (entry_guards) {
  1285. SMARTLIST_FOREACH(entry_guards, entry_guard_t *, e,
  1286. entry_guard_free(e));
  1287. smartlist_free(entry_guards);
  1288. }
  1289. entry_guards = new_entry_guards;
  1290. entry_guards_dirty = 0;
  1291. /* XXX024 hand new_entry_guards to this func, and move it up a
  1292. * few lines, so we don't have to re-dirty it */
  1293. if (remove_obsolete_entry_guards(now))
  1294. entry_guards_dirty = 1;
  1295. update_node_guard_status();
  1296. }
  1297. digestmap_free(added_by, tor_free_);
  1298. return *msg ? -1 : 0;
  1299. }
  1300. /** Our list of entry guards has changed, or some element of one
  1301. * of our entry guards has changed. Write the changes to disk within
  1302. * the next few minutes.
  1303. */
  1304. void
  1305. entry_guards_changed(void)
  1306. {
  1307. time_t when;
  1308. entry_guards_dirty = 1;
  1309. /* or_state_save() will call entry_guards_update_state(). */
  1310. when = get_options()->AvoidDiskWrites ? time(NULL) + 3600 : time(NULL)+600;
  1311. or_state_mark_dirty(get_or_state(), when);
  1312. }
  1313. /** If the entry guard info has not changed, do nothing and return.
  1314. * Otherwise, free the EntryGuards piece of <b>state</b> and create
  1315. * a new one out of the global entry_guards list, and then mark
  1316. * <b>state</b> dirty so it will get saved to disk.
  1317. */
  1318. void
  1319. entry_guards_update_state(or_state_t *state)
  1320. {
  1321. config_line_t **next, *line;
  1322. if (! entry_guards_dirty)
  1323. return;
  1324. config_free_lines(state->EntryGuards);
  1325. next = &state->EntryGuards;
  1326. *next = NULL;
  1327. if (!entry_guards)
  1328. entry_guards = smartlist_new();
  1329. SMARTLIST_FOREACH_BEGIN(entry_guards, entry_guard_t *, e) {
  1330. char dbuf[HEX_DIGEST_LEN+1];
  1331. if (!e->made_contact)
  1332. continue; /* don't write this one to disk */
  1333. *next = line = tor_malloc_zero(sizeof(config_line_t));
  1334. line->key = tor_strdup("EntryGuard");
  1335. base16_encode(dbuf, sizeof(dbuf), e->identity, DIGEST_LEN);
  1336. tor_asprintf(&line->value, "%s %s %sDirCache", e->nickname, dbuf,
  1337. e->is_dir_cache ? "" : "No");
  1338. next = &(line->next);
  1339. if (e->unreachable_since) {
  1340. *next = line = tor_malloc_zero(sizeof(config_line_t));
  1341. line->key = tor_strdup("EntryGuardDownSince");
  1342. line->value = tor_malloc(ISO_TIME_LEN+1+ISO_TIME_LEN+1);
  1343. format_iso_time(line->value, e->unreachable_since);
  1344. if (e->last_attempted) {
  1345. line->value[ISO_TIME_LEN] = ' ';
  1346. format_iso_time(line->value+ISO_TIME_LEN+1, e->last_attempted);
  1347. }
  1348. next = &(line->next);
  1349. }
  1350. if (e->bad_since) {
  1351. *next = line = tor_malloc_zero(sizeof(config_line_t));
  1352. line->key = tor_strdup("EntryGuardUnlistedSince");
  1353. line->value = tor_malloc(ISO_TIME_LEN+1);
  1354. format_iso_time(line->value, e->bad_since);
  1355. next = &(line->next);
  1356. }
  1357. if (e->chosen_on_date && e->chosen_by_version &&
  1358. !strchr(e->chosen_by_version, ' ')) {
  1359. char d[HEX_DIGEST_LEN+1];
  1360. char t[ISO_TIME_LEN+1];
  1361. *next = line = tor_malloc_zero(sizeof(config_line_t));
  1362. line->key = tor_strdup("EntryGuardAddedBy");
  1363. base16_encode(d, sizeof(d), e->identity, DIGEST_LEN);
  1364. format_iso_time(t, e->chosen_on_date);
  1365. tor_asprintf(&line->value, "%s %s %s",
  1366. d, e->chosen_by_version, t);
  1367. next = &(line->next);
  1368. }
  1369. if (e->circ_attempts > 0) {
  1370. *next = line = tor_malloc_zero(sizeof(config_line_t));
  1371. line->key = tor_strdup("EntryGuardPathBias");
  1372. /* In the long run: circuit_success ~= successful_circuit_close +
  1373. * collapsed_circuits +
  1374. * unusable_circuits */
  1375. tor_asprintf(&line->value, "%f %f %f %f %f %f",
  1376. e->circ_attempts, e->circ_successes,
  1377. pathbias_get_close_success_count(e),
  1378. e->collapsed_circuits,
  1379. e->unusable_circuits, e->timeouts);
  1380. next = &(line->next);
  1381. }
  1382. if (e->use_attempts > 0) {
  1383. *next = line = tor_malloc_zero(sizeof(config_line_t));
  1384. line->key = tor_strdup("EntryGuardPathUseBias");
  1385. tor_asprintf(&line->value, "%f %f",
  1386. e->use_attempts,
  1387. pathbias_get_use_success_count(e));
  1388. next = &(line->next);
  1389. }
  1390. } SMARTLIST_FOREACH_END(e);
  1391. if (!get_options()->AvoidDiskWrites)
  1392. or_state_mark_dirty(get_or_state(), 0);
  1393. entry_guards_dirty = 0;
  1394. }
  1395. /** If <b>question</b> is the string "entry-guards", then dump
  1396. * to *<b>answer</b> a newly allocated string describing all of
  1397. * the nodes in the global entry_guards list. See control-spec.txt
  1398. * for details.
  1399. * For backward compatibility, we also handle the string "helper-nodes".
  1400. * */
  1401. int
  1402. getinfo_helper_entry_guards(control_connection_t *conn,
  1403. const char *question, char **answer,
  1404. const char **errmsg)
  1405. {
  1406. (void) conn;
  1407. (void) errmsg;
  1408. if (!strcmp(question,"entry-guards") ||
  1409. !strcmp(question,"helper-nodes")) {
  1410. smartlist_t *sl = smartlist_new();
  1411. char tbuf[ISO_TIME_LEN+1];
  1412. char nbuf[MAX_VERBOSE_NICKNAME_LEN+1];
  1413. if (!entry_guards)
  1414. entry_guards = smartlist_new();
  1415. SMARTLIST_FOREACH_BEGIN(entry_guards, entry_guard_t *, e) {
  1416. const char *status = NULL;
  1417. time_t when = 0;
  1418. const node_t *node;
  1419. if (!e->made_contact) {
  1420. status = "never-connected";
  1421. } else if (e->bad_since) {
  1422. when = e->bad_since;
  1423. status = "unusable";
  1424. } else {
  1425. status = "up";
  1426. }
  1427. node = node_get_by_id(e->identity);
  1428. if (node) {
  1429. node_get_verbose_nickname(node, nbuf);
  1430. } else {
  1431. nbuf[0] = '$';
  1432. base16_encode(nbuf+1, sizeof(nbuf)-1, e->identity, DIGEST_LEN);
  1433. /* e->nickname field is not very reliable if we don't know about
  1434. * this router any longer; don't include it. */
  1435. }
  1436. if (when) {
  1437. format_iso_time(tbuf, when);
  1438. smartlist_add_asprintf(sl, "%s %s %s\n", nbuf, status, tbuf);
  1439. } else {
  1440. smartlist_add_asprintf(sl, "%s %s\n", nbuf, status);
  1441. }
  1442. } SMARTLIST_FOREACH_END(e);
  1443. *answer = smartlist_join_strings(sl, "", 0, NULL);
  1444. SMARTLIST_FOREACH(sl, char *, c, tor_free(c));
  1445. smartlist_free(sl);
  1446. }
  1447. return 0;
  1448. }
  1449. /** A list of configured bridges. Whenever we actually get a descriptor
  1450. * for one, we add it as an entry guard. Note that the order of bridges
  1451. * in this list does not necessarily correspond to the order of bridges
  1452. * in the torrc. */
  1453. static smartlist_t *bridge_list = NULL;
  1454. /** Mark every entry of the bridge list to be removed on our next call to
  1455. * sweep_bridge_list unless it has first been un-marked. */
  1456. void
  1457. mark_bridge_list(void)
  1458. {
  1459. if (!bridge_list)
  1460. bridge_list = smartlist_new();
  1461. SMARTLIST_FOREACH(bridge_list, bridge_info_t *, b,
  1462. b->marked_for_removal = 1);
  1463. }
  1464. /** Remove every entry of the bridge list that was marked with
  1465. * mark_bridge_list if it has not subsequently been un-marked. */
  1466. void
  1467. sweep_bridge_list(void)
  1468. {
  1469. if (!bridge_list)
  1470. bridge_list = smartlist_new();
  1471. SMARTLIST_FOREACH_BEGIN(bridge_list, bridge_info_t *, b) {
  1472. if (b->marked_for_removal) {
  1473. SMARTLIST_DEL_CURRENT(bridge_list, b);
  1474. bridge_free(b);
  1475. }
  1476. } SMARTLIST_FOREACH_END(b);
  1477. }
  1478. /** Initialize the bridge list to empty, creating it if needed. */
  1479. static void
  1480. clear_bridge_list(void)
  1481. {
  1482. if (!bridge_list)
  1483. bridge_list = smartlist_new();
  1484. SMARTLIST_FOREACH(bridge_list, bridge_info_t *, b, bridge_free(b));
  1485. smartlist_clear(bridge_list);
  1486. }
  1487. /** Free the bridge <b>bridge</b>. */
  1488. static void
  1489. bridge_free(bridge_info_t *bridge)
  1490. {
  1491. if (!bridge)
  1492. return;
  1493. tor_free(bridge->transport_name);
  1494. if (bridge->socks_args) {
  1495. SMARTLIST_FOREACH(bridge->socks_args, char*, s, tor_free(s));
  1496. smartlist_free(bridge->socks_args);
  1497. }
  1498. tor_free(bridge);
  1499. }
  1500. /** If we have a bridge configured whose digest matches <b>digest</b>, or a
  1501. * bridge with no known digest whose address matches any of the
  1502. * tor_addr_port_t's in <b>orports</b>, return that bridge. Else return
  1503. * NULL. */
  1504. static bridge_info_t *
  1505. get_configured_bridge_by_orports_digest(const char *digest,
  1506. const smartlist_t *orports)
  1507. {
  1508. if (!bridge_list)
  1509. return NULL;
  1510. SMARTLIST_FOREACH_BEGIN(bridge_list, bridge_info_t *, bridge)
  1511. {
  1512. if (tor_digest_is_zero(bridge->identity)) {
  1513. SMARTLIST_FOREACH_BEGIN(orports, tor_addr_port_t *, ap)
  1514. {
  1515. if (tor_addr_compare(&bridge->addr, &ap->addr, CMP_EXACT) == 0 &&
  1516. bridge->port == ap->port)
  1517. return bridge;
  1518. }
  1519. SMARTLIST_FOREACH_END(ap);
  1520. }
  1521. if (digest && tor_memeq(bridge->identity, digest, DIGEST_LEN))
  1522. return bridge;
  1523. }
  1524. SMARTLIST_FOREACH_END(bridge);
  1525. return NULL;
  1526. }
  1527. /** If we have a bridge configured whose digest matches <b>digest</b>, or a
  1528. * bridge with no known digest whose address matches <b>addr</b>:<b>/port</b>,
  1529. * return that bridge. Else return NULL. If <b>digest</b> is NULL, check for
  1530. * address/port matches only. */
  1531. static bridge_info_t *
  1532. get_configured_bridge_by_addr_port_digest(const tor_addr_t *addr,
  1533. uint16_t port,
  1534. const char *digest)
  1535. {
  1536. if (!bridge_list)
  1537. return NULL;
  1538. SMARTLIST_FOREACH_BEGIN(bridge_list, bridge_info_t *, bridge)
  1539. {
  1540. if ((tor_digest_is_zero(bridge->identity) || digest == NULL) &&
  1541. !tor_addr_compare(&bridge->addr, addr, CMP_EXACT) &&
  1542. bridge->port == port)
  1543. return bridge;
  1544. if (digest && tor_memeq(bridge->identity, digest, DIGEST_LEN))
  1545. return bridge;
  1546. }
  1547. SMARTLIST_FOREACH_END(bridge);
  1548. return NULL;
  1549. }
  1550. /** Wrapper around get_configured_bridge_by_addr_port_digest() to look
  1551. * it up via router descriptor <b>ri</b>. */
  1552. static bridge_info_t *
  1553. get_configured_bridge_by_routerinfo(const routerinfo_t *ri)
  1554. {
  1555. bridge_info_t *bi = NULL;
  1556. smartlist_t *orports = router_get_all_orports(ri);
  1557. bi = get_configured_bridge_by_orports_digest(ri->cache_info.identity_digest,
  1558. orports);
  1559. SMARTLIST_FOREACH(orports, tor_addr_port_t *, p, tor_free(p));
  1560. smartlist_free(orports);
  1561. return bi;
  1562. }
  1563. /** Return 1 if <b>ri</b> is one of our known bridges, else 0. */
  1564. int
  1565. routerinfo_is_a_configured_bridge(const routerinfo_t *ri)
  1566. {
  1567. return get_configured_bridge_by_routerinfo(ri) ? 1 : 0;
  1568. }
  1569. /** Return 1 if <b>node</b> is one of our configured bridges, else 0. */
  1570. int
  1571. node_is_a_configured_bridge(const node_t *node)
  1572. {
  1573. int retval = 0;
  1574. smartlist_t *orports = node_get_all_orports(node);
  1575. retval = get_configured_bridge_by_orports_digest(node->identity,
  1576. orports) != NULL;
  1577. SMARTLIST_FOREACH(orports, tor_addr_port_t *, p, tor_free(p));
  1578. smartlist_free(orports);
  1579. return retval;
  1580. }
  1581. /** We made a connection to a router at <b>addr</b>:<b>port</b>
  1582. * without knowing its digest. Its digest turned out to be <b>digest</b>.
  1583. * If it was a bridge, and we still don't know its digest, record it.
  1584. */
  1585. void
  1586. learned_router_identity(const tor_addr_t *addr, uint16_t port,
  1587. const char *digest)
  1588. {
  1589. bridge_info_t *bridge =
  1590. get_configured_bridge_by_addr_port_digest(addr, port, digest);
  1591. if (bridge && tor_digest_is_zero(bridge->identity)) {
  1592. char *transport_info = NULL;
  1593. const char *transport_name =
  1594. find_transport_name_by_bridge_addrport(addr, port);
  1595. if (transport_name)
  1596. tor_asprintf(&transport_info, " (with transport '%s')", transport_name);
  1597. memcpy(bridge->identity, digest, DIGEST_LEN);
  1598. log_notice(LD_DIR, "Learned fingerprint %s for bridge %s%s.",
  1599. hex_str(digest, DIGEST_LEN), fmt_addrport(addr, port),
  1600. transport_info ? transport_info : "");
  1601. tor_free(transport_info);
  1602. }
  1603. }
  1604. /** Return true if <b>bridge</b> has the same identity digest as
  1605. * <b>digest</b>. If <b>digest</b> is NULL, it matches
  1606. * bridges with unspecified identity digests. */
  1607. static int
  1608. bridge_has_digest(const bridge_info_t *bridge, const char *digest)
  1609. {
  1610. if (digest)
  1611. return tor_memeq(digest, bridge->identity, DIGEST_LEN);
  1612. else
  1613. return tor_digest_is_zero(bridge->identity);
  1614. }
  1615. /** We are about to add a new bridge at <b>addr</b>:<b>port</b>, with optional
  1616. * <b>digest</b> and <b>transport_name</b>. Mark for removal any previously
  1617. * existing bridge with the same address and port, and warn the user as
  1618. * appropriate.
  1619. */
  1620. static void
  1621. bridge_resolve_conflicts(const tor_addr_t *addr, uint16_t port,
  1622. const char *digest, const char *transport_name)
  1623. {
  1624. /* Iterate the already-registered bridge list:
  1625. If you find a bridge with the same adress and port, mark it for
  1626. removal. It doesn't make sense to have two active bridges with
  1627. the same IP:PORT. If the bridge in question has a different
  1628. digest or transport than <b>digest</b>/<b>transport_name</b>,
  1629. it's probably a misconfiguration and we should warn the user.
  1630. */
  1631. SMARTLIST_FOREACH_BEGIN(bridge_list, bridge_info_t *, bridge) {
  1632. if (bridge->marked_for_removal)
  1633. continue;
  1634. if (tor_addr_eq(&bridge->addr, addr) && (bridge->port == port)) {
  1635. bridge->marked_for_removal = 1;
  1636. if (!bridge_has_digest(bridge, digest) ||
  1637. strcmp_opt(bridge->transport_name, transport_name)) {
  1638. /* warn the user */
  1639. char *bridge_description_new, *bridge_description_old;
  1640. tor_asprintf(&bridge_description_new, "%s:%s:%s",
  1641. fmt_addrport(addr, port),
  1642. digest ? hex_str(digest, DIGEST_LEN) : "",
  1643. transport_name ? transport_name : "");
  1644. tor_asprintf(&bridge_description_old, "%s:%s:%s",
  1645. fmt_addrport(&bridge->addr, bridge->port),
  1646. tor_digest_is_zero(bridge->identity) ?
  1647. "" : hex_str(bridge->identity,DIGEST_LEN),
  1648. bridge->transport_name ? bridge->transport_name : "");
  1649. log_warn(LD_GENERAL,"Tried to add bridge '%s', but we found a conflict"
  1650. " with the already registered bridge '%s'. We will discard"
  1651. " the old bridge and keep '%s'. If this is not what you"
  1652. " wanted, please change your configuration file accordingly.",
  1653. bridge_description_new, bridge_description_old,
  1654. bridge_description_new);
  1655. tor_free(bridge_description_new);
  1656. tor_free(bridge_description_old);
  1657. }
  1658. }
  1659. } SMARTLIST_FOREACH_END(bridge);
  1660. }
  1661. /** Return True if we have a bridge that uses a transport with name
  1662. * <b>transport_name</b>. */
  1663. int
  1664. transport_is_needed(const char *transport_name)
  1665. {
  1666. if (!bridge_list)
  1667. return 0;
  1668. SMARTLIST_FOREACH_BEGIN(bridge_list, const bridge_info_t *, bridge) {
  1669. if (bridge->transport_name &&
  1670. !strcmp(bridge->transport_name, transport_name))
  1671. return 1;
  1672. } SMARTLIST_FOREACH_END(bridge);
  1673. return 0;
  1674. }
  1675. /** Register the bridge information in <b>bridge_line</b> to the
  1676. * bridge subsystem. Steals reference of <b>bridge_line</b>. */
  1677. void
  1678. bridge_add_from_config(bridge_line_t *bridge_line)
  1679. {
  1680. bridge_info_t *b;
  1681. { /* Log the bridge we are about to register: */
  1682. log_debug(LD_GENERAL, "Registering bridge at %s (transport: %s) (%s)",
  1683. fmt_addrport(&bridge_line->addr, bridge_line->port),
  1684. bridge_line->transport_name ?
  1685. bridge_line->transport_name : "no transport",
  1686. tor_digest_is_zero(bridge_line->digest) ?
  1687. "no key listed" : hex_str(bridge_line->digest, DIGEST_LEN));
  1688. if (bridge_line->socks_args) { /* print socks arguments */
  1689. int i = 0;
  1690. tor_assert(smartlist_len(bridge_line->socks_args) > 0);
  1691. log_debug(LD_GENERAL, "Bridge uses %d SOCKS arguments:",
  1692. smartlist_len(bridge_line->socks_args));
  1693. SMARTLIST_FOREACH(bridge_line->socks_args, const char *, arg,
  1694. log_debug(LD_CONFIG, "%d: %s", ++i, arg));
  1695. }
  1696. }
  1697. bridge_resolve_conflicts(&bridge_line->addr,
  1698. bridge_line->port,
  1699. bridge_line->digest,
  1700. bridge_line->transport_name);
  1701. b = tor_malloc_zero(sizeof(bridge_info_t));
  1702. tor_addr_copy(&b->addr, &bridge_line->addr);
  1703. b->port = bridge_line->port;
  1704. memcpy(b->identity, bridge_line->digest, DIGEST_LEN);
  1705. if (bridge_line->transport_name)
  1706. b->transport_name = bridge_line->transport_name;
  1707. b->fetch_status.schedule = DL_SCHED_BRIDGE;
  1708. b->socks_args = bridge_line->socks_args;
  1709. if (!bridge_list)
  1710. bridge_list = smartlist_new();
  1711. tor_free(bridge_line); /* Deallocate bridge_line now. */
  1712. smartlist_add(bridge_list, b);
  1713. }
  1714. /** Return true iff <b>routerset</b> contains the bridge <b>bridge</b>. */
  1715. static int
  1716. routerset_contains_bridge(const routerset_t *routerset,
  1717. const bridge_info_t *bridge)
  1718. {
  1719. int result;
  1720. extend_info_t *extinfo;
  1721. tor_assert(bridge);
  1722. if (!routerset)
  1723. return 0;
  1724. extinfo = extend_info_new(
  1725. NULL, bridge->identity, NULL, NULL, &bridge->addr, bridge->port);
  1726. result = routerset_contains_extendinfo(routerset, extinfo);
  1727. extend_info_free(extinfo);
  1728. return result;
  1729. }
  1730. /** If <b>digest</b> is one of our known bridges, return it. */
  1731. static bridge_info_t *
  1732. find_bridge_by_digest(const char *digest)
  1733. {
  1734. SMARTLIST_FOREACH(bridge_list, bridge_info_t *, bridge,
  1735. {
  1736. if (tor_memeq(bridge->identity, digest, DIGEST_LEN))
  1737. return bridge;
  1738. });
  1739. return NULL;
  1740. }
  1741. /** Given the <b>addr</b> and <b>port</b> of a bridge, if that bridge
  1742. * supports a pluggable transport, return its name. Otherwise, return
  1743. * NULL. */
  1744. const char *
  1745. find_transport_name_by_bridge_addrport(const tor_addr_t *addr, uint16_t port)
  1746. {
  1747. if (!bridge_list)
  1748. return NULL;
  1749. SMARTLIST_FOREACH_BEGIN(bridge_list, const bridge_info_t *, bridge) {
  1750. if (tor_addr_eq(&bridge->addr, addr) &&
  1751. (bridge->port == port))
  1752. return bridge->transport_name;
  1753. } SMARTLIST_FOREACH_END(bridge);
  1754. return NULL;
  1755. }
  1756. /** If <b>addr</b> and <b>port</b> match the address and port of a
  1757. * bridge of ours that uses pluggable transports, place its transport
  1758. * in <b>transport</b>.
  1759. *
  1760. * Return 0 on success (found a transport, or found a bridge with no
  1761. * transport, or found no bridge); return -1 if we should be using a
  1762. * transport, but the transport could not be found.
  1763. */
  1764. int
  1765. get_transport_by_bridge_addrport(const tor_addr_t *addr, uint16_t port,
  1766. const transport_t **transport)
  1767. {
  1768. *transport = NULL;
  1769. if (!bridge_list)
  1770. return 0;
  1771. SMARTLIST_FOREACH_BEGIN(bridge_list, const bridge_info_t *, bridge) {
  1772. if (tor_addr_eq(&bridge->addr, addr) &&
  1773. (bridge->port == port)) { /* bridge matched */
  1774. if (bridge->transport_name) { /* it also uses pluggable transports */
  1775. *transport = transport_get_by_name(bridge->transport_name);
  1776. if (*transport == NULL) { /* it uses pluggable transports, but
  1777. the transport could not be found! */
  1778. return -1;
  1779. }
  1780. return 0;
  1781. } else { /* bridge matched, but it doesn't use transports. */
  1782. break;
  1783. }
  1784. }
  1785. } SMARTLIST_FOREACH_END(bridge);
  1786. *transport = NULL;
  1787. return 0;
  1788. }
  1789. /** Return a smartlist containing all the SOCKS arguments that we
  1790. * should pass to the SOCKS proxy. */
  1791. const smartlist_t *
  1792. get_socks_args_by_bridge_addrport(const tor_addr_t *addr, uint16_t port)
  1793. {
  1794. bridge_info_t *bridge = get_configured_bridge_by_addr_port_digest(addr,
  1795. port,
  1796. NULL);
  1797. return bridge ? bridge->socks_args : NULL;
  1798. }
  1799. /** We need to ask <b>bridge</b> for its server descriptor. */
  1800. static void
  1801. launch_direct_bridge_descriptor_fetch(bridge_info_t *bridge)
  1802. {
  1803. const or_options_t *options = get_options();
  1804. if (connection_get_by_type_addr_port_purpose(
  1805. CONN_TYPE_DIR, &bridge->addr, bridge->port,
  1806. DIR_PURPOSE_FETCH_SERVERDESC))
  1807. return; /* it's already on the way */
  1808. if (routerset_contains_bridge(options->ExcludeNodes, bridge)) {
  1809. download_status_mark_impossible(&bridge->fetch_status);
  1810. log_warn(LD_APP, "Not using bridge at %s: it is in ExcludeNodes.",
  1811. safe_str_client(fmt_and_decorate_addr(&bridge->addr)));
  1812. return;
  1813. }
  1814. directory_initiate_command(&bridge->addr,
  1815. bridge->port, 0/*no dirport*/,
  1816. bridge->identity,
  1817. DIR_PURPOSE_FETCH_SERVERDESC,
  1818. ROUTER_PURPOSE_BRIDGE,
  1819. DIRIND_ONEHOP, "authority.z", NULL, 0, 0);
  1820. }
  1821. /** Fetching the bridge descriptor from the bridge authority returned a
  1822. * "not found". Fall back to trying a direct fetch. */
  1823. void
  1824. retry_bridge_descriptor_fetch_directly(const char *digest)
  1825. {
  1826. bridge_info_t *bridge = find_bridge_by_digest(digest);
  1827. if (!bridge)
  1828. return; /* not found? oh well. */
  1829. launch_direct_bridge_descriptor_fetch(bridge);
  1830. }
  1831. /** For each bridge in our list for which we don't currently have a
  1832. * descriptor, fetch a new copy of its descriptor -- either directly
  1833. * from the bridge or via a bridge authority. */
  1834. void
  1835. fetch_bridge_descriptors(const or_options_t *options, time_t now)
  1836. {
  1837. int num_bridge_auths = get_n_authorities(BRIDGE_DIRINFO);
  1838. int ask_bridge_directly;
  1839. int can_use_bridge_authority;
  1840. if (!bridge_list)
  1841. return;
  1842. /* If we still have unconfigured managed proxies, don't go and
  1843. connect to a bridge. */
  1844. if (pt_proxies_configuration_pending())
  1845. return;
  1846. SMARTLIST_FOREACH_BEGIN(bridge_list, bridge_info_t *, bridge)
  1847. {
  1848. if (!download_status_is_ready(&bridge->fetch_status, now,
  1849. IMPOSSIBLE_TO_DOWNLOAD))
  1850. continue; /* don't bother, no need to retry yet */
  1851. if (routerset_contains_bridge(options->ExcludeNodes, bridge)) {
  1852. download_status_mark_impossible(&bridge->fetch_status);
  1853. log_warn(LD_APP, "Not using bridge at %s: it is in ExcludeNodes.",
  1854. safe_str_client(fmt_and_decorate_addr(&bridge->addr)));
  1855. continue;
  1856. }
  1857. /* schedule another fetch as if this one will fail, in case it does */
  1858. download_status_failed(&bridge->fetch_status, 0);
  1859. can_use_bridge_authority = !tor_digest_is_zero(bridge->identity) &&
  1860. num_bridge_auths;
  1861. ask_bridge_directly = !can_use_bridge_authority ||
  1862. !options->UpdateBridgesFromAuthority;
  1863. log_debug(LD_DIR, "ask_bridge_directly=%d (%d, %d, %d)",
  1864. ask_bridge_directly, tor_digest_is_zero(bridge->identity),
  1865. !options->UpdateBridgesFromAuthority, !num_bridge_auths);
  1866. if (ask_bridge_directly &&
  1867. !fascist_firewall_allows_address_or(&bridge->addr, bridge->port)) {
  1868. log_notice(LD_DIR, "Bridge at '%s' isn't reachable by our "
  1869. "firewall policy. %s.",
  1870. fmt_addrport(&bridge->addr, bridge->port),
  1871. can_use_bridge_authority ?
  1872. "Asking bridge authority instead" : "Skipping");
  1873. if (can_use_bridge_authority)
  1874. ask_bridge_directly = 0;
  1875. else
  1876. continue;
  1877. }
  1878. if (ask_bridge_directly) {
  1879. /* we need to ask the bridge itself for its descriptor. */
  1880. launch_direct_bridge_descriptor_fetch(bridge);
  1881. } else {
  1882. /* We have a digest and we want to ask an authority. We could
  1883. * combine all the requests into one, but that may give more
  1884. * hints to the bridge authority than we want to give. */
  1885. char resource[10 + HEX_DIGEST_LEN];
  1886. memcpy(resource, "fp/", 3);
  1887. base16_encode(resource+3, HEX_DIGEST_LEN+1,
  1888. bridge->identity, DIGEST_LEN);
  1889. memcpy(resource+3+HEX_DIGEST_LEN, ".z", 3);
  1890. log_info(LD_DIR, "Fetching bridge info '%s' from bridge authority.",
  1891. resource);
  1892. directory_get_from_dirserver(DIR_PURPOSE_FETCH_SERVERDESC,
  1893. ROUTER_PURPOSE_BRIDGE, resource, 0);
  1894. }
  1895. }
  1896. SMARTLIST_FOREACH_END(bridge);
  1897. }
  1898. /** If our <b>bridge</b> is configured to be a different address than
  1899. * the bridge gives in <b>node</b>, rewrite the routerinfo
  1900. * we received to use the address we meant to use. Now we handle
  1901. * multihomed bridges better.
  1902. */
  1903. static void
  1904. rewrite_node_address_for_bridge(const bridge_info_t *bridge, node_t *node)
  1905. {
  1906. /* XXXX move this function. */
  1907. /* XXXX overridden addresses should really live in the node_t, so that the
  1908. * routerinfo_t and the microdesc_t can be immutable. But we can only
  1909. * do that safely if we know that no function that connects to an OR
  1910. * does so through an address from any source other than node_get_addr().
  1911. */
  1912. tor_addr_t addr;
  1913. if (node->ri) {
  1914. routerinfo_t *ri = node->ri;
  1915. tor_addr_from_ipv4h(&addr, ri->addr);
  1916. if ((!tor_addr_compare(&bridge->addr, &addr, CMP_EXACT) &&
  1917. bridge->port == ri->or_port) ||
  1918. (!tor_addr_compare(&bridge->addr, &ri->ipv6_addr, CMP_EXACT) &&
  1919. bridge->port == ri->ipv6_orport)) {
  1920. /* they match, so no need to do anything */
  1921. } else {
  1922. if (tor_addr_family(&bridge->addr) == AF_INET) {
  1923. ri->addr = tor_addr_to_ipv4h(&bridge->addr);
  1924. ri->or_port = bridge->port;
  1925. log_info(LD_DIR,
  1926. "Adjusted bridge routerinfo for '%s' to match configured "
  1927. "address %s:%d.",
  1928. ri->nickname, fmt_addr32(ri->addr), ri->or_port);
  1929. } else if (tor_addr_family(&bridge->addr) == AF_INET6) {
  1930. tor_addr_copy(&ri->ipv6_addr, &bridge->addr);
  1931. ri->ipv6_orport = bridge->port;
  1932. log_info(LD_DIR,
  1933. "Adjusted bridge routerinfo for '%s' to match configured "
  1934. "address %s.",
  1935. ri->nickname, fmt_addrport(&ri->ipv6_addr, ri->ipv6_orport));
  1936. } else {
  1937. log_err(LD_BUG, "Address family not supported: %d.",
  1938. tor_addr_family(&bridge->addr));
  1939. return;
  1940. }
  1941. }
  1942. /* Mark which address to use based on which bridge_t we got. */
  1943. node->ipv6_preferred = (tor_addr_family(&bridge->addr) == AF_INET6 &&
  1944. !tor_addr_is_null(&node->ri->ipv6_addr));
  1945. /* XXXipv6 we lack support for falling back to another address for
  1946. the same relay, warn the user */
  1947. if (!tor_addr_is_null(&ri->ipv6_addr)) {
  1948. tor_addr_port_t ap;
  1949. node_get_pref_orport(node, &ap);
  1950. log_notice(LD_CONFIG,
  1951. "Bridge '%s' has both an IPv4 and an IPv6 address. "
  1952. "Will prefer using its %s address (%s).",
  1953. ri->nickname,
  1954. tor_addr_family(&ap.addr) == AF_INET6 ? "IPv6" : "IPv4",
  1955. fmt_addrport(&ap.addr, ap.port));
  1956. }
  1957. }
  1958. if (node->rs) {
  1959. routerstatus_t *rs = node->rs;
  1960. tor_addr_from_ipv4h(&addr, rs->addr);
  1961. if (!tor_addr_compare(&bridge->addr, &addr, CMP_EXACT) &&
  1962. bridge->port == rs->or_port) {
  1963. /* they match, so no need to do anything */
  1964. } else {
  1965. rs->addr = tor_addr_to_ipv4h(&bridge->addr);
  1966. rs->or_port = bridge->port;
  1967. log_info(LD_DIR,
  1968. "Adjusted bridge routerstatus for '%s' to match "
  1969. "configured address %s.",
  1970. rs->nickname, fmt_addrport(&bridge->addr, rs->or_port));
  1971. }
  1972. }
  1973. }
  1974. /** We just learned a descriptor for a bridge. See if that
  1975. * digest is in our entry guard list, and add it if not. */
  1976. void
  1977. learned_bridge_descriptor(routerinfo_t *ri, int from_cache)
  1978. {
  1979. tor_assert(ri);
  1980. tor_assert(ri->purpose == ROUTER_PURPOSE_BRIDGE);
  1981. if (get_options()->UseBridges) {
  1982. int first = num_bridges_usable() <= 1;
  1983. bridge_info_t *bridge = get_configured_bridge_by_routerinfo(ri);
  1984. time_t now = time(NULL);
  1985. router_set_status(ri->cache_info.identity_digest, 1);
  1986. if (bridge) { /* if we actually want to use this one */
  1987. node_t *node;
  1988. /* it's here; schedule its re-fetch for a long time from now. */
  1989. if (!from_cache)
  1990. download_status_reset(&bridge->fetch_status);
  1991. node = node_get_mutable_by_id(ri->cache_info.identity_digest);
  1992. tor_assert(node);
  1993. rewrite_node_address_for_bridge(bridge, node);
  1994. add_an_entry_guard(node, 1, 1, 0, 0);
  1995. log_notice(LD_DIR, "new bridge descriptor '%s' (%s): %s", ri->nickname,
  1996. from_cache ? "cached" : "fresh", router_describe(ri));
  1997. /* set entry->made_contact so if it goes down we don't drop it from
  1998. * our entry node list */
  1999. entry_guard_register_connect_status(ri->cache_info.identity_digest,
  2000. 1, 0, now);
  2001. if (first) {
  2002. routerlist_retry_directory_downloads(now);
  2003. }
  2004. }
  2005. }
  2006. }
  2007. /** Return the number of bridges that have descriptors that
  2008. * are marked with purpose 'bridge' and are running.
  2009. *
  2010. * We use this function to decide if we're ready to start building
  2011. * circuits through our bridges, or if we need to wait until the
  2012. * directory "server/authority" requests finish. */
  2013. int
  2014. any_bridge_descriptors_known(void)
  2015. {
  2016. tor_assert(get_options()->UseBridges);
  2017. return choose_random_entry(NULL) != NULL;
  2018. }
  2019. /** Return the number of bridges that have descriptors that are marked with
  2020. * purpose 'bridge' and are running.
  2021. */
  2022. static int
  2023. num_bridges_usable(void)
  2024. {
  2025. int n_options = 0;
  2026. tor_assert(get_options()->UseBridges);
  2027. (void) choose_random_entry_impl(NULL, 0, 0, &n_options);
  2028. return n_options;
  2029. }
  2030. /** Return 1 if we have at least one descriptor for an entry guard
  2031. * (bridge or member of EntryNodes) and all descriptors we know are
  2032. * down. Else return 0. If <b>act</b> is 1, then mark the down guards
  2033. * up; else just observe and report. */
  2034. static int
  2035. entries_retry_helper(const or_options_t *options, int act)
  2036. {
  2037. const node_t *node;
  2038. int any_known = 0;
  2039. int any_running = 0;
  2040. int need_bridges = options->UseBridges != 0;
  2041. if (!entry_guards)
  2042. entry_guards = smartlist_new();
  2043. SMARTLIST_FOREACH_BEGIN(entry_guards, entry_guard_t *, e) {
  2044. node = node_get_by_id(e->identity);
  2045. if (node && node_has_descriptor(node) &&
  2046. node_is_bridge(node) == need_bridges) {
  2047. any_known = 1;
  2048. if (node->is_running)
  2049. any_running = 1; /* some entry is both known and running */
  2050. else if (act) {
  2051. /* Mark all current connections to this OR as unhealthy, since
  2052. * otherwise there could be one that started 30 seconds
  2053. * ago, and in 30 seconds it will time out, causing us to mark
  2054. * the node down and undermine the retry attempt. We mark even
  2055. * the established conns, since if the network just came back
  2056. * we'll want to attach circuits to fresh conns. */
  2057. connection_or_set_bad_connections(node->identity, 1);
  2058. /* mark this entry node for retry */
  2059. router_set_status(node->identity, 1);
  2060. e->can_retry = 1;
  2061. e->bad_since = 0;
  2062. }
  2063. }
  2064. } SMARTLIST_FOREACH_END(e);
  2065. log_debug(LD_DIR, "%d: any_known %d, any_running %d",
  2066. act, any_known, any_running);
  2067. return any_known && !any_running;
  2068. }
  2069. /** Do we know any descriptors for our bridges / entrynodes, and are
  2070. * all the ones we have descriptors for down? */
  2071. int
  2072. entries_known_but_down(const or_options_t *options)
  2073. {
  2074. tor_assert(entry_list_is_constrained(options));
  2075. return entries_retry_helper(options, 0);
  2076. }
  2077. /** Mark all down known bridges / entrynodes up. */
  2078. void
  2079. entries_retry_all(const or_options_t *options)
  2080. {
  2081. tor_assert(entry_list_is_constrained(options));
  2082. entries_retry_helper(options, 1);
  2083. }
  2084. /** Return true if at least one of our bridges runs a Tor version that can
  2085. * provide microdescriptors to us. If not, we'll fall back to asking for
  2086. * full descriptors. */
  2087. int
  2088. any_bridge_supports_microdescriptors(void)
  2089. {
  2090. const node_t *node;
  2091. if (!get_options()->UseBridges || !entry_guards)
  2092. return 0;
  2093. SMARTLIST_FOREACH_BEGIN(entry_guards, entry_guard_t *, e) {
  2094. node = node_get_by_id(e->identity);
  2095. if (node && node->is_running &&
  2096. node_is_bridge(node) && node_is_a_configured_bridge(node) &&
  2097. node_understands_microdescriptors(node)) {
  2098. /* This is one of our current bridges, and we know enough about
  2099. * it to know that it will be able to answer our microdescriptor
  2100. * questions. */
  2101. return 1;
  2102. }
  2103. } SMARTLIST_FOREACH_END(e);
  2104. return 0;
  2105. }
  2106. /** Release all storage held by the list of entry guards and related
  2107. * memory structs. */
  2108. void
  2109. entry_guards_free_all(void)
  2110. {
  2111. if (entry_guards) {
  2112. SMARTLIST_FOREACH(entry_guards, entry_guard_t *, e,
  2113. entry_guard_free(e));
  2114. smartlist_free(entry_guards);
  2115. entry_guards = NULL;
  2116. }
  2117. clear_bridge_list();
  2118. smartlist_free(bridge_list);
  2119. bridge_list = NULL;
  2120. circuit_build_times_free_timeouts(get_circuit_build_times_mutable());
  2121. }