1 /* Copyright (c) 2001 Matej Pfajfar.
2 * Copyright (c) 2001-2004, Roger Dingledine.
3 * Copyright (c) 2004-2007, Roger Dingledine, Nick Mathewson. */
4 /* See LICENSE for licensing information */
6 const char routerlist_c_id
[] =
12 * maintain and access the global list of routerinfos for known
18 /****************************************************************************/
20 /* static function prototypes */
21 static routerstatus_t
*router_pick_directory_server_impl(int requireother
,
24 int for_v2_directory
);
25 static routerstatus_t
*router_pick_trusteddirserver_impl(
26 authority_type_t type
, int requireother
,
27 int fascistfirewall
, int prefer_tunnel
);
28 static void mark_all_trusteddirservers_up(void);
29 static int router_nickname_matches(routerinfo_t
*router
, const char *nickname
);
30 static void routerstatus_list_update_from_networkstatus(time_t now
);
31 static void local_routerstatus_free(local_routerstatus_t
*rs
);
32 static void trusted_dir_server_free(trusted_dir_server_t
*ds
);
33 static void update_networkstatus_cache_downloads(time_t now
);
34 static void update_networkstatus_client_downloads(time_t now
);
35 static int signed_desc_digest_is_recognized(signed_descriptor_t
*desc
);
36 static void routerlist_assert_ok(routerlist_t
*rl
);
37 static int have_tried_downloading_all_statuses(int n_failures
);
38 static routerstatus_t
*networkstatus_find_entry(networkstatus_t
*ns
,
40 static local_routerstatus_t
*router_get_combined_status_by_nickname(
43 static void update_router_have_minimum_dir_info(void);
44 static void router_dir_info_changed(void);
46 /****************************************************************************/
48 /** Global list of a trusted_dir_server_t object for each trusted directory
50 static smartlist_t
*trusted_dir_servers
= NULL
;
52 /** Global list of all of the routers that we know about. */
53 static routerlist_t
*routerlist
= NULL
;
55 /** Global list of all of the current network_status documents that we know
56 * about. This list is kept sorted by published_on. */
57 static smartlist_t
*networkstatus_list
= NULL
;
59 /** Global list of local_routerstatus_t for each router, known or unknown.
60 * Kept sorted by digest. */
61 static smartlist_t
*routerstatus_list
= NULL
;
63 /** Map from lowercase nickname to digest of named server, if any. */
64 static strmap_t
*named_server_map
= NULL
;
66 /** True iff any member of networkstatus_list has changed since the last time
67 * we called routerstatus_list_update_from_networkstatus(). */
68 static int networkstatus_list_has_changed
= 0;
70 /** True iff any element of routerstatus_list has changed since the last
71 * time we called routers_update_all_from_networkstatus().*/
72 static int routerstatus_list_has_changed
= 0;
74 /** List of strings for nicknames we've already warned about and that are
75 * still unknown / unavailable. */
76 static smartlist_t
*warned_nicknames
= NULL
;
78 /** List of strings for nicknames or fingerprints we've already warned about
79 * and that are still conflicted. */
80 static smartlist_t
*warned_conflicts
= NULL
;
82 /** The last time we tried to download any routerdesc, or 0 for "never". We
83 * use this to rate-limit download attempts when the number of routerdescs to
85 static time_t last_routerdesc_download_attempted
= 0;
87 /** The last time we tried to download a networkstatus, or 0 for "never". We
88 * use this to rate-limit download attempts for directory caches (including
89 * mirrors). Clients don't use this now. */
90 static time_t last_networkstatus_download_attempted
= 0;
92 /** True iff we have logged a warning about this OR not being valid or
94 static int have_warned_about_invalid_status
= 0;
95 /** True iff we have logged a warning about this OR's version being older than
96 * listed by the authorities */
97 static int have_warned_about_old_version
= 0;
98 /** True iff we have logged a warning about this OR's version being newer than
99 * listed by the authorities */
100 static int have_warned_about_new_version
= 0;
102 /** Return the number of v2 directory authorities */
104 get_n_v2_authorities(void)
107 if (!trusted_dir_servers
)
109 SMARTLIST_FOREACH(trusted_dir_servers
, trusted_dir_server_t
*, ds
,
110 if (ds
->is_v2_authority
)
115 /** Repopulate our list of network_status_t objects from the list cached on
116 * disk. Return 0 on success, -1 on failure. */
118 router_reload_networkstatus(void)
121 smartlist_t
*entries
;
124 tor_assert(get_options()->DataDirectory
);
125 if (!networkstatus_list
)
126 networkstatus_list
= smartlist_create();
128 tor_snprintf(filename
,sizeof(filename
),"%s/cached-status",
129 get_options()->DataDirectory
);
130 entries
= tor_listdir(filename
);
131 SMARTLIST_FOREACH(entries
, const char *, fn
, {
132 char buf
[DIGEST_LEN
];
133 if (strlen(fn
) != HEX_DIGEST_LEN
||
134 base16_decode(buf
, sizeof(buf
), fn
, strlen(fn
))) {
136 "Skipping cached-status file with unexpected name \"%s\"",fn
);
139 tor_snprintf(filename
,sizeof(filename
),"%s/cached-status/%s",
140 get_options()->DataDirectory
, fn
);
141 s
= read_file_to_str(filename
, 0, &st
);
143 if (router_set_networkstatus(s
, st
.st_mtime
, NS_FROM_CACHE
, NULL
)<0) {
144 log_warn(LD_FS
, "Couldn't load networkstatus from \"%s\"",filename
);
149 SMARTLIST_FOREACH(entries
, char *, fn
, tor_free(fn
));
150 smartlist_free(entries
);
151 networkstatus_list_clean(time(NULL
));
152 routers_update_all_from_networkstatus();
156 /* Router descriptor storage.
158 * Routerdescs are stored in a big file, named "cached-routers". As new
159 * routerdescs arrive, we append them to a journal file named
160 * "cached-routers.new".
162 * From time to time, we replace "cached-routers" with a new file containing
163 * only the live, non-superseded descriptors, and clear cached-routers.new.
165 * On startup, we read both files.
168 /** The size of the router log, in bytes. */
169 static size_t router_journal_len
= 0;
170 /** The size of the router store, in bytes. */
171 static size_t router_store_len
= 0;
172 /** Total bytes dropped since last rebuild. */
173 static size_t router_bytes_dropped
= 0;
175 /** Helper: return 1 iff the router log is so big we want to rebuild the
178 router_should_rebuild_store(void)
180 if (router_store_len
> (1<<16))
181 return (router_journal_len
> router_store_len
/ 2 ||
182 router_bytes_dropped
> router_store_len
/ 2);
184 return router_journal_len
> (1<<15);
187 /** Add the <b>len</b>-type router descriptor in <b>s</b> to the router
188 * journal; change its saved_location to SAVED_IN_JOURNAL and set its
189 * offset appropriately. */
191 router_append_to_journal(signed_descriptor_t
*desc
)
193 or_options_t
*options
= get_options();
194 size_t fname_len
= strlen(options
->DataDirectory
)+32;
195 char *fname
= tor_malloc(fname_len
);
196 const char *body
= signed_descriptor_get_body(desc
);
197 size_t len
= desc
->signed_descriptor_len
;
199 tor_snprintf(fname
, fname_len
, "%s/cached-routers.new",
200 options
->DataDirectory
);
202 tor_assert(len
== strlen(body
));
204 if (append_bytes_to_file(fname
, body
, len
, 1)) {
205 log_warn(LD_FS
, "Unable to store router descriptor");
209 desc
->saved_location
= SAVED_IN_JOURNAL
;
210 desc
->saved_offset
= router_journal_len
;
213 router_journal_len
+= len
;
217 /** Sorting helper: return <0, 0, or >0 depending on whether the
218 * signed_descriptor_t* in *<b>a</b> is older, the same age as, or newer than
219 * the signed_descriptor_t* in *<b>b</b>. */
221 _compare_old_routers_by_age(const void **_a
, const void **_b
)
223 const signed_descriptor_t
*r1
= *_a
, *r2
= *_b
;
224 return r1
->published_on
- r2
->published_on
;
227 /** Sorting helper: return <0, 0, or >0 depending on whether the
228 * routerinfo_t* in *<b>a</b> is older, the same age as, or newer than
229 * the routerinfo_t* in *<b>b</b>. */
231 _compare_routers_by_age(const void **_a
, const void **_b
)
233 const routerinfo_t
*r1
= *_a
, *r2
= *_b
;
234 return r1
->cache_info
.published_on
- r2
->cache_info
.published_on
;
237 /** If the journal is too long, or if <b>force</b> is true, then atomically
238 * replace the router store with the routers currently in our routerlist, and
239 * clear the journal. Return 0 on success, -1 on failure.
242 router_rebuild_store(int force
)
244 or_options_t
*options
;
246 smartlist_t
*chunk_list
= NULL
;
247 char *fname
= NULL
, *fname_tmp
= NULL
;
250 smartlist_t
*old_routers
, *routers
;
252 if (!force
&& !router_should_rebuild_store())
257 /* Don't save deadweight. */
258 routerlist_remove_old_routers();
260 log_info(LD_DIR
, "Rebuilding router descriptor cache");
262 options
= get_options();
263 fname_len
= strlen(options
->DataDirectory
)+32;
264 fname
= tor_malloc(fname_len
);
265 fname_tmp
= tor_malloc(fname_len
);
266 tor_snprintf(fname
, fname_len
, "%s/cached-routers", options
->DataDirectory
);
267 tor_snprintf(fname_tmp
, fname_len
, "%s/cached-routers.tmp",
268 options
->DataDirectory
);
270 chunk_list
= smartlist_create();
272 old_routers
= smartlist_create();
273 smartlist_add_all(old_routers
, routerlist
->old_routers
);
274 smartlist_sort(old_routers
, _compare_old_routers_by_age
);
275 routers
= smartlist_create();
276 smartlist_add_all(routers
, routerlist
->routers
);
277 smartlist_sort(routers
, _compare_routers_by_age
);
278 for (i
= 0; i
< 2; ++i
) {
279 /* We sort the routers by age to enhance locality on disk. */
280 smartlist_t
*lst
= (i
== 0) ? old_routers
: routers
;
281 /* Now, add the appropriate members to chunk_list */
282 SMARTLIST_FOREACH(lst
, void *, ptr
,
284 signed_descriptor_t
*sd
= (i
==0) ?
285 ((signed_descriptor_t
*)ptr
): &((routerinfo_t
*)ptr
)->cache_info
;
287 const char *body
= signed_descriptor_get_body(sd
);
289 log_warn(LD_BUG
, "Bug! No descriptor available for router.");
292 c
= tor_malloc(sizeof(sized_chunk_t
));
294 c
->len
= sd
->signed_descriptor_len
;
295 smartlist_add(chunk_list
, c
);
298 if (write_chunks_to_file(fname_tmp
, chunk_list
, 1)<0) {
299 log_warn(LD_FS
, "Error writing router store to disk.");
302 /* Our mmap is now invalid. */
303 if (routerlist
->mmap_descriptors
) {
304 tor_munmap_file(routerlist
->mmap_descriptors
);
306 if (replace_file(fname_tmp
, fname
)<0) {
307 log_warn(LD_FS
, "Error replacing old router store.");
311 routerlist
->mmap_descriptors
= tor_mmap_file(fname
);
312 if (! routerlist
->mmap_descriptors
)
313 log_warn(LD_FS
, "Unable to mmap new descriptor file at '%s'.",fname
);
316 for (i
= 0; i
< 2; ++i
) {
317 smartlist_t
*lst
= (i
== 0) ? old_routers
: routers
;
318 SMARTLIST_FOREACH(lst
, void *, ptr
,
320 signed_descriptor_t
*sd
= (i
==0) ?
321 ((signed_descriptor_t
*)ptr
): &((routerinfo_t
*)ptr
)->cache_info
;
323 sd
->saved_location
= SAVED_IN_CACHE
;
324 if (routerlist
->mmap_descriptors
) {
325 tor_free(sd
->signed_descriptor_body
); // sets it to null
326 sd
->saved_offset
= offset
;
328 offset
+= sd
->signed_descriptor_len
;
329 signed_descriptor_get_body(sd
);
333 tor_snprintf(fname
, fname_len
, "%s/cached-routers.new",
334 options
->DataDirectory
);
336 write_str_to_file(fname
, "", 1);
339 tor_assert(offset
>= 0);
340 router_store_len
= (size_t) offset
;
341 router_journal_len
= 0;
342 router_bytes_dropped
= 0;
344 smartlist_free(old_routers
);
345 smartlist_free(routers
);
347 SMARTLIST_FOREACH(chunk_list
, sized_chunk_t
*, c
, tor_free(c
));
348 smartlist_free(chunk_list
);
352 /** Load all cached router descriptors from the store. Return 0 on success and
356 router_reload_router_list(void)
358 or_options_t
*options
= get_options();
359 size_t fname_len
= strlen(options
->DataDirectory
)+32;
360 char *fname
= tor_malloc(fname_len
), *contents
= NULL
;
363 router_get_routerlist(); /* mallocs and inits it in place */
365 router_journal_len
= router_store_len
= 0;
367 tor_snprintf(fname
, fname_len
, "%s/cached-routers", options
->DataDirectory
);
369 if (routerlist
->mmap_descriptors
) /* get rid of it first */
370 tor_munmap_file(routerlist
->mmap_descriptors
);
372 routerlist
->mmap_descriptors
= tor_mmap_file(fname
);
373 if (routerlist
->mmap_descriptors
) {
374 router_store_len
= routerlist
->mmap_descriptors
->size
;
375 router_load_routers_from_string(routerlist
->mmap_descriptors
->data
,
376 routerlist
->mmap_descriptors
->size
,
377 SAVED_IN_CACHE
, NULL
);
380 tor_snprintf(fname
, fname_len
, "%s/cached-routers.new",
381 options
->DataDirectory
);
382 if (file_status(fname
) == FN_FILE
)
383 contents
= read_file_to_str(fname
, RFTS_BIN
|RFTS_IGNORE_MISSING
, NULL
);
385 router_load_routers_from_string(contents
, strlen(contents
),
386 SAVED_IN_JOURNAL
, NULL
);
392 if (router_journal_len
) {
393 /* Always clear the journal on startup.*/
394 router_rebuild_store(1);
396 /* Don't cache expired routers. (This is in an else because
397 * router_rebuild_store() also calls remove_old_routers().) */
398 routerlist_remove_old_routers();
404 /** Return a smartlist containing a list of trusted_dir_server_t * for all
405 * known trusted dirservers. Callers must not modify the list or its
409 router_get_trusted_dir_servers(void)
411 if (!trusted_dir_servers
)
412 trusted_dir_servers
= smartlist_create();
414 return trusted_dir_servers
;
417 /** Try to find a running dirserver. If there are no running dirservers
418 * in our routerlist and <b>retry_if_no_servers</b> is non-zero,
419 * set all the authoritative ones as running again, and pick one;
420 * if there are then no dirservers at all in our routerlist,
421 * reload the routerlist and try one last time. If for_runningrouters is
422 * true, then only pick a dirserver that can answer runningrouters queries
423 * (that is, a trusted dirserver, or one running 0.0.9rc5-cvs or later).
424 * Don't pick an authority if any non-authority is viable.
425 * Other args are as in router_pick_directory_server_impl().
428 router_pick_directory_server(int requireother
,
430 int for_v2_directory
,
431 int retry_if_no_servers
)
433 routerstatus_t
*choice
;
434 int prefer_tunnel
= get_options()->PreferTunneledDirConns
;
439 choice
= router_pick_directory_server_impl(requireother
, fascistfirewall
,
440 prefer_tunnel
, for_v2_directory
);
441 if (choice
|| !retry_if_no_servers
)
445 "No reachable router entries for dirservers. "
446 "Trying them all again.");
447 /* mark all authdirservers as up again */
448 mark_all_trusteddirservers_up();
450 choice
= router_pick_directory_server_impl(requireother
, fascistfirewall
,
451 prefer_tunnel
, for_v2_directory
);
455 log_info(LD_DIR
,"Still no %s router entries. Reloading and trying again.",
456 fascistfirewall
? "reachable" : "known");
457 if (router_reload_router_list()) {
460 /* give it one last try */
461 choice
= router_pick_directory_server_impl(requireother
, fascistfirewall
,
462 prefer_tunnel
, for_v2_directory
);
466 /** Return the trusted_dir_server_t for the directory authority whose identity
467 * key hashes to <b>digest</b>, or NULL if no such authority is known.
469 trusted_dir_server_t
*
470 router_get_trusteddirserver_by_digest(const char *digest
)
472 if (!trusted_dir_servers
)
475 SMARTLIST_FOREACH(trusted_dir_servers
, trusted_dir_server_t
*, ds
,
477 if (!memcmp(ds
->digest
, digest
, DIGEST_LEN
))
484 /** Try to find a running trusted dirserver. If there are no running
485 * trusted dirservers and <b>retry_if_no_servers</b> is non-zero,
486 * set them all as running again, and try again.
487 * If <b>need_v1_authority</b> is set, return only trusted servers
488 * that are authorities for the V1 directory protocol.
489 * Other args are as in router_pick_trusteddirserver_impl().
492 router_pick_trusteddirserver(authority_type_t type
,
495 int retry_if_no_servers
)
497 routerstatus_t
*choice
;
498 int prefer_tunnel
= get_options()->PreferTunneledDirConns
;
500 choice
= router_pick_trusteddirserver_impl(type
, requireother
,
501 fascistfirewall
, prefer_tunnel
);
502 if (choice
|| !retry_if_no_servers
)
506 "No trusted dirservers are reachable. Trying them all again.");
507 mark_all_trusteddirservers_up();
508 return router_pick_trusteddirserver_impl(type
, requireother
,
509 fascistfirewall
, prefer_tunnel
);
512 /** How long do we avoid using a directory server after it's given us a 503? */
513 #define DIR_503_TIMEOUT (60*60)
515 /** Pick a random running valid directory server/mirror from our
516 * routerlist. Don't pick an authority if any non-authorities are viable.
517 * If <b>fascistfirewall</b>, make sure the router we pick is allowed
518 * by our firewall options.
519 * If <b>requireother</b>, it cannot be us. If <b>for_v2_directory</b>,
520 * choose a directory server new enough to support the v2 directory
522 * If <b>prefer_tunnel</b>, choose a directory server that is reachable
523 * and supports BEGIN_DIR cells, if possible.
524 * Try to avoid using servers that are overloaded (have returned 503
527 static routerstatus_t
*
528 router_pick_directory_server_impl(int requireother
, int fascistfirewall
,
529 int prefer_tunnel
, int for_v2_directory
)
531 routerstatus_t
*result
;
532 smartlist_t
*direct
, *tunnel
;
533 smartlist_t
*trusted_direct
, *trusted_tunnel
;
534 smartlist_t
*overloaded_direct
, *overloaded_tunnel
;
535 time_t now
= time(NULL
);
537 if (!routerstatus_list
)
540 direct
= smartlist_create();
541 tunnel
= smartlist_create();
542 trusted_direct
= smartlist_create();
543 trusted_tunnel
= smartlist_create();
544 overloaded_direct
= smartlist_create();
545 overloaded_tunnel
= smartlist_create();
547 /* Find all the running dirservers we know about. */
548 SMARTLIST_FOREACH(routerstatus_list
, local_routerstatus_t
*, _local_status
,
550 routerstatus_t
*status
= &(_local_status
->status
);
552 int is_overloaded
= _local_status
->last_dir_503_at
+ DIR_503_TIMEOUT
> now
;
553 if (!status
->is_running
|| !status
->dir_port
|| !status
->is_valid
)
555 if (status
->is_bad_directory
)
557 if (requireother
&& router_digest_is_me(status
->identity_digest
))
559 is_trusted
= router_digest_is_trusted_dir(status
->identity_digest
);
560 if (for_v2_directory
&& !(status
->is_v2_dir
|| is_trusted
))
562 if (fascistfirewall
&&
564 status
->version_supports_begindir
&&
565 router_get_by_digest(status
->identity_digest
) &&
566 fascist_firewall_allows_address_or(status
->addr
, status
->or_port
))
567 smartlist_add(is_trusted
? trusted_tunnel
:
568 is_overloaded
? overloaded_tunnel
: tunnel
, status
);
569 else if (!fascistfirewall
|| (fascistfirewall
&&
570 fascist_firewall_allows_address_dir(status
->addr
,
572 smartlist_add(is_trusted
? trusted_direct
:
573 is_overloaded
? overloaded_direct
: direct
, status
);
576 if (smartlist_len(tunnel
)) {
577 result
= routerstatus_sl_choose_by_bandwidth(tunnel
);
578 } else if (smartlist_len(overloaded_tunnel
)) {
579 result
= routerstatus_sl_choose_by_bandwidth(overloaded_tunnel
);
580 } else if (smartlist_len(trusted_tunnel
)) {
581 /* FFFF We don't distinguish between trusteds and overloaded trusteds
582 * yet. Maybe one day we should. */
583 /* FFFF We also don't load balance over authorities yet. I think this
584 * is a feature, but it could easily be a bug. -RD */
585 result
= smartlist_choose(trusted_tunnel
);
586 } else if (smartlist_len(direct
)) {
587 result
= routerstatus_sl_choose_by_bandwidth(direct
);
588 } else if (smartlist_len(overloaded_direct
)) {
589 result
= routerstatus_sl_choose_by_bandwidth(overloaded_direct
);
591 result
= smartlist_choose(trusted_direct
);
593 smartlist_free(direct
);
594 smartlist_free(tunnel
);
595 smartlist_free(trusted_direct
);
596 smartlist_free(trusted_tunnel
);
597 smartlist_free(overloaded_direct
);
598 smartlist_free(overloaded_tunnel
);
602 /** Choose randomly from among the trusted dirservers that are up. If
603 * <b>fascistfirewall</b>, make sure the port we pick is allowed by our
604 * firewall options. If <b>requireother</b>, it cannot be us. If
605 * <b>need_v1_authority</b>, choose a trusted authority for the v1 directory
608 static routerstatus_t
*
609 router_pick_trusteddirserver_impl(authority_type_t type
,
610 int requireother
, int fascistfirewall
,
613 smartlist_t
*direct
, *tunnel
;
614 smartlist_t
*overloaded_direct
, *overloaded_tunnel
;
615 routerinfo_t
*me
= router_get_my_routerinfo();
616 routerstatus_t
*result
;
617 time_t now
= time(NULL
);
619 direct
= smartlist_create();
620 tunnel
= smartlist_create();
621 overloaded_direct
= smartlist_create();
622 overloaded_tunnel
= smartlist_create();
624 if (!trusted_dir_servers
)
627 SMARTLIST_FOREACH(trusted_dir_servers
, trusted_dir_server_t
*, d
,
630 d
->fake_status
.last_dir_503_at
+ DIR_503_TIMEOUT
> now
;
631 if (!d
->is_running
) continue;
632 if (type
== V1_AUTHORITY
&& !d
->is_v1_authority
)
634 if (type
== V2_AUTHORITY
&& !d
->is_v2_authority
)
636 if (type
== HIDSERV_AUTHORITY
&& !d
->is_hidserv_authority
)
638 if (requireother
&& me
&& router_digest_is_me(d
->digest
))
641 if (fascistfirewall
&&
644 router_get_by_digest(d
->digest
) &&
645 fascist_firewall_allows_address_or(d
->addr
, d
->or_port
))
646 smartlist_add(is_overloaded
? overloaded_tunnel
: tunnel
,
647 &d
->fake_status
.status
);
648 else if (!fascistfirewall
|| (fascistfirewall
&&
649 fascist_firewall_allows_address_dir(d
->addr
,
651 smartlist_add(is_overloaded
? overloaded_direct
: direct
,
652 &d
->fake_status
.status
);
655 if (smartlist_len(tunnel
)) {
656 result
= smartlist_choose(tunnel
);
657 } else if (smartlist_len(overloaded_tunnel
)) {
658 result
= smartlist_choose(overloaded_tunnel
);
659 } else if (smartlist_len(direct
)) {
660 result
= smartlist_choose(direct
);
662 result
= smartlist_choose(overloaded_direct
);
665 smartlist_free(direct
);
666 smartlist_free(tunnel
);
667 smartlist_free(overloaded_direct
);
668 smartlist_free(overloaded_tunnel
);
672 /** Go through and mark the authoritative dirservers as up. */
674 mark_all_trusteddirservers_up(void)
677 SMARTLIST_FOREACH(routerlist
->routers
, routerinfo_t
*, router
,
678 if (router_digest_is_trusted_dir(router
->cache_info
.identity_digest
) &&
679 router
->dir_port
> 0) {
680 router
->is_running
= 1;
683 if (trusted_dir_servers
) {
684 SMARTLIST_FOREACH(trusted_dir_servers
, trusted_dir_server_t
*, dir
,
686 local_routerstatus_t
*rs
;
688 dir
->n_networkstatus_failures
= 0;
689 dir
->fake_status
.last_dir_503_at
= 0;
690 rs
= router_get_combined_status_by_digest(dir
->digest
);
691 if (rs
&& !rs
->status
.is_running
) {
692 rs
->status
.is_running
= 1;
693 rs
->last_dir_503_at
= 0;
694 control_event_networkstatus_changed_single(rs
);
698 last_networkstatus_download_attempted
= 0;
699 router_dir_info_changed();
702 /** Reset all internal variables used to count failed downloads of network
705 router_reset_status_download_failures(void)
707 mark_all_trusteddirservers_up();
710 /** Look through the routerlist and identify routers that
711 * advertise the same /16 network address as <b>router</b>.
712 * Add each of them to <b>sl</b>.
715 routerlist_add_network_family(smartlist_t
*sl
, routerinfo_t
*router
)
717 SMARTLIST_FOREACH(routerlist
->routers
, routerinfo_t
*, r
,
720 (router
->addr
& 0xffff0000) == (r
->addr
& 0xffff0000))
721 smartlist_add(sl
, r
);
725 /** Add all the family of <b>router</b> to the smartlist <b>sl</b>.
726 * This is used to make sure we don't pick siblings in a single path.
729 routerlist_add_family(smartlist_t
*sl
, routerinfo_t
*router
)
733 or_options_t
*options
= get_options();
735 /* First, add any routers with similar network addresses. */
736 if (options
->EnforceDistinctSubnets
)
737 routerlist_add_network_family(sl
, router
);
739 if (!router
->declared_family
)
742 /* Add every r such that router declares familyness with r, and r
743 * declares familyhood with router. */
744 SMARTLIST_FOREACH(router
->declared_family
, const char *, n
,
746 if (!(r
= router_get_by_nickname(n
, 0)))
748 if (!r
->declared_family
)
750 SMARTLIST_FOREACH(r
->declared_family
, const char *, n2
,
752 if (router_nickname_matches(router
, n2
))
753 smartlist_add(sl
, r
);
757 /* If the user declared any families locally, honor those too. */
758 for (cl
= get_options()->NodeFamilies
; cl
; cl
= cl
->next
) {
759 if (router_nickname_is_in_list(router
, cl
->value
)) {
760 add_nickname_list_to_smartlist(sl
, cl
->value
, 0);
765 /** Given a (possibly NULL) comma-and-whitespace separated list of nicknames,
766 * see which nicknames in <b>list</b> name routers in our routerlist, and add
767 * the routerinfos for those routers to <b>sl</b>. If <b>must_be_running</b>,
768 * only include routers that we think are running.
769 * Warn if any non-Named routers are specified by nickname.
772 add_nickname_list_to_smartlist(smartlist_t
*sl
, const char *list
,
775 routerinfo_t
*router
;
776 smartlist_t
*nickname_list
;
777 int have_dir_info
= router_have_minimum_dir_info();
780 return; /* nothing to do */
783 nickname_list
= smartlist_create();
784 if (!warned_nicknames
)
785 warned_nicknames
= smartlist_create();
787 smartlist_split_string(nickname_list
, list
, ",",
788 SPLIT_SKIP_SPACE
|SPLIT_IGNORE_BLANK
, 0);
790 SMARTLIST_FOREACH(nickname_list
, const char *, nick
, {
792 if (!is_legal_nickname_or_hexdigest(nick
)) {
793 log_warn(LD_CONFIG
, "Nickname '%s' is misformed; skipping", nick
);
796 router
= router_get_by_nickname(nick
, 1);
797 warned
= smartlist_string_isin(warned_nicknames
, nick
);
799 if (!must_be_running
|| router
->is_running
) {
800 smartlist_add(sl
,router
);
802 } else if (!router_get_combined_status_by_nickname(nick
,1)) {
804 log_fn(have_dir_info
? LOG_WARN
: LOG_INFO
, LD_CONFIG
,
805 "Nickname list includes '%s' which isn't a known router.",nick
);
806 smartlist_add(warned_nicknames
, tor_strdup(nick
));
810 SMARTLIST_FOREACH(nickname_list
, char *, nick
, tor_free(nick
));
811 smartlist_free(nickname_list
);
814 /** Return 1 iff any member of the (possibly NULL) comma-separated list
815 * <b>list</b> is an acceptable nickname or hexdigest for <b>router</b>. Else
819 router_nickname_is_in_list(routerinfo_t
*router
, const char *list
)
821 smartlist_t
*nickname_list
;
825 return 0; /* definitely not */
828 nickname_list
= smartlist_create();
829 smartlist_split_string(nickname_list
, list
, ",",
830 SPLIT_SKIP_SPACE
|SPLIT_IGNORE_BLANK
, 0);
831 SMARTLIST_FOREACH(nickname_list
, const char *, cp
,
832 if (router_nickname_matches(router
, cp
)) {v
=1;break;});
833 SMARTLIST_FOREACH(nickname_list
, char *, cp
, tor_free(cp
));
834 smartlist_free(nickname_list
);
838 /** Add every suitable router from our routerlist to <b>sl</b>, so that
839 * we can pick a node for a circuit.
842 router_add_running_routers_to_smartlist(smartlist_t
*sl
, int allow_invalid
,
843 int need_uptime
, int need_capacity
,
849 SMARTLIST_FOREACH(routerlist
->routers
, routerinfo_t
*, router
,
851 if (router
->is_running
&&
852 router
->purpose
== ROUTER_PURPOSE_GENERAL
&&
853 (router
->is_valid
|| allow_invalid
) &&
854 !router_is_unreliable(router
, need_uptime
,
855 need_capacity
, need_guard
)) {
856 /* If it's running, and it's suitable according to the
857 * other flags we had in mind */
858 smartlist_add(sl
, router
);
863 /** Look through the routerlist until we find a router that has my key.
866 routerlist_find_my_routerinfo(void)
871 SMARTLIST_FOREACH(routerlist
->routers
, routerinfo_t
*, router
,
873 if (router_is_me(router
))
879 /** Find a router that's up, that has this IP address, and
880 * that allows exit to this address:port, or return NULL if there
884 router_find_exact_exit_enclave(const char *address
, uint16_t port
)
889 if (!tor_inet_aton(address
, &in
))
890 return NULL
; /* it's not an IP already */
891 addr
= ntohl(in
.s_addr
);
893 SMARTLIST_FOREACH(routerlist
->routers
, routerinfo_t
*, router
,
895 if (router
->is_running
&&
896 router
->addr
== addr
&&
897 compare_addr_to_addr_policy(addr
, port
, router
->exit_policy
) ==
898 ADDR_POLICY_ACCEPTED
)
904 /** Return 1 if <b>router</b> is not suitable for these parameters, else 0.
905 * If <b>need_uptime</b> is non-zero, we require a minimum uptime.
906 * If <b>need_capacity</b> is non-zero, we require a minimum advertised
908 * If <b>need_guard</b>, we require that the router is a possible entry guard.
911 router_is_unreliable(routerinfo_t
*router
, int need_uptime
,
912 int need_capacity
, int need_guard
)
914 if (need_uptime
&& !router
->is_stable
)
916 if (need_capacity
&& !router
->is_fast
)
918 if (need_guard
&& !router
->is_possible_guard
)
923 /** Return the smaller of the router's configured BandwidthRate
924 * and its advertised capacity. */
926 router_get_advertised_bandwidth(routerinfo_t
*router
)
928 if (router
->bandwidthcapacity
< router
->bandwidthrate
)
929 return router
->bandwidthcapacity
;
930 return router
->bandwidthrate
;
933 /** Do not weight any declared bandwidth more than this much when picking
934 * routers by bandwidth. */
935 #define MAX_BELIEVABLE_BANDWIDTH 1500000 /* 1.5 MB/sec */
938 * choose a random element of smartlist <b>sl</b>, weighted by
939 * the advertised bandwidth of each element.
941 * If <b>statuses</b> is zero, then <b>sl</b> is a list of
942 * routerinfo_t's. Otherwise it's a list of routerstatus_t's.
944 * If <b>for_exit</b>, we're picking an exit node: consider all nodes'
945 * bandwidth equally regardless of their Exit status. If not <b>for_exit</b>,
946 * we're picking a non-exit node: weight exit-node's bandwidth downwards
947 * depending on the smallness of the fraction of Exit-to-total bandwidth.
950 smartlist_choose_by_bandwidth(smartlist_t
*sl
, int for_exit
, int statuses
)
953 routerinfo_t
*router
;
954 routerstatus_t
*status
;
957 uint64_t total_nonexit_bw
= 0, total_exit_bw
= 0, total_bw
= 0;
958 uint64_t rand_bw
, tmp
;
962 /* First count the total bandwidth weight, and make a list
963 * of each value. <0 means "unknown; no routerinfo." We use the
964 * bits of negative values to remember whether the router was fast (-x)&1
965 * and whether it was an exit (-x)&2. Yes, it's a hack. */
966 bandwidths
= tor_malloc(sizeof(int32_t)*smartlist_len(sl
));
968 /* Iterate over all the routerinfo_t or routerstatus_t, and */
969 for (i
= 0; i
< smartlist_len(sl
); ++i
) {
970 /* first, learn what bandwidth we think i has */
973 uint32_t this_bw
= 0;
975 /* need to extract router info */
976 status
= smartlist_get(sl
, i
);
977 router
= router_get_by_digest(status
->identity_digest
);
978 is_exit
= status
->is_exit
;
980 this_bw
= router_get_advertised_bandwidth(router
);
983 flags
= status
->is_fast
? 1 : 0;
984 flags
|= is_exit
? 2 : 0;
987 router
= smartlist_get(sl
, i
);
988 is_exit
= router
->is_exit
;
989 this_bw
= router_get_advertised_bandwidth(router
);
991 /* if they claim something huge, don't believe it */
992 if (this_bw
> MAX_BELIEVABLE_BANDWIDTH
)
993 this_bw
= MAX_BELIEVABLE_BANDWIDTH
;
995 bandwidths
[i
] = (int32_t) this_bw
; // safe since MAX_BELIEVABLE<INT32_MAX
997 total_exit_bw
+= this_bw
;
999 total_nonexit_bw
+= this_bw
;
1002 bandwidths
[i
] = -flags
;
1006 /* Now, fill in the unknown values. */
1008 int32_t avg_fast
, avg_slow
;
1009 if (total_exit_bw
+total_nonexit_bw
) {
1010 /* if there's some bandwidth, there's at least one known router,
1011 * so no worries about div by 0 here */
1012 int n_known
= smartlist_len(sl
)-n_unknown
;
1013 avg_fast
= avg_slow
= (int32_t)
1014 ((total_exit_bw
+total_nonexit_bw
)/((uint64_t) n_known
));
1019 for (i
=0; i
<smartlist_len(sl
); ++i
) {
1020 int32_t bw
= bandwidths
[i
];
1023 is_exit
= ((-bw
)&2);
1024 bandwidths
[i
] = ((-bw
)&1) ? avg_fast
: avg_slow
;
1026 total_exit_bw
+= bandwidths
[i
];
1028 total_nonexit_bw
+= bandwidths
[i
];
1032 /* If there's no bandwidth at all, pick at random. */
1033 if (!(total_exit_bw
+total_nonexit_bw
)) {
1034 tor_free(bandwidths
);
1035 return smartlist_choose(sl
);
1038 /* Figure out how to weight exits. */
1040 /* If we're choosing an exit node, exit bandwidth counts fully. */
1042 total_bw
= total_exit_bw
+ total_nonexit_bw
;
1043 } else if (total_exit_bw
< total_nonexit_bw
/ 2) {
1044 /* If we're choosing a relay and exits are greatly outnumbered, ignore
1047 total_bw
= total_nonexit_bw
;
1049 /* If we're choosing a relay and exits aren't outnumbered use the formula
1050 * from path-spec. */
1051 uint64_t leftover
= (total_exit_bw
- total_nonexit_bw
/ 2);
1052 exit_weight
= U64_TO_DBL(leftover
) /
1053 U64_TO_DBL(leftover
+ total_nonexit_bw
);
1054 total_bw
= total_nonexit_bw
+
1055 DBL_TO_U64(exit_weight
* U64_TO_DBL(total_exit_bw
));
1058 log_debug(LD_CIRC, "Total bw = "U64_FORMAT", total exit bw = "U64_FORMAT
1059 ", total nonexit bw = "U64_FORMAT", exit weight = %lf "
1061 U64_PRINTF_ARG(total_bw), U64_PRINTF_ARG(total_exit_bw),
1062 U64_PRINTF_ARG(total_nonexit_bw), exit_weight, for_exit);
1065 /* Almost done: choose a random value from the bandwidth weights. */
1066 rand_bw
= crypto_rand_uint64(total_bw
);
1068 /* Last, count through sl until we get to the element we picked */
1070 for (i
=0; i
< smartlist_len(sl
); i
++) {
1072 status
= smartlist_get(sl
, i
);
1073 is_exit
= status
->is_exit
;
1075 router
= smartlist_get(sl
, i
);
1076 is_exit
= router
->is_exit
;
1079 tmp
+= ((uint64_t)(bandwidths
[i
] * exit_weight
));
1081 tmp
+= bandwidths
[i
];
1085 tor_free(bandwidths
);
1086 return smartlist_get(sl
, i
);
1089 /** Choose a random element of router list <b>sl</b>, weighted by
1090 * the advertised bandwidth of each router.
1093 routerlist_sl_choose_by_bandwidth(smartlist_t
*sl
, int for_exit
)
1095 return smartlist_choose_by_bandwidth(sl
, for_exit
, 0);
1098 /** Choose a random element of status list <b>sl</b>, weighted by
1099 * the advertised bandwidth of each status.
1102 routerstatus_sl_choose_by_bandwidth(smartlist_t
*sl
)
1104 return smartlist_choose_by_bandwidth(sl
, 1, 1);
1107 /** Return a random running router from the routerlist. If any node
1108 * named in <b>preferred</b> is available, pick one of those. Never
1109 * pick a node named in <b>excluded</b>, or whose routerinfo is in
1110 * <b>excludedsmartlist</b>, even if they are the only nodes
1111 * available. If <b>strict</b> is true, never pick any node besides
1112 * those in <b>preferred</b>.
1113 * If <b>need_uptime</b> is non-zero and any router has more than
1114 * a minimum uptime, return one of those.
1115 * If <b>need_capacity</b> is non-zero, weight your choice by the
1116 * advertised capacity of each router.
1117 * If ! <b>allow_invalid</b>, consider only Valid routers.
1118 * If <b>need_guard</b>, consider only Guard routers.
1119 * If <b>weight_for_exit</b>, we weight bandwidths as if picking an exit node,
1120 * otherwise we weight bandwidths for picking a relay node (that is, possibly
1121 * discounting exit nodes).
1124 router_choose_random_node(const char *preferred
,
1125 const char *excluded
,
1126 smartlist_t
*excludedsmartlist
,
1127 int need_uptime
, int need_capacity
,
1129 int allow_invalid
, int strict
,
1130 int weight_for_exit
)
1132 smartlist_t
*sl
, *excludednodes
;
1133 routerinfo_t
*choice
= NULL
;
1135 excludednodes
= smartlist_create();
1136 add_nickname_list_to_smartlist(excludednodes
,excluded
,0);
1138 /* Try the preferred nodes first. Ignore need_uptime and need_capacity
1139 * and need_guard, since the user explicitly asked for these nodes. */
1141 sl
= smartlist_create();
1142 add_nickname_list_to_smartlist(sl
,preferred
,1);
1143 smartlist_subtract(sl
,excludednodes
);
1144 if (excludedsmartlist
)
1145 smartlist_subtract(sl
,excludedsmartlist
);
1146 choice
= smartlist_choose(sl
);
1149 if (!choice
&& !strict
) {
1150 /* Then give up on our preferred choices: any node
1151 * will do that has the required attributes. */
1152 sl
= smartlist_create();
1153 router_add_running_routers_to_smartlist(sl
, allow_invalid
,
1154 need_uptime
, need_capacity
,
1156 smartlist_subtract(sl
,excludednodes
);
1157 if (excludedsmartlist
)
1158 smartlist_subtract(sl
,excludedsmartlist
);
1161 choice
= routerlist_sl_choose_by_bandwidth(sl
, weight_for_exit
);
1163 choice
= smartlist_choose(sl
);
1166 if (!choice
&& (need_uptime
|| need_capacity
|| need_guard
)) {
1167 /* try once more -- recurse but with fewer restrictions. */
1169 "We couldn't find any live%s%s%s routers; falling back "
1170 "to list of all routers.",
1171 need_capacity
?", fast":"",
1172 need_uptime
?", stable":"",
1173 need_guard
?", guard":"");
1174 choice
= router_choose_random_node(
1175 NULL
, excluded
, excludedsmartlist
,
1176 0, 0, 0, allow_invalid
, 0, weight_for_exit
);
1179 smartlist_free(excludednodes
);
1182 log_warn(LD_CIRC
, "All preferred nodes were down when trying to choose "
1183 "node, and the Strict[...]Nodes option is set. Failing.");
1186 "No available nodes when trying to choose node. Failing.");
1192 /** Return true iff the digest of <b>router</b>'s identity key,
1193 * encoded in hexadecimal, matches <b>hexdigest</b> (which is
1194 * optionally prefixed with a single dollar sign). Return false if
1195 * <b>hexdigest</b> is malformed, or it doesn't match. */
1197 router_hex_digest_matches(routerinfo_t
*router
, const char *hexdigest
)
1199 char digest
[DIGEST_LEN
];
1201 tor_assert(hexdigest
);
1202 if (hexdigest
[0] == '$')
1205 len
= strlen(hexdigest
);
1206 if (len
< HEX_DIGEST_LEN
)
1208 else if (len
> HEX_DIGEST_LEN
&&
1209 (hexdigest
[HEX_DIGEST_LEN
] == '=' ||
1210 hexdigest
[HEX_DIGEST_LEN
] == '~')) {
1211 if (strcasecmp(hexdigest
+HEX_DIGEST_LEN
+1, router
->nickname
))
1213 if (hexdigest
[HEX_DIGEST_LEN
] == '=' && !router
->is_named
)
1217 if (base16_decode(digest
, DIGEST_LEN
, hexdigest
, HEX_DIGEST_LEN
)<0)
1219 return (!memcmp(digest
, router
->cache_info
.identity_digest
, DIGEST_LEN
));
1222 /** Return true if <b>router</b>'s nickname matches <b>nickname</b>
1223 * (case-insensitive), or if <b>router's</b> identity key digest
1224 * matches a hexadecimal value stored in <b>nickname</b>. Return
1225 * false otherwise. */
1227 router_nickname_matches(routerinfo_t
*router
, const char *nickname
)
1229 if (nickname
[0]!='$' && !strcasecmp(router
->nickname
, nickname
))
1231 return router_hex_digest_matches(router
, nickname
);
1234 /** Return the router in our routerlist whose (case-insensitive)
1235 * nickname or (case-sensitive) hexadecimal key digest is
1236 * <b>nickname</b>. Return NULL if no such router is known.
1239 router_get_by_nickname(const char *nickname
, int warn_if_unnamed
)
1242 char digest
[DIGEST_LEN
];
1243 routerinfo_t
*best_match
=NULL
;
1245 char *named_digest
= NULL
;
1247 tor_assert(nickname
);
1250 if (nickname
[0] == '$')
1251 return router_get_by_hexdigest(nickname
);
1252 if (!strcasecmp(nickname
, UNNAMED_ROUTER_NICKNAME
))
1254 if (server_mode(get_options()) &&
1255 !strcasecmp(nickname
, get_options()->Nickname
))
1256 return router_get_my_routerinfo();
1258 maybedigest
= (strlen(nickname
) >= HEX_DIGEST_LEN
) &&
1259 (base16_decode(digest
,DIGEST_LEN
,nickname
,HEX_DIGEST_LEN
) == 0);
1261 if (named_server_map
&&
1262 (named_digest
= strmap_get_lc(named_server_map
, nickname
))) {
1263 return digestmap_get(routerlist
->identity_map
, named_digest
);
1266 SMARTLIST_FOREACH(routerlist
->routers
, routerinfo_t
*, router
,
1268 if (!strcasecmp(router
->nickname
, nickname
)) {
1270 if (n_matches
<= 1 || router
->is_running
)
1271 best_match
= router
;
1272 } else if (maybedigest
&&
1273 !memcmp(digest
, router
->cache_info
.identity_digest
, DIGEST_LEN
)
1275 if (router_hex_digest_matches(router
, nickname
))
1278 best_match
= router
; // XXXX NM not exactly right.
1283 if (warn_if_unnamed
&& n_matches
> 1) {
1284 smartlist_t
*fps
= smartlist_create();
1285 int any_unwarned
= 0;
1286 SMARTLIST_FOREACH(routerlist
->routers
, routerinfo_t
*, router
,
1288 local_routerstatus_t
*rs
;
1291 char fp
[HEX_DIGEST_LEN
+1];
1292 if (strcasecmp(router
->nickname
, nickname
))
1294 rs
= router_get_combined_status_by_digest(
1295 router
->cache_info
.identity_digest
);
1296 if (rs
&& !rs
->name_lookup_warned
) {
1297 rs
->name_lookup_warned
= 1;
1300 base16_encode(fp
, sizeof(fp
),
1301 router
->cache_info
.identity_digest
, DIGEST_LEN
);
1302 dlen
= 32 + HEX_DIGEST_LEN
+ strlen(router
->address
);
1303 desc
= tor_malloc(dlen
);
1304 tor_snprintf(desc
, dlen
, "\"$%s\" for the one at %s:%d",
1305 fp
, router
->address
, router
->or_port
);
1306 smartlist_add(fps
, desc
);
1309 char *alternatives
= smartlist_join_strings(fps
, "; ",0,NULL
);
1311 "There are multiple matches for the nickname \"%s\","
1312 " but none is listed as named by the directory authorities. "
1313 "Choosing one arbitrarily. If you meant one in particular, "
1314 "you should say %s.", nickname
, alternatives
);
1315 tor_free(alternatives
);
1317 SMARTLIST_FOREACH(fps
, char *, cp
, tor_free(cp
));
1318 smartlist_free(fps
);
1319 } else if (warn_if_unnamed
) {
1320 local_routerstatus_t
*rs
= router_get_combined_status_by_digest(
1321 best_match
->cache_info
.identity_digest
);
1322 if (rs
&& !rs
->name_lookup_warned
) {
1323 char fp
[HEX_DIGEST_LEN
+1];
1324 base16_encode(fp
, sizeof(fp
),
1325 best_match
->cache_info
.identity_digest
, DIGEST_LEN
);
1326 log_warn(LD_CONFIG
, "You specified a server \"%s\" by name, but this "
1327 "name is not registered, so it could be used by any server, "
1328 "not just the one you meant. "
1329 "To make sure you get the same server in the future, refer to "
1330 "it by key, as \"$%s\".", nickname
, fp
);
1331 rs
->name_lookup_warned
= 1;
1340 /** Try to find a routerinfo for <b>digest</b>. If we don't have one,
1341 * return 1. If we do, ask tor_version_as_new_as() for the answer.
1344 router_digest_version_as_new_as(const char *digest
, const char *cutoff
)
1346 routerinfo_t
*router
= router_get_by_digest(digest
);
1349 return tor_version_as_new_as(router
->platform
, cutoff
);
1352 /** Return true iff <b>digest</b> is the digest of the identity key of
1353 * a trusted directory. */
1355 router_digest_is_trusted_dir(const char *digest
)
1357 if (!trusted_dir_servers
)
1359 if (get_options()->AuthoritativeDir
&&
1360 router_digest_is_me(digest
))
1362 SMARTLIST_FOREACH(trusted_dir_servers
, trusted_dir_server_t
*, ent
,
1363 if (!memcmp(digest
, ent
->digest
, DIGEST_LEN
)) return 1);
1367 /** Return the router in our routerlist whose hexadecimal key digest
1368 * is <b>hexdigest</b>. Return NULL if no such router is known. */
1370 router_get_by_hexdigest(const char *hexdigest
)
1372 char digest
[DIGEST_LEN
];
1376 tor_assert(hexdigest
);
1379 if (hexdigest
[0]=='$')
1381 len
= strlen(hexdigest
);
1382 if (len
< HEX_DIGEST_LEN
||
1383 base16_decode(digest
,DIGEST_LEN
,hexdigest
,HEX_DIGEST_LEN
) < 0)
1386 ri
= router_get_by_digest(digest
);
1388 if (len
> HEX_DIGEST_LEN
) {
1389 if (hexdigest
[HEX_DIGEST_LEN
] == '=') {
1390 if (strcasecmp(ri
->nickname
, hexdigest
+HEX_DIGEST_LEN
+1) ||
1393 } else if (hexdigest
[HEX_DIGEST_LEN
] == '~') {
1394 if (strcasecmp(ri
->nickname
, hexdigest
+HEX_DIGEST_LEN
+1))
1404 /** Return the router in our routerlist whose 20-byte key digest
1405 * is <b>digest</b>. Return NULL if no such router is known. */
1407 router_get_by_digest(const char *digest
)
1411 if (!routerlist
) return NULL
;
1413 // routerlist_assert_ok(routerlist);
1415 return digestmap_get(routerlist
->identity_map
, digest
);
1418 /** Return the router in our routerlist whose 20-byte descriptor
1419 * is <b>digest</b>. Return NULL if no such router is known. */
1420 signed_descriptor_t
*
1421 router_get_by_descriptor_digest(const char *digest
)
1425 if (!routerlist
) return NULL
;
1427 return digestmap_get(routerlist
->desc_digest_map
, digest
);
1430 /** Return a pointer to the signed textual representation of a descriptor.
1431 * The returned string is not guaranteed to be NUL-terminated: the string's
1432 * length will be in desc-\>signed_descriptor_len. */
1434 signed_descriptor_get_body(signed_descriptor_t
*desc
)
1437 size_t len
= desc
->signed_descriptor_len
;
1438 tor_assert(len
> 32);
1439 if (desc
->saved_location
== SAVED_IN_CACHE
&& routerlist
&&
1440 routerlist
->mmap_descriptors
) {
1441 tor_assert(desc
->saved_offset
+ len
<= routerlist
->mmap_descriptors
->size
);
1442 r
= routerlist
->mmap_descriptors
->data
+ desc
->saved_offset
;
1444 r
= desc
->signed_descriptor_body
;
1447 tor_assert(!memcmp("router ", r
, 7));
1449 tor_assert(!memcmp("\n-----END SIGNATURE-----\n",
1456 /** Return the current list of all known routers. */
1458 router_get_routerlist(void)
1461 routerlist
= tor_malloc_zero(sizeof(routerlist_t
));
1462 routerlist
->routers
= smartlist_create();
1463 routerlist
->old_routers
= smartlist_create();
1464 routerlist
->identity_map
= digestmap_new();
1465 routerlist
->desc_digest_map
= digestmap_new();
1470 /** Free all storage held by <b>router</b>. */
1472 routerinfo_free(routerinfo_t
*router
)
1477 tor_free(router
->cache_info
.signed_descriptor_body
);
1478 tor_free(router
->address
);
1479 tor_free(router
->nickname
);
1480 tor_free(router
->platform
);
1481 tor_free(router
->contact_info
);
1482 if (router
->onion_pkey
)
1483 crypto_free_pk_env(router
->onion_pkey
);
1484 if (router
->identity_pkey
)
1485 crypto_free_pk_env(router
->identity_pkey
);
1486 if (router
->declared_family
) {
1487 SMARTLIST_FOREACH(router
->declared_family
, char *, s
, tor_free(s
));
1488 smartlist_free(router
->declared_family
);
1490 addr_policy_free(router
->exit_policy
);
1494 /** Release storage held by <b>sd</b>. */
1496 signed_descriptor_free(signed_descriptor_t
*sd
)
1498 tor_free(sd
->signed_descriptor_body
);
1502 /** Extract a signed_descriptor_t from a routerinfo, and free the routerinfo.
1504 static signed_descriptor_t
*
1505 signed_descriptor_from_routerinfo(routerinfo_t
*ri
)
1507 signed_descriptor_t
*sd
= tor_malloc_zero(sizeof(signed_descriptor_t
));
1508 memcpy(sd
, &(ri
->cache_info
), sizeof(signed_descriptor_t
));
1509 ri
->cache_info
.signed_descriptor_body
= NULL
;
1510 routerinfo_free(ri
);
1514 /** Free all storage held by a routerlist <b>rl</b> */
1516 routerlist_free(routerlist_t
*rl
)
1519 digestmap_free(rl
->identity_map
, NULL
);
1520 digestmap_free(rl
->desc_digest_map
, NULL
);
1521 SMARTLIST_FOREACH(rl
->routers
, routerinfo_t
*, r
,
1522 routerinfo_free(r
));
1523 SMARTLIST_FOREACH(rl
->old_routers
, signed_descriptor_t
*, sd
,
1524 signed_descriptor_free(sd
));
1525 smartlist_free(rl
->routers
);
1526 smartlist_free(rl
->old_routers
);
1527 if (routerlist
->mmap_descriptors
)
1528 tor_munmap_file(routerlist
->mmap_descriptors
);
1531 router_dir_info_changed();
1535 dump_routerlist_mem_usage(int severity
)
1537 uint64_t livedescs
= 0;
1538 uint64_t olddescs
= 0;
1541 SMARTLIST_FOREACH(routerlist
->routers
, routerinfo_t
*, r
,
1542 livedescs
+= r
->cache_info
.signed_descriptor_len
);
1543 SMARTLIST_FOREACH(routerlist
->old_routers
, signed_descriptor_t
*, sd
,
1544 olddescs
+= sd
->signed_descriptor_len
);
1546 log(severity
, LD_GENERAL
,
1547 "In %d live descriptors: "U64_FORMAT
" bytes. "
1548 "In %d old descriptors: "U64_FORMAT
" bytes.",
1549 smartlist_len(routerlist
->routers
), U64_PRINTF_ARG(livedescs
),
1550 smartlist_len(routerlist
->old_routers
), U64_PRINTF_ARG(olddescs
));
1553 /** Return the greatest number of routerdescs we'll hold for any given router.
1556 max_descriptors_per_router(void)
1558 int n_authorities
= get_n_v2_authorities();
1559 return (n_authorities
< 5) ? 5 : n_authorities
;
1562 /** Return non-zero if we have a lot of extra descriptors in our
1563 * routerlist, and should get rid of some of them. Else return 0.
1565 * We should be careful to not return true too eagerly, since we
1566 * could churn. By using "+1" below, we make sure this function
1567 * only returns true at most every smartlist_len(rl-\>routers)
1571 routerlist_is_overfull(routerlist_t
*rl
)
1573 return smartlist_len(rl
->old_routers
) >
1574 smartlist_len(rl
->routers
)*(max_descriptors_per_router()+1);
1578 _routerlist_find_elt(smartlist_t
*sl
, void *ri
, int idx
)
1580 if (idx
< 0 || smartlist_get(sl
, idx
) != ri
) {
1582 SMARTLIST_FOREACH(sl
, routerinfo_t
*, r
,
1591 /** Insert an item <b>ri</b> into the routerlist <b>rl</b>, updating indices
1594 routerlist_insert(routerlist_t
*rl
, routerinfo_t
*ri
)
1597 /* XXXX remove this code once bug 404 is fixed. */
1598 routerinfo_t
*ri_generated
= router_get_my_routerinfo();
1599 tor_assert(ri_generated
!= ri
);
1602 digestmap_set(rl
->identity_map
, ri
->cache_info
.identity_digest
, ri
);
1603 digestmap_set(rl
->desc_digest_map
, ri
->cache_info
.signed_descriptor_digest
,
1605 smartlist_add(rl
->routers
, ri
);
1606 ri
->routerlist_index
= smartlist_len(rl
->routers
) - 1;
1607 router_dir_info_changed();
1608 routerlist_assert_ok(rl
);
1611 /** If we're a directory cache and routerlist <b>rl</b> doesn't have
1612 * a copy of router <b>ri</b> yet, add it to the list of old (not
1613 * recommended but still served) descriptors. Else free it. */
1615 routerlist_insert_old(routerlist_t
*rl
, routerinfo_t
*ri
)
1618 /* XXXX remove this code once bug 404 is fixed. */
1619 routerinfo_t
*ri_generated
= router_get_my_routerinfo();
1620 tor_assert(ri_generated
!= ri
);
1622 if (get_options()->DirPort
&&
1623 !digestmap_get(rl
->desc_digest_map
,
1624 ri
->cache_info
.signed_descriptor_digest
)) {
1625 signed_descriptor_t
*sd
= signed_descriptor_from_routerinfo(ri
);
1626 digestmap_set(rl
->desc_digest_map
, sd
->signed_descriptor_digest
, sd
);
1627 smartlist_add(rl
->old_routers
, sd
);
1629 routerinfo_free(ri
);
1631 routerlist_assert_ok(rl
);
1634 /** Remove an item <b>ri</b> from the routerlist <b>rl</b>, updating indices
1635 * as needed. If <b>idx</b> is nonnegative and smartlist_get(rl->routers,
1636 * idx) == ri, we don't need to do a linear search over the list to decide
1637 * which to remove. We fill the gap in rl->routers with a later element in
1638 * the list, if any exists. <b>ri</b> is freed. */
1640 routerlist_remove(routerlist_t
*rl
, routerinfo_t
*ri
, int idx
, int make_old
)
1642 routerinfo_t
*ri_tmp
;
1643 idx
= _routerlist_find_elt(rl
->routers
, ri
, idx
);
1646 ri
->routerlist_index
= -1;
1647 smartlist_del(rl
->routers
, idx
);
1648 if (idx
< smartlist_len(rl
->routers
)) {
1649 routerinfo_t
*r
= smartlist_get(rl
->routers
, idx
);
1650 r
->routerlist_index
= idx
;
1653 ri_tmp
= digestmap_remove(rl
->identity_map
, ri
->cache_info
.identity_digest
);
1654 router_dir_info_changed();
1655 tor_assert(ri_tmp
== ri
);
1656 if (make_old
&& get_options()->DirPort
) {
1657 signed_descriptor_t
*sd
;
1658 sd
= signed_descriptor_from_routerinfo(ri
);
1659 smartlist_add(rl
->old_routers
, sd
);
1660 digestmap_set(rl
->desc_digest_map
, sd
->signed_descriptor_digest
, sd
);
1662 ri_tmp
= digestmap_remove(rl
->desc_digest_map
,
1663 ri
->cache_info
.signed_descriptor_digest
);
1664 tor_assert(ri_tmp
== ri
);
1665 router_bytes_dropped
+= ri
->cache_info
.signed_descriptor_len
;
1666 routerinfo_free(ri
);
1668 routerlist_assert_ok(rl
);
1673 routerlist_remove_old(routerlist_t
*rl
, signed_descriptor_t
*sd
, int idx
)
1675 signed_descriptor_t
*sd_tmp
;
1676 idx
= _routerlist_find_elt(rl
->old_routers
, sd
, idx
);
1679 smartlist_del(rl
->old_routers
, idx
);
1680 sd_tmp
= digestmap_remove(rl
->desc_digest_map
,
1681 sd
->signed_descriptor_digest
);
1682 tor_assert(sd_tmp
== sd
);
1683 router_bytes_dropped
+= sd
->signed_descriptor_len
;
1684 signed_descriptor_free(sd
);
1685 routerlist_assert_ok(rl
);
1688 /** Remove <b>ri_old</b> from the routerlist <b>rl</b>, and replace it with
1689 * <b>ri_new</b>, updating all index info. If <b>idx</b> is nonnegative and
1690 * smartlist_get(rl->routers, idx) == ri, we don't need to do a linear
1691 * search over the list to decide which to remove. We put ri_new in the same
1692 * index as ri_old, if possible. ri is freed as appropriate. */
1694 routerlist_replace(routerlist_t
*rl
, routerinfo_t
*ri_old
,
1695 routerinfo_t
*ri_new
)
1699 /* XXXX remove this code once bug 404 is fixed. */
1700 routerinfo_t
*ri_generated
= router_get_my_routerinfo();
1701 tor_assert(ri_generated
!= ri_new
);
1703 tor_assert(ri_old
!= ri_new
);
1704 idx
= ri_old
->routerlist_index
;
1705 tor_assert(0 <= idx
&& idx
< smartlist_len(rl
->routers
));
1706 tor_assert(smartlist_get(rl
->routers
, idx
) == ri_old
);
1708 router_dir_info_changed();
1710 smartlist_set(rl
->routers
, idx
, ri_new
);
1711 ri_old
->routerlist_index
= -1;
1712 ri_new
->routerlist_index
= idx
;
1714 log_warn(LD_BUG
, "Appending entry from routerlist_replace.");
1715 routerlist_insert(rl
, ri_new
);
1718 if (memcmp(ri_old
->cache_info
.identity_digest
,
1719 ri_new
->cache_info
.identity_digest
, DIGEST_LEN
)) {
1720 /* digests don't match; digestmap_set won't replace */
1721 digestmap_remove(rl
->identity_map
, ri_old
->cache_info
.identity_digest
);
1723 digestmap_set(rl
->identity_map
, ri_new
->cache_info
.identity_digest
, ri_new
);
1724 digestmap_set(rl
->desc_digest_map
,
1725 ri_new
->cache_info
.signed_descriptor_digest
, &(ri_new
->cache_info
));
1727 if (get_options()->DirPort
) {
1728 signed_descriptor_t
*sd
= signed_descriptor_from_routerinfo(ri_old
);
1729 smartlist_add(rl
->old_routers
, sd
);
1730 digestmap_set(rl
->desc_digest_map
, sd
->signed_descriptor_digest
, sd
);
1732 if (memcmp(ri_old
->cache_info
.signed_descriptor_digest
,
1733 ri_new
->cache_info
.signed_descriptor_digest
,
1735 /* digests don't match; digestmap_set didn't replace */
1736 digestmap_remove(rl
->desc_digest_map
,
1737 ri_old
->cache_info
.signed_descriptor_digest
);
1739 router_bytes_dropped
+= ri_old
->cache_info
.signed_descriptor_len
;
1740 routerinfo_free(ri_old
);
1742 routerlist_assert_ok(rl
);
1745 /** Free all memory held by the routerlist module. */
1747 routerlist_free_all(void)
1750 routerlist_free(routerlist
);
1752 if (warned_nicknames
) {
1753 SMARTLIST_FOREACH(warned_nicknames
, char *, cp
, tor_free(cp
));
1754 smartlist_free(warned_nicknames
);
1755 warned_nicknames
= NULL
;
1757 if (warned_conflicts
) {
1758 SMARTLIST_FOREACH(warned_conflicts
, char *, cp
, tor_free(cp
));
1759 smartlist_free(warned_conflicts
);
1760 warned_conflicts
= NULL
;
1762 if (trusted_dir_servers
) {
1763 SMARTLIST_FOREACH(trusted_dir_servers
, trusted_dir_server_t
*, ds
,
1764 trusted_dir_server_free(ds
));
1765 smartlist_free(trusted_dir_servers
);
1766 trusted_dir_servers
= NULL
;
1768 if (networkstatus_list
) {
1769 SMARTLIST_FOREACH(networkstatus_list
, networkstatus_t
*, ns
,
1770 networkstatus_free(ns
));
1771 smartlist_free(networkstatus_list
);
1772 networkstatus_list
= NULL
;
1774 if (routerstatus_list
) {
1775 SMARTLIST_FOREACH(routerstatus_list
, local_routerstatus_t
*, rs
,
1776 local_routerstatus_free(rs
));
1777 smartlist_free(routerstatus_list
);
1778 routerstatus_list
= NULL
;
1780 if (named_server_map
) {
1781 strmap_free(named_server_map
, _tor_free
);
1785 /** Free all storage held by the routerstatus object <b>rs</b>. */
1787 routerstatus_free(routerstatus_t
*rs
)
1792 /** Free all storage held by the local_routerstatus object <b>rs</b>. */
1794 local_routerstatus_free(local_routerstatus_t
*rs
)
1799 /** Free all storage held by the networkstatus object <b>ns</b>. */
1801 networkstatus_free(networkstatus_t
*ns
)
1803 tor_free(ns
->source_address
);
1804 tor_free(ns
->contact
);
1805 if (ns
->signing_key
)
1806 crypto_free_pk_env(ns
->signing_key
);
1807 tor_free(ns
->client_versions
);
1808 tor_free(ns
->server_versions
);
1810 SMARTLIST_FOREACH(ns
->entries
, routerstatus_t
*, rs
,
1811 routerstatus_free(rs
));
1812 smartlist_free(ns
->entries
);
1817 /** Forget that we have issued any router-related warnings, so that we'll
1818 * warn again if we see the same errors. */
1820 routerlist_reset_warnings(void)
1822 if (!warned_nicknames
)
1823 warned_nicknames
= smartlist_create();
1824 SMARTLIST_FOREACH(warned_nicknames
, char *, cp
, tor_free(cp
));
1825 smartlist_clear(warned_nicknames
); /* now the list is empty. */
1827 if (!warned_conflicts
)
1828 warned_conflicts
= smartlist_create();
1829 SMARTLIST_FOREACH(warned_conflicts
, char *, cp
, tor_free(cp
));
1830 smartlist_clear(warned_conflicts
); /* now the list is empty. */
1832 if (!routerstatus_list
)
1833 routerstatus_list
= smartlist_create();
1834 SMARTLIST_FOREACH(routerstatus_list
, local_routerstatus_t
*, rs
,
1835 rs
->name_lookup_warned
= 0);
1837 have_warned_about_invalid_status
= 0;
1838 have_warned_about_old_version
= 0;
1839 have_warned_about_new_version
= 0;
1842 /** Mark the router with ID <b>digest</b> as running or non-running
1843 * in our routerlist. */
1845 router_set_status(const char *digest
, int up
)
1847 routerinfo_t
*router
;
1848 local_routerstatus_t
*status
;
1851 SMARTLIST_FOREACH(trusted_dir_servers
, trusted_dir_server_t
*, d
,
1852 if (!memcmp(d
->digest
, digest
, DIGEST_LEN
))
1853 d
->is_running
= up
);
1855 router
= router_get_by_digest(digest
);
1857 log_debug(LD_DIR
,"Marking router '%s' as %s.",
1858 router
->nickname
, up
? "up" : "down");
1859 if (!up
&& router_is_me(router
) && !we_are_hibernating())
1860 log_warn(LD_NET
, "We just marked ourself as down. Are your external "
1861 "addresses reachable?");
1862 router
->is_running
= up
;
1864 status
= router_get_combined_status_by_digest(digest
);
1865 if (status
&& status
->status
.is_running
!= up
) {
1866 status
->status
.is_running
= up
;
1867 control_event_networkstatus_changed_single(status
);
1869 router_dir_info_changed();
1872 /** Add <b>router</b> to the routerlist, if we don't already have it. Replace
1873 * older entries (if any) with the same key. Note: Callers should not hold
1874 * their pointers to <b>router</b> if this function fails; <b>router</b>
1875 * will either be inserted into the routerlist or freed.
1877 * Returns >= 0 if the router was added; less than 0 if it was not.
1879 * If we're returning non-zero, then assign to *<b>msg</b> a static string
1880 * describing the reason for not liking the routerinfo.
1882 * If the return value is less than -1, there was a problem with the
1883 * routerinfo. If the return value is equal to -1, then the routerinfo was
1884 * fine, but out-of-date. If the return value is equal to 1, the
1885 * routerinfo was accepted, but we should notify the generator of the
1886 * descriptor using the message *<b>msg</b>.
1888 * If <b>from_cache</b>, this descriptor came from our disk cache. If
1889 * <b>from_fetch</b>, we received it in response to a request we made.
1890 * (If both are false, that means it was uploaded to us as an auth dir
1891 * server or via the controller.)
1893 * This function should be called *after*
1894 * routers_update_status_from_networkstatus; subsequently, you should call
1895 * router_rebuild_store and control_event_descriptors_changed.
1898 router_add_to_routerlist(routerinfo_t
*router
, const char **msg
,
1899 int from_cache
, int from_fetch
)
1901 const char *id_digest
;
1902 int authdir
= get_options()->AuthoritativeDir
;
1903 int authdir_believes_valid
= 0;
1904 routerinfo_t
*old_router
;
1905 /* router_have_minimum_dir_info() has side effects, so do it before we
1906 * start the real work */
1907 int authdir_may_warn_about_unreachable_server
=
1908 authdir
&& !from_cache
&& !from_fetch
&&
1909 router_have_minimum_dir_info();
1914 router_get_routerlist();
1915 if (!networkstatus_list
)
1916 networkstatus_list
= smartlist_create();
1918 id_digest
= router
->cache_info
.identity_digest
;
1920 /* Make sure that we haven't already got this exact descriptor. */
1921 if (digestmap_get(routerlist
->desc_digest_map
,
1922 router
->cache_info
.signed_descriptor_digest
)) {
1924 "Dropping descriptor that we already have for router '%s'",
1926 *msg
= "Router descriptor was not new.";
1927 routerinfo_free(router
);
1931 if (routerlist_is_overfull(routerlist
))
1932 routerlist_remove_old_routers();
1935 if (authdir_wants_to_reject_router(router
, msg
,
1936 !from_cache
&& !from_fetch
)) {
1938 routerinfo_free(router
);
1941 authdir_believes_valid
= router
->is_valid
;
1942 } else if (from_fetch
) {
1943 /* Only check the descriptor digest against the network statuses when
1944 * we are receiving in response to a fetch. */
1946 if (!signed_desc_digest_is_recognized(&router
->cache_info
)) {
1947 /* We asked for it, so some networkstatus must have listed it when we
1948 * did. Save it if we're a cache in case somebody else asks for it. */
1950 "Received a no-longer-recognized descriptor for router '%s'",
1952 *msg
= "Router descriptor is not referenced by any network-status.";
1954 /* Only journal this desc if we'll be serving it. */
1955 if (!from_cache
&& get_options()->DirPort
)
1956 router_append_to_journal(&router
->cache_info
);
1957 routerlist_insert_old(routerlist
, router
);
1962 /* We no longer need a router with this descriptor digest. */
1963 SMARTLIST_FOREACH(networkstatus_list
, networkstatus_t
*, ns
,
1965 routerstatus_t
*rs
=
1966 networkstatus_find_entry(ns
, router
->cache_info
.identity_digest
);
1967 if (rs
&& !memcmp(rs
->descriptor_digest
,
1968 router
->cache_info
.signed_descriptor_digest
,
1970 rs
->need_to_mirror
= 0;
1973 /* If we have a router with the same identity key, choose the newer one. */
1974 old_router
= digestmap_get(routerlist
->identity_map
,
1975 router
->cache_info
.identity_digest
);
1977 if (router
->cache_info
.published_on
<=
1978 old_router
->cache_info
.published_on
) {
1979 /* Same key, but old */
1980 log_debug(LD_DIR
, "Skipping not-new descriptor for router '%s'",
1982 /* Only journal this desc if we'll be serving it. */
1983 if (!from_cache
&& get_options()->DirPort
)
1984 router_append_to_journal(&router
->cache_info
);
1985 routerlist_insert_old(routerlist
, router
);
1986 *msg
= "Router descriptor was not new.";
1989 /* Same key, new. */
1990 int unreachable
= 0;
1991 log_debug(LD_DIR
, "Replacing entry for router '%s/%s' [%s]",
1992 router
->nickname
, old_router
->nickname
,
1993 hex_str(id_digest
,DIGEST_LEN
));
1994 if (router
->addr
== old_router
->addr
&&
1995 router
->or_port
== old_router
->or_port
) {
1996 /* these carry over when the address and orport are unchanged.*/
1997 router
->last_reachable
= old_router
->last_reachable
;
1998 router
->testing_since
= old_router
->testing_since
;
1999 router
->num_unreachable_notifications
=
2000 old_router
->num_unreachable_notifications
;
2002 if (authdir_may_warn_about_unreachable_server
&&
2003 dirserv_thinks_router_is_blatantly_unreachable(router
, time(NULL
))) {
2004 if (router
->num_unreachable_notifications
>= 3) {
2006 log_notice(LD_DIR
, "Notifying server '%s' that it's unreachable. "
2007 "(ContactInfo '%s', platform '%s').",
2009 router
->contact_info
? router
->contact_info
: "",
2010 router
->platform
? router
->platform
: "");
2012 log_info(LD_DIR
,"'%s' may be unreachable -- the %d previous "
2013 "descriptors were thought to be unreachable.",
2014 router
->nickname
, router
->num_unreachable_notifications
);
2015 router
->num_unreachable_notifications
++;
2018 routerlist_replace(routerlist
, old_router
, router
);
2020 router_append_to_journal(&router
->cache_info
);
2022 directory_set_dirty();
2023 *msg
= unreachable
? "Dirserver believes your ORPort is unreachable" :
2024 authdir_believes_valid
? "Valid server updated" :
2025 ("Invalid server updated. (This dirserver is marking your "
2026 "server as unapproved.)");
2027 return unreachable
? 1 : 0;
2031 /* We haven't seen a router with this identity before. Add it to the end of
2033 routerlist_insert(routerlist
, router
);
2035 router_append_to_journal(&router
->cache_info
);
2036 directory_set_dirty();
2040 /** Sorting helper: return <0, 0, or >0 depending on whether the
2041 * signed_descriptor_t* in *<b>a</b> has an identity digest preceding, equal
2042 * to, or later than that of *<b>b</b>. */
2044 _compare_old_routers_by_identity(const void **_a
, const void **_b
)
2047 const signed_descriptor_t
*r1
= *_a
, *r2
= *_b
;
2048 if ((i
= memcmp(r1
->identity_digest
, r2
->identity_digest
, DIGEST_LEN
)))
2050 return r1
->published_on
- r2
->published_on
;
2053 /** Internal type used to represent how long an old descriptor was valid,
2054 * where it appeared in the list of old descriptors, and whether it's extra
2055 * old. Used only by routerlist_remove_old_cached_routers_with_id(). */
2056 struct duration_idx_t
{
2062 /** Sorting helper: compare two duration_idx_t by their duration. */
2064 _compare_duration_idx(const void *_d1
, const void *_d2
)
2066 const struct duration_idx_t
*d1
= _d1
;
2067 const struct duration_idx_t
*d2
= _d2
;
2068 return d1
->duration
- d2
->duration
;
2071 /** The range <b>lo</b> through <b>hi</b> inclusive of routerlist->old_routers
2072 * must contain routerinfo_t with the same identity and with publication time
2073 * in ascending order. Remove members from this range until there are no more
2074 * than max_descriptors_per_router() remaining. Start by removing the oldest
2075 * members from before <b>cutoff</b>, then remove members which were current
2076 * for the lowest amount of time. The order of members of old_routers at
2077 * indices <b>lo</b> or higher may be changed.
2080 routerlist_remove_old_cached_routers_with_id(time_t cutoff
, int lo
, int hi
,
2081 digestmap_t
*retain
)
2083 int i
, n
= hi
-lo
+1, n_extra
;
2085 struct duration_idx_t
*lifespans
;
2086 uint8_t *rmv
, *must_keep
;
2087 smartlist_t
*lst
= routerlist
->old_routers
;
2090 tor_assert(hi
< smartlist_len(lst
));
2091 tor_assert(lo
<= hi
);
2092 ident
= ((signed_descriptor_t
*)smartlist_get(lst
, lo
))->identity_digest
;
2093 for (i
= lo
+1; i
<= hi
; ++i
) {
2094 signed_descriptor_t
*r
= smartlist_get(lst
, i
);
2095 tor_assert(!memcmp(ident
, r
->identity_digest
, DIGEST_LEN
));
2099 /* Check whether we need to do anything at all. */
2100 n_extra
= n
- max_descriptors_per_router();
2104 lifespans
= tor_malloc_zero(sizeof(struct duration_idx_t
)*n
);
2105 rmv
= tor_malloc_zero(sizeof(uint8_t)*n
);
2106 must_keep
= tor_malloc_zero(sizeof(uint8_t)*n
);
2107 /* Set lifespans to contain the lifespan and index of each server. */
2108 /* Set rmv[i-lo]=1 if we're going to remove a server for being too old. */
2109 for (i
= lo
; i
<= hi
; ++i
) {
2110 signed_descriptor_t
*r
= smartlist_get(lst
, i
);
2111 signed_descriptor_t
*r_next
;
2112 lifespans
[i
-lo
].idx
= i
;
2113 if (retain
&& digestmap_get(retain
, r
->signed_descriptor_digest
)) {
2114 must_keep
[i
-lo
] = 1;
2117 r_next
= smartlist_get(lst
, i
+1);
2118 tor_assert(r
->published_on
<= r_next
->published_on
);
2119 lifespans
[i
-lo
].duration
= (r_next
->published_on
- r
->published_on
);
2122 lifespans
[i
-lo
].duration
= INT_MAX
;
2124 if (!must_keep
[i
-lo
] && r
->published_on
< cutoff
&& n_rmv
< n_extra
) {
2126 lifespans
[i
-lo
].old
= 1;
2131 if (n_rmv
< n_extra
) {
2133 * We aren't removing enough servers for being old. Sort lifespans by
2134 * the duration of liveness, and remove the ones we're not already going to
2135 * remove based on how long they were alive.
2137 qsort(lifespans
, n
, sizeof(struct duration_idx_t
), _compare_duration_idx
);
2138 for (i
= 0; i
< n
&& n_rmv
< n_extra
; ++i
) {
2139 if (!must_keep
[lifespans
[i
].idx
-lo
] && !lifespans
[i
].old
) {
2140 rmv
[lifespans
[i
].idx
-lo
] = 1;
2146 for (i
= hi
; i
>= lo
; --i
) {
2148 routerlist_remove_old(routerlist
, smartlist_get(lst
, i
), i
);
2150 tor_free(must_keep
);
2152 tor_free(lifespans
);
2155 /** Deactivate any routers from the routerlist that are more than
2156 * ROUTER_MAX_AGE seconds old and not recommended by any networkstatuses;
2157 * remove old routers from the list of cached routers if we have too many.
2160 routerlist_remove_old_routers(void)
2163 const char *cur_id
= NULL
;
2164 time_t now
= time(NULL
);
2166 routerinfo_t
*router
;
2167 signed_descriptor_t
*sd
;
2168 digestmap_t
*retain
;
2169 if (!routerlist
|| !networkstatus_list
)
2172 routerlist_assert_ok(routerlist
);
2174 retain
= digestmap_new();
2175 cutoff
= now
- OLD_ROUTER_DESC_MAX_AGE
;
2176 /* Build a list of all the descriptors that _anybody_ recommends. */
2177 SMARTLIST_FOREACH(networkstatus_list
, networkstatus_t
*, ns
,
2179 /* XXXX The inner loop here gets pretty expensive, and actually shows up
2180 * on some profiles. It may be the reason digestmap_set shows up in
2181 * profiles too. If instead we kept a per-descriptor digest count of
2182 * how many networkstatuses recommended each descriptor, and changed
2183 * that only when the networkstatuses changed, that would be a speed
2184 * improvement, possibly 1-4% if it also removes digestmap_set from the
2185 * profile. Not worth it for 0.1.2.x, though. The new directory
2186 * system will obsolete this whole thing in 0.2.0.x. */
2187 SMARTLIST_FOREACH(ns
->entries
, routerstatus_t
*, rs
,
2188 if (rs
->published_on
>= cutoff
)
2189 digestmap_set(retain
, rs
->descriptor_digest
, (void*)1));
2192 /* If we have a bunch of networkstatuses, we should consider pruning current
2193 * routers that are too old and that nobody recommends. (If we don't have
2194 * enough networkstatuses, then we should get more before we decide to kill
2196 if (smartlist_len(networkstatus_list
) > get_n_v2_authorities() / 2) {
2197 cutoff
= now
- ROUTER_MAX_AGE
;
2198 /* Remove too-old unrecommended members of routerlist->routers. */
2199 for (i
= 0; i
< smartlist_len(routerlist
->routers
); ++i
) {
2200 router
= smartlist_get(routerlist
->routers
, i
);
2201 if (router
->cache_info
.published_on
<= cutoff
&&
2202 !digestmap_get(retain
,router
->cache_info
.signed_descriptor_digest
)) {
2203 /* Too old: remove it. (If we're a cache, just move it into
2206 "Forgetting obsolete (too old) routerinfo for router '%s'",
2208 routerlist_remove(routerlist
, router
, i
--, 1);
2213 routerlist_assert_ok(routerlist
);
2215 /* Remove far-too-old members of routerlist->old_routers. */
2216 cutoff
= now
- OLD_ROUTER_DESC_MAX_AGE
;
2217 for (i
= 0; i
< smartlist_len(routerlist
->old_routers
); ++i
) {
2218 sd
= smartlist_get(routerlist
->old_routers
, i
);
2219 if (sd
->published_on
<= cutoff
&&
2220 !digestmap_get(retain
, sd
->signed_descriptor_digest
)) {
2221 /* Too old. Remove it. */
2222 routerlist_remove_old(routerlist
, sd
, i
--);
2226 routerlist_assert_ok(routerlist
);
2228 /* Now we might have to look at routerlist->old_routers for extraneous
2229 * members. (We'd keep all the members if we could, but we need to save
2230 * space.) First, check whether we have too many router descriptors, total.
2231 * We're okay with having too many for some given router, so long as the
2232 * total number doesn't approach max_descriptors_per_router()*len(router).
2234 if (smartlist_len(routerlist
->old_routers
) <
2235 smartlist_len(routerlist
->routers
) * (max_descriptors_per_router() - 1))
2238 smartlist_sort(routerlist
->old_routers
, _compare_old_routers_by_identity
);
2240 /* Iterate through the list from back to front, so when we remove descriptors
2241 * we don't mess up groups we haven't gotten to. */
2242 for (i
= smartlist_len(routerlist
->old_routers
)-1; i
>= 0; --i
) {
2243 signed_descriptor_t
*r
= smartlist_get(routerlist
->old_routers
, i
);
2245 cur_id
= r
->identity_digest
;
2248 if (memcmp(cur_id
, r
->identity_digest
, DIGEST_LEN
)) {
2249 routerlist_remove_old_cached_routers_with_id(cutoff
, i
+1, hi
, retain
);
2250 cur_id
= r
->identity_digest
;
2255 routerlist_remove_old_cached_routers_with_id(cutoff
, 0, hi
, retain
);
2256 routerlist_assert_ok(routerlist
);
2259 digestmap_free(retain
, NULL
);
2263 * Code to parse a single router descriptor and insert it into the
2264 * routerlist. Return -1 if the descriptor was ill-formed; 0 if the
2265 * descriptor was well-formed but could not be added; and 1 if the
2266 * descriptor was added.
2268 * If we don't add it and <b>msg</b> is not NULL, then assign to
2269 * *<b>msg</b> a static string describing the reason for refusing the
2272 * This is used only by the controller.
2275 router_load_single_router(const char *s
, uint8_t purpose
, const char **msg
)
2283 if (!(ri
= router_parse_entry_from_string(s
, NULL
, 1))) {
2284 log_warn(LD_DIR
, "Error parsing router descriptor; dropping.");
2285 *msg
= "Couldn't parse router descriptor.";
2288 ri
->purpose
= purpose
;
2289 if (router_is_me(ri
)) {
2290 log_warn(LD_DIR
, "Router's identity key matches mine; dropping.");
2291 *msg
= "Router's identity key matches mine.";
2292 routerinfo_free(ri
);
2296 lst
= smartlist_create();
2297 smartlist_add(lst
, ri
);
2298 routers_update_status_from_networkstatus(lst
, 0);
2300 if ((r
=router_add_to_routerlist(ri
, msg
, 0, 0))<0) {
2301 /* we've already assigned to *msg now, and ri is already freed */
2304 log_warn(LD_DIR
, "Couldn't add router to list: %s Dropping.", *msg
);
2305 smartlist_free(lst
);
2308 control_event_descriptors_changed(lst
);
2309 smartlist_free(lst
);
2310 log_debug(LD_DIR
, "Added router to list");
2315 /** Given a string <b>s</b> containing some routerdescs, parse it and put the
2316 * routers into our directory. If saved_location is SAVED_NOWHERE, the routers
2317 * are in response to a query to the network: cache them by adding them to
2320 * If <b>requested_fingerprints</b> is provided, it must contain a list of
2321 * uppercased identity fingerprints. Do not update any router whose
2322 * fingerprint is not on the list; after updating a router, remove its
2323 * fingerprint from the list.
2326 router_load_routers_from_string(const char *s
, size_t len
,
2327 saved_location_t saved_location
,
2328 smartlist_t
*requested_fingerprints
)
2330 smartlist_t
*routers
= smartlist_create(), *changed
= smartlist_create();
2331 char fp
[HEX_DIGEST_LEN
+1];
2333 int from_cache
= (saved_location
!= SAVED_NOWHERE
);
2335 router_parse_list_from_string(&s
, s
+len
, routers
, saved_location
);
2337 routers_update_status_from_networkstatus(routers
, !from_cache
);
2339 log_info(LD_DIR
, "%d elements to add", smartlist_len(routers
));
2341 SMARTLIST_FOREACH(routers
, routerinfo_t
*, ri
,
2343 base16_encode(fp
, sizeof(fp
), ri
->cache_info
.signed_descriptor_digest
,
2345 if (requested_fingerprints
) {
2346 if (smartlist_string_isin(requested_fingerprints
, fp
)) {
2347 smartlist_string_remove(requested_fingerprints
, fp
);
2350 smartlist_join_strings(requested_fingerprints
," ",0,NULL
);
2352 "We received a router descriptor with a fingerprint (%s) "
2353 "that we never requested. (We asked for: %s.) Dropping.",
2355 tor_free(requested
);
2356 routerinfo_free(ri
);
2361 if (router_add_to_routerlist(ri
, &msg
, from_cache
, !from_cache
) >= 0)
2362 smartlist_add(changed
, ri
);
2365 if (smartlist_len(changed
))
2366 control_event_descriptors_changed(changed
);
2368 routerlist_assert_ok(routerlist
);
2369 router_rebuild_store(0);
2371 smartlist_free(routers
);
2372 smartlist_free(changed
);
2375 /** Helper: return a newly allocated string containing the name of the filename
2376 * where we plan to cache the network status with the given identity digest. */
2378 networkstatus_get_cache_filename(const char *identity_digest
)
2380 const char *datadir
= get_options()->DataDirectory
;
2381 size_t len
= strlen(datadir
)+64;
2382 char fp
[HEX_DIGEST_LEN
+1];
2383 char *fn
= tor_malloc(len
+1);
2384 base16_encode(fp
, HEX_DIGEST_LEN
+1, identity_digest
, DIGEST_LEN
);
2385 tor_snprintf(fn
, len
, "%s/cached-status/%s",datadir
,fp
);
2389 /** Helper for smartlist_sort: Compare two networkstatus objects by
2390 * publication date. */
2392 _compare_networkstatus_published_on(const void **_a
, const void **_b
)
2394 const networkstatus_t
*a
= *_a
, *b
= *_b
;
2395 if (a
->published_on
< b
->published_on
)
2397 else if (a
->published_on
> b
->published_on
)
2403 /** Add the parsed neworkstatus in <b>ns</b> (with original document in
2404 * <b>s</b> to the disk cache (and the in-memory directory server cache) as
2407 add_networkstatus_to_cache(const char *s
,
2408 networkstatus_source_t source
,
2409 networkstatus_t
*ns
)
2411 if (source
!= NS_FROM_CACHE
) {
2412 char *fn
= networkstatus_get_cache_filename(ns
->identity_digest
);
2413 if (write_str_to_file(fn
, s
, 0)<0) {
2414 log_notice(LD_FS
, "Couldn't write cached network status to \"%s\"", fn
);
2419 if (get_options()->DirPort
)
2420 dirserv_set_cached_networkstatus_v2(s
,
2421 ns
->identity_digest
,
2427 /** How far in the future do we allow a network-status to get before removing
2429 #define NETWORKSTATUS_ALLOW_SKEW (24*60*60)
2431 /** Given a string <b>s</b> containing a network status that we received at
2432 * <b>arrived_at</b> from <b>source</b>, try to parse it, see if we want to
2433 * store it, and put it into our cache as necessary.
2435 * If <b>source</b> is NS_FROM_DIR or NS_FROM_CACHE, do not replace our
2436 * own networkstatus_t (if we're an authoritative directory server).
2438 * If <b>source</b> is NS_FROM_CACHE, do not write our networkstatus_t to the
2441 * If <b>requested_fingerprints</b> is provided, it must contain a list of
2442 * uppercased identity fingerprints. Do not update any networkstatus whose
2443 * fingerprint is not on the list; after updating a networkstatus, remove its
2444 * fingerprint from the list.
2446 * Return 0 on success, -1 on failure.
2448 * Callers should make sure that routers_update_all_from_networkstatus() is
2449 * invoked after this function succeeds.
2452 router_set_networkstatus(const char *s
, time_t arrived_at
,
2453 networkstatus_source_t source
, smartlist_t
*requested_fingerprints
)
2455 networkstatus_t
*ns
;
2459 trusted_dir_server_t
*trusted_dir
= NULL
;
2460 const char *source_desc
= NULL
;
2461 char fp
[HEX_DIGEST_LEN
+1];
2462 char published
[ISO_TIME_LEN
+1];
2464 ns
= networkstatus_parse_from_string(s
);
2466 log_warn(LD_DIR
, "Couldn't parse network status.");
2469 base16_encode(fp
, HEX_DIGEST_LEN
+1, ns
->identity_digest
, DIGEST_LEN
);
2471 router_get_trusteddirserver_by_digest(ns
->identity_digest
)) ||
2472 !trusted_dir
->is_v2_authority
) {
2473 log_info(LD_DIR
, "Network status was signed, but not by an authoritative "
2474 "directory we recognize.");
2475 if (!get_options()->DirPort
) {
2476 networkstatus_free(ns
);
2481 source_desc
= trusted_dir
->description
;
2484 if (arrived_at
> now
)
2487 ns
->received_on
= arrived_at
;
2489 format_iso_time(published
, ns
->published_on
);
2491 if (ns
->published_on
> now
+ NETWORKSTATUS_ALLOW_SKEW
) {
2492 log_warn(LD_GENERAL
, "Network status from %s was published in the future "
2493 "(%s GMT). Somebody is skewed here: check your clock. "
2495 source_desc
, published
);
2496 control_event_general_status(LOG_WARN
,
2497 "CLOCK_SKEW SOURCE=NETWORKSTATUS:%s:%d",
2498 ns
->source_address
, ns
->source_dirport
);
2502 if (!networkstatus_list
)
2503 networkstatus_list
= smartlist_create();
2505 if ( (source
== NS_FROM_DIR_BY_FP
|| source
== NS_FROM_DIR_ALL
) &&
2506 router_digest_is_me(ns
->identity_digest
)) {
2507 /* Don't replace our own networkstatus when we get it from somebody else.*/
2508 networkstatus_free(ns
);
2512 if (requested_fingerprints
) {
2513 if (smartlist_string_isin(requested_fingerprints
, fp
)) {
2514 smartlist_string_remove(requested_fingerprints
, fp
);
2516 if (source
!= NS_FROM_DIR_ALL
) {
2518 smartlist_join_strings(requested_fingerprints
," ",0,NULL
);
2520 "We received a network status with a fingerprint (%s) that we "
2521 "never requested. (We asked for: %s.) Dropping.",
2523 tor_free(requested
);
2530 if (!skewed
&& get_options()->DirPort
) {
2531 /* We got a non-trusted networkstatus, and we're a directory cache.
2532 * This means that we asked an authority, and it told us about another
2533 * authority we didn't recognize. */
2535 "We do not recognize authority (%s) but we are willing "
2537 add_networkstatus_to_cache(s
, source
, ns
);
2538 networkstatus_free(ns
);
2544 for (i
=0; i
< smartlist_len(networkstatus_list
); ++i
) {
2545 networkstatus_t
*old_ns
= smartlist_get(networkstatus_list
, i
);
2547 if (!memcmp(old_ns
->identity_digest
, ns
->identity_digest
, DIGEST_LEN
)) {
2548 if (!memcmp(old_ns
->networkstatus_digest
,
2549 ns
->networkstatus_digest
, DIGEST_LEN
)) {
2550 /* Same one we had before. */
2551 networkstatus_free(ns
);
2552 tor_assert(trusted_dir
);
2554 "Not replacing network-status from %s (published %s); "
2555 "we already have it.",
2556 trusted_dir
->description
, published
);
2557 if (old_ns
->received_on
< arrived_at
) {
2558 if (source
!= NS_FROM_CACHE
) {
2560 fn
= networkstatus_get_cache_filename(old_ns
->identity_digest
);
2561 /* We use mtime to tell when it arrived, so update that. */
2565 old_ns
->received_on
= arrived_at
;
2567 ++trusted_dir
->n_networkstatus_failures
;
2569 } else if (old_ns
->published_on
>= ns
->published_on
) {
2570 char old_published
[ISO_TIME_LEN
+1];
2571 format_iso_time(old_published
, old_ns
->published_on
);
2572 tor_assert(trusted_dir
);
2574 "Not replacing network-status from %s (published %s);"
2575 " we have a newer one (published %s) for this authority.",
2576 trusted_dir
->description
, published
,
2578 networkstatus_free(ns
);
2579 ++trusted_dir
->n_networkstatus_failures
;
2582 networkstatus_free(old_ns
);
2583 smartlist_set(networkstatus_list
, i
, ns
);
2590 if (source
!= NS_FROM_CACHE
&& trusted_dir
)
2591 trusted_dir
->n_networkstatus_failures
= 0;
2594 smartlist_add(networkstatus_list
, ns
);
2596 SMARTLIST_FOREACH(ns
->entries
, routerstatus_t
*, rs
,
2598 if (!router_get_by_descriptor_digest(rs
->descriptor_digest
))
2599 rs
->need_to_mirror
= 1;
2602 log_info(LD_DIR
, "Setting networkstatus %s %s (published %s)",
2603 source
== NS_FROM_CACHE
?"cached from":
2604 ((source
== NS_FROM_DIR_BY_FP
|| source
== NS_FROM_DIR_ALL
) ?
2605 "downloaded from":"generated for"),
2606 trusted_dir
->description
, published
);
2607 networkstatus_list_has_changed
= 1;
2608 router_dir_info_changed();
2610 smartlist_sort(networkstatus_list
, _compare_networkstatus_published_on
);
2613 add_networkstatus_to_cache(s
, source
, ns
);
2615 networkstatus_list_update_recent(now
);
2620 /** How old do we allow a network-status to get before removing it
2622 #define MAX_NETWORKSTATUS_AGE (10*24*60*60)
2623 /** Remove all very-old network_status_t objects from memory and from the
2626 networkstatus_list_clean(time_t now
)
2629 if (!networkstatus_list
)
2632 for (i
= 0; i
< smartlist_len(networkstatus_list
); ++i
) {
2633 networkstatus_t
*ns
= smartlist_get(networkstatus_list
, i
);
2635 if (ns
->published_on
+ MAX_NETWORKSTATUS_AGE
> now
)
2637 /* Okay, this one is too old. Remove it from the list, and delete it
2638 * from the cache. */
2639 smartlist_del(networkstatus_list
, i
--);
2640 fname
= networkstatus_get_cache_filename(ns
->identity_digest
);
2641 if (file_status(fname
) == FN_FILE
) {
2642 log_info(LD_DIR
, "Removing too-old networkstatus in %s", fname
);
2646 if (get_options()->DirPort
) {
2647 dirserv_set_cached_networkstatus_v2(NULL
, ns
->identity_digest
, 0);
2649 networkstatus_free(ns
);
2650 router_dir_info_changed();
2653 /* And now go through the directory cache for any cached untrusted
2654 * networkstatuses and other network info. */
2655 dirserv_clear_old_networkstatuses(now
- MAX_NETWORKSTATUS_AGE
);
2656 dirserv_clear_old_v1_info(now
);
2659 /** Helper for bsearching a list of routerstatus_t pointers.*/
2661 _compare_digest_to_routerstatus_entry(const void *_key
, const void **_member
)
2663 const char *key
= _key
;
2664 const routerstatus_t
*rs
= *_member
;
2665 return memcmp(key
, rs
->identity_digest
, DIGEST_LEN
);
2668 /** Return the entry in <b>ns</b> for the identity digest <b>digest</b>, or
2669 * NULL if none was found. */
2670 static routerstatus_t
*
2671 networkstatus_find_entry(networkstatus_t
*ns
, const char *digest
)
2673 return smartlist_bsearch(ns
->entries
, digest
,
2674 _compare_digest_to_routerstatus_entry
);
2677 /** Return the consensus view of the status of the router whose digest is
2678 * <b>digest</b>, or NULL if we don't know about any such router. */
2679 local_routerstatus_t
*
2680 router_get_combined_status_by_digest(const char *digest
)
2682 if (!routerstatus_list
)
2684 return smartlist_bsearch(routerstatus_list
, digest
,
2685 _compare_digest_to_routerstatus_entry
);
2688 /** Return a newly allocated list of the local_routerstatus_t for all routers
2689 * where we believe that the digest of their current descriptor is some digest
2690 * listed in <b>digests</b>. */
2692 router_get_combined_status_by_descriptor_digests(smartlist_t
*digests
)
2695 smartlist_t
*result
;
2697 if (!routerstatus_list
)
2700 map
= digestmap_new();
2701 result
= smartlist_create();
2702 SMARTLIST_FOREACH(digests
, const char *, d
, digestmap_set(map
, d
, (void*)1));
2704 SMARTLIST_FOREACH(routerstatus_list
, local_routerstatus_t
*, lrs
, {
2705 if (digestmap_get(map
, lrs
->status
.descriptor_digest
))
2706 smartlist_add(result
, lrs
);
2709 digestmap_free(map
, NULL
);
2713 /** Given a nickname (possibly verbose, possibly a hexadecimal digest), return
2714 * the corresponding local_routerstatus_t, or NULL if none exists. Warn the
2715 * user if <b>warn_if_unnamed</b> is set, and they have specified a router by
2716 * nickname, but the Named flag isn't set for that router. */
2717 static local_routerstatus_t
*
2718 router_get_combined_status_by_nickname(const char *nickname
,
2719 int warn_if_unnamed
)
2721 char digest
[DIGEST_LEN
];
2722 local_routerstatus_t
*best
=NULL
;
2723 smartlist_t
*matches
=NULL
;
2725 if (!routerstatus_list
|| !nickname
)
2728 if (nickname
[0] == '$') {
2729 if (base16_decode(digest
, DIGEST_LEN
, nickname
+1, strlen(nickname
))<0)
2731 return router_get_combined_status_by_digest(digest
);
2732 } else if (strlen(nickname
) == HEX_DIGEST_LEN
&&
2733 (base16_decode(digest
, DIGEST_LEN
, nickname
+1, strlen(nickname
))==0)) {
2734 return router_get_combined_status_by_digest(digest
);
2737 matches
= smartlist_create();
2738 SMARTLIST_FOREACH(routerstatus_list
, local_routerstatus_t
*, lrs
,
2740 if (!strcasecmp(lrs
->status
.nickname
, nickname
)) {
2741 if (lrs
->status
.is_named
) {
2742 smartlist_free(matches
);
2745 smartlist_add(matches
, lrs
);
2751 if (smartlist_len(matches
)>1 && warn_if_unnamed
) {
2753 SMARTLIST_FOREACH(matches
, local_routerstatus_t
*, lrs
,
2755 if (! lrs
->name_lookup_warned
) {
2756 lrs
->name_lookup_warned
=1;
2761 log_warn(LD_CONFIG
,"There are multiple matches for the nickname \"%s\","
2762 " but none is listed as named by the directory authorites. "
2763 "Choosing one arbitrarily.", nickname
);
2765 } else if (warn_if_unnamed
&& best
&& !best
->name_lookup_warned
) {
2766 char fp
[HEX_DIGEST_LEN
+1];
2767 base16_encode(fp
, sizeof(fp
),
2768 best
->status
.identity_digest
, DIGEST_LEN
);
2770 "When looking up a status, you specified a server \"%s\" by name, "
2771 "but the directory authorities do not have any key registered for "
2772 "this nickname -- so it could be used by any server, "
2773 "not just the one you meant. "
2774 "To make sure you get the same server in the future, refer to "
2775 "it by key, as \"$%s\".", nickname
, fp
);
2776 best
->name_lookup_warned
= 1;
2778 smartlist_free(matches
);
2782 /** Find a routerstatus_t that corresponds to <b>hexdigest</b>, if
2783 * any. Prefer ones that belong to authorities. */
2785 routerstatus_get_by_hexdigest(const char *hexdigest
)
2787 char digest
[DIGEST_LEN
];
2788 local_routerstatus_t
*rs
;
2789 trusted_dir_server_t
*ds
;
2791 if (strlen(hexdigest
) < HEX_DIGEST_LEN
||
2792 base16_decode(digest
,DIGEST_LEN
,hexdigest
,HEX_DIGEST_LEN
) < 0)
2794 if ((ds
= router_get_trusteddirserver_by_digest(digest
)))
2795 return &(ds
->fake_status
.status
);
2796 if ((rs
= router_get_combined_status_by_digest(digest
)))
2797 return &(rs
->status
);
2801 /** Return true iff any networkstatus includes a descriptor whose digest
2802 * is that of <b>desc</b>. */
2804 signed_desc_digest_is_recognized(signed_descriptor_t
*desc
)
2807 if (!networkstatus_list
)
2810 SMARTLIST_FOREACH(networkstatus_list
, networkstatus_t
*, ns
,
2812 if (!(rs
= networkstatus_find_entry(ns
, desc
->identity_digest
)))
2814 if (!memcmp(rs
->descriptor_digest
,
2815 desc
->signed_descriptor_digest
, DIGEST_LEN
))
2821 /** How frequently do directory authorities re-download fresh networkstatus
2823 #define AUTHORITY_NS_CACHE_INTERVAL (5*60)
2825 /** How frequently do non-authority directory caches re-download fresh
2826 * networkstatus documents? */
2827 #define NONAUTHORITY_NS_CACHE_INTERVAL (15*60)
2829 /** We are a directory server, and so cache network_status documents.
2830 * Initiate downloads as needed to update them. For authorities, this means
2831 * asking each trusted directory for its network-status. For caches, this
2832 * means asking a random authority for all network-statuses.
2835 update_networkstatus_cache_downloads(time_t now
)
2837 int authority
= authdir_mode(get_options());
2839 authority
? AUTHORITY_NS_CACHE_INTERVAL
: NONAUTHORITY_NS_CACHE_INTERVAL
;
2841 if (last_networkstatus_download_attempted
+ interval
>= now
)
2843 if (!trusted_dir_servers
)
2846 last_networkstatus_download_attempted
= now
;
2849 /* An authority launches a separate connection for everybody. */
2850 SMARTLIST_FOREACH(trusted_dir_servers
, trusted_dir_server_t
*, ds
,
2852 char resource
[HEX_DIGEST_LEN
+6]; /* fp/hexdigit.z\0 */
2853 if (!ds
->is_v2_authority
)
2855 if (router_digest_is_me(ds
->digest
))
2857 if (connection_get_by_type_addr_port_purpose(
2858 CONN_TYPE_DIR
, ds
->addr
, ds
->dir_port
,
2859 DIR_PURPOSE_FETCH_NETWORKSTATUS
)) {
2860 /* We are already fetching this one. */
2863 strlcpy(resource
, "fp/", sizeof(resource
));
2864 base16_encode(resource
+3, sizeof(resource
)-3, ds
->digest
, DIGEST_LEN
);
2865 strlcat(resource
, ".z", sizeof(resource
));
2866 directory_initiate_command_routerstatus(
2867 &ds
->fake_status
.status
, DIR_PURPOSE_FETCH_NETWORKSTATUS
,
2868 0, /* Not private */
2870 NULL
, 0 /* No payload. */);
2873 /* A non-authority cache launches one connection to a random authority. */
2874 /* (Check whether we're currently fetching network-status objects.) */
2875 if (!connection_get_by_type_purpose(CONN_TYPE_DIR
,
2876 DIR_PURPOSE_FETCH_NETWORKSTATUS
))
2877 directory_get_from_dirserver(DIR_PURPOSE_FETCH_NETWORKSTATUS
,"all.z",1);
2881 /** How long (in seconds) does a client wait after getting a network status
2882 * before downloading the next in sequence? */
2883 #define NETWORKSTATUS_CLIENT_DL_INTERVAL (30*60)
2884 /** How many times do we allow a networkstatus download to fail before we
2885 * assume that the authority isn't publishing? */
2886 #define NETWORKSTATUS_N_ALLOWABLE_FAILURES 3
2887 /** We are not a directory cache or authority. Update our network-status list
2888 * by launching a new directory fetch for enough network-status documents "as
2889 * necessary". See function comments for implementation details.
2892 update_networkstatus_client_downloads(time_t now
)
2894 int n_live
= 0, n_dirservers
, n_running_dirservers
, needed
= 0;
2895 int fetch_latest
= 0;
2896 int most_recent_idx
= -1;
2897 trusted_dir_server_t
*most_recent
= NULL
;
2898 time_t most_recent_received
= 0;
2899 char *resource
, *cp
;
2900 size_t resource_len
;
2901 smartlist_t
*missing
;
2903 if (connection_get_by_type_purpose(CONN_TYPE_DIR
,
2904 DIR_PURPOSE_FETCH_NETWORKSTATUS
))
2907 /* This is a little tricky. We want to download enough network-status
2908 * objects so that we have all of them under
2909 * NETWORKSTATUS_MAX_AGE publication time. We want to download a new
2910 * *one* if the most recent one's publication time is under
2911 * NETWORKSTATUS_CLIENT_DL_INTERVAL.
2913 if (!get_n_v2_authorities())
2915 n_dirservers
= n_running_dirservers
= 0;
2916 missing
= smartlist_create();
2917 SMARTLIST_FOREACH(trusted_dir_servers
, trusted_dir_server_t
*, ds
,
2919 networkstatus_t
*ns
= networkstatus_get_by_digest(ds
->digest
);
2920 if (!ds
->is_v2_authority
)
2923 if (ds
->n_networkstatus_failures
> NETWORKSTATUS_N_ALLOWABLE_FAILURES
)
2925 ++n_running_dirservers
;
2926 if (ns
&& ns
->published_on
> now
-NETWORKSTATUS_MAX_AGE
)
2929 smartlist_add(missing
, ds
->digest
);
2930 if (ns
&& (!most_recent
|| ns
->received_on
> most_recent_received
)) {
2931 most_recent_idx
= ds_sl_idx
; /* magic variable from FOREACH */
2933 most_recent_received
= ns
->received_on
;
2937 /* Also, download at least 1 every NETWORKSTATUS_CLIENT_DL_INTERVAL. */
2938 if (!smartlist_len(missing
) &&
2939 most_recent_received
< now
-NETWORKSTATUS_CLIENT_DL_INTERVAL
) {
2940 log_info(LD_DIR
, "Our most recent network-status document (from %s) "
2941 "is %d seconds old; downloading another.",
2942 most_recent
?most_recent
->description
:"nobody",
2943 (int)(now
-most_recent_received
));
2946 } else if (smartlist_len(missing
)) {
2947 log_info(LD_DIR
, "For %d/%d running directory servers, we have %d live"
2948 " network-status documents. Downloading %d.",
2949 n_running_dirservers
, n_dirservers
, n_live
,
2950 smartlist_len(missing
));
2951 needed
= smartlist_len(missing
);
2953 smartlist_free(missing
);
2957 /* If no networkstatus was found, choose a dirserver at random as "most
2959 if (most_recent_idx
<0)
2960 most_recent_idx
= crypto_rand_int(smartlist_len(trusted_dir_servers
));
2965 for (i
= most_recent_idx
+ 1; 1; ++i
) {
2966 trusted_dir_server_t
*ds
;
2967 if (i
>= smartlist_len(trusted_dir_servers
))
2969 ds
= smartlist_get(trusted_dir_servers
, i
);
2970 if (! ds
->is_v2_authority
)
2972 if (n_failed
>= n_dirservers
) {
2973 log_info(LD_DIR
, "All authorities have failed. Not trying any.");
2974 smartlist_free(missing
);
2977 if (ds
->n_networkstatus_failures
> NETWORKSTATUS_N_ALLOWABLE_FAILURES
) {
2981 smartlist_add(missing
, ds
->digest
);
2986 /* Build a request string for all the resources we want. */
2987 resource_len
= smartlist_len(missing
) * (HEX_DIGEST_LEN
+1) + 6;
2988 resource
= tor_malloc(resource_len
);
2989 memcpy(resource
, "fp/", 3);
2991 smartlist_sort_digests(missing
);
2992 needed
= smartlist_len(missing
);
2993 SMARTLIST_FOREACH(missing
, const char *, d
,
2995 base16_encode(cp
, HEX_DIGEST_LEN
+1, d
, DIGEST_LEN
);
2996 cp
+= HEX_DIGEST_LEN
;
3001 memcpy(cp
, ".z", 3);
3002 directory_get_from_dirserver(DIR_PURPOSE_FETCH_NETWORKSTATUS
, resource
, 1);
3004 smartlist_free(missing
);
3007 /** Launch requests for networkstatus documents as appropriate. */
3009 update_networkstatus_downloads(time_t now
)
3011 or_options_t
*options
= get_options();
3012 if (options
->DirPort
)
3013 update_networkstatus_cache_downloads(now
);
3015 update_networkstatus_client_downloads(now
);
3018 /** Return 1 if all running sufficiently-stable routers will reject
3019 * addr:port, return 0 if any might accept it. */
3021 router_exit_policy_all_routers_reject(uint32_t addr
, uint16_t port
,
3024 addr_policy_result_t r
;
3025 if (!routerlist
) return 1;
3027 SMARTLIST_FOREACH(routerlist
->routers
, routerinfo_t
*, router
,
3029 if (router
->is_running
&&
3030 !router_is_unreliable(router
, need_uptime
, 0, 0)) {
3031 r
= compare_addr_to_addr_policy(addr
, port
, router
->exit_policy
);
3032 if (r
!= ADDR_POLICY_REJECTED
&& r
!= ADDR_POLICY_PROBABLY_REJECTED
)
3033 return 0; /* this one could be ok. good enough. */
3036 return 1; /* all will reject. */
3039 /** Return true iff <b>router</b> does not permit exit streams.
3042 router_exit_policy_rejects_all(routerinfo_t
*router
)
3044 return compare_addr_to_addr_policy(0, 0, router
->exit_policy
)
3045 == ADDR_POLICY_REJECTED
;
3048 /** Add to the list of authorized directory servers one at
3049 * <b>address</b>:<b>port</b>, with identity key <b>digest</b>. If
3050 * <b>address</b> is NULL, add ourself. */
3052 add_trusted_dir_server(const char *nickname
, const char *address
,
3053 uint16_t dir_port
, uint16_t or_port
,
3054 const char *digest
, int is_v1_authority
,
3055 int is_v2_authority
, int is_hidserv_authority
)
3057 trusted_dir_server_t
*ent
;
3059 char *hostname
= NULL
;
3061 if (!trusted_dir_servers
)
3062 trusted_dir_servers
= smartlist_create();
3064 if (!address
) { /* The address is us; we should guess. */
3065 if (resolve_my_address(LOG_WARN
, get_options(), &a
, &hostname
) < 0) {
3067 "Couldn't find a suitable address when adding ourself as a "
3068 "trusted directory server.");
3072 if (tor_lookup_hostname(address
, &a
)) {
3074 "Unable to lookup address for directory server at '%s'",
3078 hostname
= tor_strdup(address
);
3082 ent
= tor_malloc_zero(sizeof(trusted_dir_server_t
));
3083 ent
->nickname
= nickname
? tor_strdup(nickname
) : NULL
;
3084 ent
->address
= hostname
;
3086 ent
->dir_port
= dir_port
;
3087 ent
->or_port
= or_port
;
3088 ent
->is_running
= 1;
3089 ent
->is_v1_authority
= is_v1_authority
;
3090 ent
->is_v2_authority
= is_v2_authority
;
3091 ent
->is_hidserv_authority
= is_hidserv_authority
;
3092 memcpy(ent
->digest
, digest
, DIGEST_LEN
);
3094 dlen
= 64 + strlen(hostname
) + (nickname
?strlen(nickname
):0);
3095 ent
->description
= tor_malloc(dlen
);
3097 tor_snprintf(ent
->description
, dlen
, "directory server \"%s\" at %s:%d",
3098 nickname
, hostname
, (int)dir_port
);
3100 tor_snprintf(ent
->description
, dlen
, "directory server at %s:%d",
3101 hostname
, (int)dir_port
);
3103 ent
->fake_status
.status
.addr
= ent
->addr
;
3104 memcpy(ent
->fake_status
.status
.identity_digest
, digest
, DIGEST_LEN
);
3106 strlcpy(ent
->fake_status
.status
.nickname
, nickname
,
3107 sizeof(ent
->fake_status
.status
.nickname
));
3109 ent
->fake_status
.status
.nickname
[0] = '\0';
3110 ent
->fake_status
.status
.dir_port
= ent
->dir_port
;
3111 ent
->fake_status
.status
.or_port
= ent
->or_port
;
3113 smartlist_add(trusted_dir_servers
, ent
);
3114 router_dir_info_changed();
3117 /** Free storage held in <b>ds</b> */
3119 trusted_dir_server_free(trusted_dir_server_t
*ds
)
3121 tor_free(ds
->nickname
);
3122 tor_free(ds
->description
);
3123 tor_free(ds
->address
);
3127 /** Remove all members from the list of trusted dir servers. */
3129 clear_trusted_dir_servers(void)
3131 if (trusted_dir_servers
) {
3132 SMARTLIST_FOREACH(trusted_dir_servers
, trusted_dir_server_t
*, ent
,
3133 trusted_dir_server_free(ent
));
3134 smartlist_clear(trusted_dir_servers
);
3136 trusted_dir_servers
= smartlist_create();
3138 router_dir_info_changed();
3141 /** Return 1 if any trusted dir server supports v1 directories,
3144 any_trusted_dir_is_v1_authority(void)
3146 if (trusted_dir_servers
)
3147 SMARTLIST_FOREACH(trusted_dir_servers
, trusted_dir_server_t
*, ent
,
3148 if (ent
->is_v1_authority
) return 1);
3152 /** Return the network status with a given identity digest. */
3154 networkstatus_get_by_digest(const char *digest
)
3156 SMARTLIST_FOREACH(networkstatus_list
, networkstatus_t
*, ns
,
3158 if (!memcmp(ns
->identity_digest
, digest
, DIGEST_LEN
))
3164 /** We believe networkstatuses more recent than this when they tell us that
3165 * our server is broken, invalid, obsolete, etc. */
3166 #define SELF_OPINION_INTERVAL (90*60)
3168 /** Result of checking whether a version is recommended. */
3169 typedef struct combined_version_status_t
{
3170 /** How many networkstatuses claim to know about versions? */
3172 /** What do the majority of networkstatuses believe about this version? */
3173 version_status_t consensus
;
3174 /** How many networkstatuses constitute the majority? */
3176 } combined_version_status_t
;
3178 /** Return a string naming the versions of Tor recommended by
3179 * more than half the versioning networkstatuses. */
3181 compute_recommended_versions(time_t now
, int client
,
3182 const char *my_version
,
3183 combined_version_status_t
*status_out
)
3187 smartlist_t
*combined
, *recommended
;
3188 int n_versioning
, n_recommending
;
3190 /** holds the compromise status taken among all non-recommending
3192 version_status_t consensus
= VS_RECOMMENDED
;
3193 (void) now
; /* right now, we consider *all* statuses, regardless of age. */
3195 tor_assert(my_version
);
3196 tor_assert(status_out
);
3198 memset(status_out
, 0, sizeof(combined_version_status_t
));
3200 if (!networkstatus_list
)
3201 return tor_strdup("<none>");
3203 combined
= smartlist_create();
3204 n_versioning
= n_recommending
= 0;
3205 SMARTLIST_FOREACH(networkstatus_list
, networkstatus_t
*, ns
,
3208 smartlist_t
*versions
;
3209 version_status_t status
;
3210 if (! ns
->recommends_versions
)
3213 vers
= client
? ns
->client_versions
: ns
->server_versions
;
3216 versions
= smartlist_create();
3217 smartlist_split_string(versions
, vers
, ",",
3218 SPLIT_SKIP_SPACE
|SPLIT_IGNORE_BLANK
, 0);
3219 sort_version_list(versions
, 1);
3220 smartlist_add_all(combined
, versions
);
3221 smartlist_free(versions
);
3223 /* now, check _our_ version */
3224 status
= tor_version_is_obsolete(my_version
, vers
);
3225 if (status
== VS_RECOMMENDED
)
3227 consensus
= version_status_join(status
, consensus
);
3230 sort_version_list(combined
, 0);
3234 recommended
= smartlist_create();
3235 SMARTLIST_FOREACH(combined
, char *, cp
,
3237 if (current
&& !strcmp(cp
, current
)) {
3240 if (n_seen
> n_versioning
/2 && current
)
3241 smartlist_add(recommended
, current
);
3246 if (n_seen
> n_versioning
/2 && current
)
3247 smartlist_add(recommended
, current
);
3249 result
= smartlist_join_strings(recommended
, ", ", 0, NULL
);
3251 SMARTLIST_FOREACH(combined
, char *, cp
, tor_free(cp
));
3252 smartlist_free(combined
);
3253 smartlist_free(recommended
);
3255 status_out
->n_versioning
= n_versioning
;
3256 if (n_recommending
> n_versioning
/2) {
3257 status_out
->consensus
= VS_RECOMMENDED
;
3258 status_out
->n_concurring
= n_recommending
;
3260 status_out
->consensus
= consensus
;
3261 status_out
->n_concurring
= n_versioning
- n_recommending
;
3267 /** How many times do we have to fail at getting a networkstatus we can't find
3268 * before we're willing to believe it's okay to set up router statuses? */
3269 #define N_NS_ATTEMPTS_TO_SET_ROUTERS 4
3270 /** How many times do we have to fail at getting a networkstatus we can't find
3271 * before we're willing to believe it's okay to check our version? */
3272 #define N_NS_ATTEMPTS_TO_CHECK_VERSION 4
3274 /** If the network-status list has changed since the last time we called this
3275 * function, update the status of every routerinfo from the network-status
3279 routers_update_all_from_networkstatus(void)
3283 if (!routerlist
|| !networkstatus_list
||
3284 (!networkstatus_list_has_changed
&& !routerstatus_list_has_changed
))
3287 router_dir_info_changed();
3290 if (networkstatus_list_has_changed
)
3291 routerstatus_list_update_from_networkstatus(now
);
3293 routers_update_status_from_networkstatus(routerlist
->routers
, 0);
3295 me
= router_get_my_routerinfo();
3296 if (me
&& !have_warned_about_invalid_status
&&
3297 have_tried_downloading_all_statuses(N_NS_ATTEMPTS_TO_SET_ROUTERS
)) {
3298 int n_recent
= 0, n_listing
= 0, n_valid
= 0, n_named
= 0, n_naming
= 0;
3300 SMARTLIST_FOREACH(networkstatus_list
, networkstatus_t
*, ns
,
3302 if (ns
->received_on
+ SELF_OPINION_INTERVAL
< now
)
3305 if (ns
->binds_names
)
3307 if (!(rs
= networkstatus_find_entry(ns
, me
->cache_info
.identity_digest
)))
3317 if (n_valid
<= n_listing
/2) {
3318 log_info(LD_GENERAL
,
3319 "%d/%d recent statements from directory authorities list us "
3320 "as unapproved. Are you misconfigured?",
3321 n_listing
-n_valid
, n_listing
);
3322 have_warned_about_invalid_status
= 1;
3323 } else if (n_naming
&& !n_named
) {
3324 log_info(LD_GENERAL
, "0/%d name-binding directory authorities "
3325 "recognize your nickname. Please consider sending your "
3326 "nickname and identity fingerprint to the tor-ops.",
3328 have_warned_about_invalid_status
= 1;
3333 entry_guards_compute_status();
3335 if (!have_warned_about_old_version
&&
3336 have_tried_downloading_all_statuses(N_NS_ATTEMPTS_TO_CHECK_VERSION
)) {
3337 combined_version_status_t st
;
3338 int is_server
= server_mode(get_options());
3341 recommended
= compute_recommended_versions(now
, !is_server
, VERSION
, &st
);
3343 if (st
.n_versioning
) {
3344 if (st
.consensus
== VS_RECOMMENDED
) {
3345 log_info(LD_GENERAL
, "%d/%d statements from version-listing "
3346 "directory authorities say my version is ok.",
3347 st
.n_concurring
, st
.n_versioning
);
3348 } else if (st
.consensus
== VS_NEW
|| st
.consensus
== VS_NEW_IN_SERIES
) {
3349 if (!have_warned_about_new_version
) {
3350 log_notice(LD_GENERAL
, "This version of Tor (%s) is newer than any "
3351 "recommended version%s, according to %d/%d version-listing "
3352 "network statuses. Versions recommended by more than %d "
3353 "authorit%s are: %s",
3355 st
.consensus
== VS_NEW_IN_SERIES
? " in its series" : "",
3356 st
.n_concurring
, st
.n_versioning
, st
.n_versioning
/2,
3357 st
.n_versioning
/2 > 1 ? "ies" : "y", recommended
);
3358 have_warned_about_new_version
= 1;
3359 control_event_general_status(LOG_WARN
, "DANGEROUS_VERSION "
3360 "CURRENT=%s REASON=%s RECOMMENDED=\"%s\"",
3361 VERSION
, "NEW", recommended
);
3364 log_warn(LD_GENERAL
, "Please upgrade! "
3365 "This version of Tor (%s) is %s, according to %d/%d version-"
3366 "listing network statuses. Versions recommended by "
3367 "at least %d authorit%s are: %s",
3369 st
.consensus
== VS_OLD
? "obsolete" : "not recommended",
3370 st
.n_concurring
, st
.n_versioning
, st
.n_versioning
/2,
3371 st
.n_versioning
/2 > 1 ? "ies" : "y", recommended
);
3372 have_warned_about_old_version
= 1;
3373 control_event_general_status(LOG_WARN
, "DANGEROUS_VERSION "
3374 "CURRENT=%s REASON=%s RECOMMENDED=\"%s\"",
3375 VERSION
, st
.consensus
== VS_OLD
? "OLD" : "UNRECOMMENDED",
3379 tor_free(recommended
);
3382 routerstatus_list_has_changed
= 0;
3385 /** Allow any network-status newer than this to influence our view of who's
3387 #define DEFAULT_RUNNING_INTERVAL (60*60)
3388 /** If possible, always allow at least this many network-statuses to influence
3389 * our view of who's running. */
3390 #define MIN_TO_INFLUENCE_RUNNING 3
3392 /** Change the is_recent field of each member of networkstatus_list so that
3393 * all members more recent than DEFAULT_RUNNING_INTERVAL are recent, and
3394 * at least the MIN_TO_INFLUENCE_RUNNING most recent members are recent, and no
3395 * others are recent. Set networkstatus_list_has_changed if anything happened.
3398 networkstatus_list_update_recent(time_t now
)
3400 int n_statuses
, n_recent
, changed
, i
;
3401 char published
[ISO_TIME_LEN
+1];
3403 if (!networkstatus_list
)
3406 n_statuses
= smartlist_len(networkstatus_list
);
3409 for (i
=n_statuses
-1; i
>= 0; --i
) {
3410 networkstatus_t
*ns
= smartlist_get(networkstatus_list
, i
);
3411 trusted_dir_server_t
*ds
=
3412 router_get_trusteddirserver_by_digest(ns
->identity_digest
);
3413 const char *src
= ds
?ds
->description
:ns
->source_address
;
3414 if (n_recent
< MIN_TO_INFLUENCE_RUNNING
||
3415 ns
->published_on
+ DEFAULT_RUNNING_INTERVAL
> now
) {
3416 if (!ns
->is_recent
) {
3417 format_iso_time(published
, ns
->published_on
);
3419 "Networkstatus from %s (published %s) is now \"recent\"",
3426 if (ns
->is_recent
) {
3427 format_iso_time(published
, ns
->published_on
);
3429 "Networkstatus from %s (published %s) is "
3430 "no longer \"recent\"",
3438 networkstatus_list_has_changed
= 1;
3439 router_dir_info_changed();
3443 /** Helper for routerstatus_list_update_from_networkstatus: remember how many
3444 * authorities recommend a given descriptor digest. */
3448 } desc_digest_count_t
;
3450 /** Update our view of router status (as stored in routerstatus_list) from the
3451 * current set of network status documents (as stored in networkstatus_list).
3452 * Do nothing unless the network status list has changed since the last time
3453 * this function was called.
3456 routerstatus_list_update_from_networkstatus(time_t now
)
3458 or_options_t
*options
= get_options();
3459 int n_trusted
, n_statuses
, n_recent
= 0, n_naming
= 0;
3460 int n_listing_bad_exits
= 0, n_listing_bad_directories
= 0;
3463 networkstatus_t
**networkstatus
;
3464 smartlist_t
*result
, *changed_list
;
3466 char conflict
[DIGEST_LEN
]; /* Sentinel value */
3467 desc_digest_count_t
*digest_counts
= NULL
;
3469 /* compute which network statuses will have a vote now */
3470 networkstatus_list_update_recent(now
);
3471 router_dir_info_changed();
3473 if (!networkstatus_list_has_changed
)
3475 if (!networkstatus_list
)
3476 networkstatus_list
= smartlist_create();
3477 if (!routerstatus_list
)
3478 routerstatus_list
= smartlist_create();
3479 if (!trusted_dir_servers
)
3480 trusted_dir_servers
= smartlist_create();
3481 if (!warned_conflicts
)
3482 warned_conflicts
= smartlist_create();
3484 n_statuses
= smartlist_len(networkstatus_list
);
3485 n_trusted
= get_n_v2_authorities();
3487 if (n_statuses
<= n_trusted
/2) {
3488 /* Not enough statuses to adjust status. */
3490 "Not enough statuses to update router status list. (%d/%d)",
3491 n_statuses
, n_trusted
);
3495 log_info(LD_DIR
, "Rebuilding router status list.");
3497 index
= tor_malloc(sizeof(int)*n_statuses
);
3498 size
= tor_malloc(sizeof(int)*n_statuses
);
3499 networkstatus
= tor_malloc(sizeof(networkstatus_t
*)*n_statuses
);
3500 for (i
= 0; i
< n_statuses
; ++i
) {
3502 networkstatus
[i
] = smartlist_get(networkstatus_list
, i
);
3503 size
[i
] = smartlist_len(networkstatus
[i
]->entries
);
3504 if (networkstatus
[i
]->binds_names
)
3506 if (networkstatus
[i
]->is_recent
)
3508 if (networkstatus
[i
]->lists_bad_exits
)
3509 ++n_listing_bad_exits
;
3510 if (networkstatus
[i
]->lists_bad_directories
)
3511 ++n_listing_bad_directories
;
3514 /** Iterate over all entries in all networkstatuses, and build
3515 * name_map as a map from lc nickname to identity digest. If there
3516 * is a conflict on that nickname, map the lc nickname to conflict.
3518 name_map
= strmap_new();
3519 /* Clear the global map... */
3520 if (named_server_map
)
3521 strmap_free(named_server_map
, _tor_free
);
3522 named_server_map
= strmap_new();
3523 memset(conflict
, 0xff, sizeof(conflict
));
3524 for (i
= 0; i
< n_statuses
; ++i
) {
3525 if (!networkstatus
[i
]->binds_names
)
3527 SMARTLIST_FOREACH(networkstatus
[i
]->entries
, routerstatus_t
*, rs
,
3529 const char *other_digest
;
3532 other_digest
= strmap_get_lc(name_map
, rs
->nickname
);
3533 warned
= smartlist_string_isin(warned_conflicts
, rs
->nickname
);
3534 if (!other_digest
) {
3535 strmap_set_lc(name_map
, rs
->nickname
, rs
->identity_digest
);
3536 strmap_set_lc(named_server_map
, rs
->nickname
,
3537 tor_memdup(rs
->identity_digest
, DIGEST_LEN
));
3539 smartlist_string_remove(warned_conflicts
, rs
->nickname
);
3540 } else if (memcmp(other_digest
, rs
->identity_digest
, DIGEST_LEN
) &&
3541 other_digest
!= conflict
) {
3544 int should_warn
= options
->DirPort
&& options
->AuthoritativeDir
;
3545 char fp1
[HEX_DIGEST_LEN
+1];
3546 char fp2
[HEX_DIGEST_LEN
+1];
3547 base16_encode(fp1
, sizeof(fp1
), other_digest
, DIGEST_LEN
);
3548 base16_encode(fp2
, sizeof(fp2
), rs
->identity_digest
, DIGEST_LEN
);
3549 log_fn(should_warn
? LOG_WARN
: LOG_INFO
, LD_DIR
,
3550 "Naming authorities disagree about which key goes with %s. "
3552 rs
->nickname
, fp1
, fp2
);
3553 strmap_set_lc(name_map
, rs
->nickname
, conflict
);
3554 d
= strmap_remove_lc(named_server_map
, rs
->nickname
);
3556 smartlist_add(warned_conflicts
, tor_strdup(rs
->nickname
));
3560 smartlist_string_remove(warned_conflicts
, rs
->nickname
);
3565 result
= smartlist_create();
3566 changed_list
= smartlist_create();
3567 digest_counts
= tor_malloc_zero(sizeof(desc_digest_count_t
)*n_statuses
);
3569 /* Iterate through all of the sorted routerstatus lists in lockstep.
3571 * - For 0 <= i < n_statuses: index[i] is an index into
3572 * networkstatus[i]->entries, which has size[i] elements.
3573 * - For i1, i2, j such that 0 <= i1 < n_statuses, 0 <= i2 < n_statues, 0 <=
3574 * j < index[i1]: networkstatus[i1]->entries[j]->identity_digest <
3575 * networkstatus[i2]->entries[index[i2]]->identity_digest.
3577 * (That is, the indices are always advanced past lower digest before
3581 int n_running
=0, n_named
=0, n_valid
=0, n_listing
=0;
3582 int n_v2_dir
=0, n_fast
=0, n_stable
=0, n_exit
=0, n_guard
=0, n_bad_exit
=0;
3583 int n_bad_directory
=0;
3584 int n_version_known
=0, n_supports_begindir
=0;
3585 int n_desc_digests
=0, highest_count
=0;
3586 const char *the_name
= NULL
;
3587 local_routerstatus_t
*rs_out
, *rs_old
;
3588 routerstatus_t
*rs
, *most_recent
;
3589 networkstatus_t
*ns
;
3590 const char *lowest
= NULL
;
3592 /* Find out which of the digests appears first. */
3593 for (i
= 0; i
< n_statuses
; ++i
) {
3594 if (index
[i
] < size
[i
]) {
3595 rs
= smartlist_get(networkstatus
[i
]->entries
, index
[i
]);
3596 if (!lowest
|| memcmp(rs
->identity_digest
, lowest
, DIGEST_LEN
)<0)
3597 lowest
= rs
->identity_digest
;
3601 /* We're out of routers. Great! */
3604 /* Okay. The routers at networkstatus[i]->entries[index[i]] whose digests
3605 * match "lowest" are next in order. Iterate over them, incrementing those
3606 * index[i] as we go. */
3607 for (i
= 0; i
< n_statuses
; ++i
) {
3608 if (index
[i
] >= size
[i
])
3610 ns
= networkstatus
[i
];
3611 rs
= smartlist_get(ns
->entries
, index
[i
]);
3612 if (memcmp(rs
->identity_digest
, lowest
, DIGEST_LEN
))
3614 /* At this point, we know that we're looking at a routersatus with
3615 * identity "lowest".
3619 /* Should we name this router? Only if all the names from naming
3620 * authorities match. */
3621 if (rs
->is_named
&& ns
->binds_names
) {
3623 the_name
= rs
->nickname
;
3624 if (!strcasecmp(rs
->nickname
, the_name
)) {
3626 } else if (strcmp(the_name
,"**mismatch**")) {
3627 char hd
[HEX_DIGEST_LEN
+1];
3628 base16_encode(hd
, HEX_DIGEST_LEN
+1, rs
->identity_digest
, DIGEST_LEN
);
3629 if (! smartlist_string_isin(warned_conflicts
, hd
)) {
3631 "Naming authorities disagree about nicknames for $%s "
3632 "(\"%s\" vs \"%s\")",
3633 hd
, the_name
, rs
->nickname
);
3634 smartlist_add(warned_conflicts
, tor_strdup(hd
));
3636 the_name
= "**mismatch**";
3639 /* Keep a running count of how often which descriptor digests
3641 for (j
= 0; j
< n_desc_digests
; ++j
) {
3642 if (!memcmp(rs
->descriptor_digest
,
3643 digest_counts
[j
].rs
->descriptor_digest
, DIGEST_LEN
)) {
3644 if (++digest_counts
[j
].count
> highest_count
)
3645 highest_count
= digest_counts
[j
].count
;
3649 digest_counts
[n_desc_digests
].rs
= rs
;
3650 digest_counts
[n_desc_digests
].count
= 1;
3655 /* Now tally up the easily-tallied flags. */
3658 if (rs
->is_running
&& ns
->is_recent
)
3664 if (rs
->is_possible_guard
)
3670 if (rs
->is_bad_exit
)
3672 if (rs
->is_bad_directory
)
3674 if (rs
->version_known
)
3676 if (rs
->version_supports_begindir
)
3677 ++n_supports_begindir
;
3679 /* Go over the descriptor digests and figure out which descriptor we
3682 for (i
= 0; i
< n_desc_digests
; ++i
) {
3683 /* If any digest appears twice or more, ignore those that don't.*/
3684 if (highest_count
>= 2 && digest_counts
[i
].count
< 2)
3687 digest_counts
[i
].rs
->published_on
> most_recent
->published_on
)
3688 most_recent
= digest_counts
[i
].rs
;
3690 rs_out
= tor_malloc_zero(sizeof(local_routerstatus_t
));
3691 memcpy(&rs_out
->status
, most_recent
, sizeof(routerstatus_t
));
3692 /* Copy status info about this router, if we had any before. */
3693 if ((rs_old
= router_get_combined_status_by_digest(lowest
))) {
3694 if (!memcmp(rs_out
->status
.descriptor_digest
,
3695 most_recent
->descriptor_digest
, DIGEST_LEN
)) {
3696 rs_out
->n_download_failures
= rs_old
->n_download_failures
;
3697 rs_out
->next_attempt_at
= rs_old
->next_attempt_at
;
3699 rs_out
->name_lookup_warned
= rs_old
->name_lookup_warned
;
3700 rs_out
->last_dir_503_at
= rs_old
->last_dir_503_at
;
3702 smartlist_add(result
, rs_out
);
3703 log_debug(LD_DIR
, "Router '%s' is listed by %d/%d directories, "
3704 "named by %d/%d, validated by %d/%d, and %d/%d recent "
3705 "directories think it's running.",
3706 rs_out
->status
.nickname
,
3707 n_listing
, n_statuses
, n_named
, n_naming
, n_valid
, n_statuses
,
3708 n_running
, n_recent
);
3709 rs_out
->status
.is_named
= 0;
3710 if (the_name
&& strcmp(the_name
, "**mismatch**") && n_named
> 0) {
3711 const char *d
= strmap_get_lc(name_map
, the_name
);
3712 if (d
&& d
!= conflict
)
3713 rs_out
->status
.is_named
= 1;
3714 if (smartlist_string_isin(warned_conflicts
, rs_out
->status
.nickname
))
3715 smartlist_string_remove(warned_conflicts
, rs_out
->status
.nickname
);
3717 if (rs_out
->status
.is_named
)
3718 strlcpy(rs_out
->status
.nickname
, the_name
,
3719 sizeof(rs_out
->status
.nickname
));
3720 rs_out
->status
.is_valid
= n_valid
> n_statuses
/2;
3721 rs_out
->status
.is_running
= n_running
> n_recent
/2;
3722 rs_out
->status
.is_exit
= n_exit
> n_statuses
/2;
3723 rs_out
->status
.is_fast
= n_fast
> n_statuses
/2;
3724 rs_out
->status
.is_possible_guard
= n_guard
> n_statuses
/2;
3725 rs_out
->status
.is_stable
= n_stable
> n_statuses
/2;
3726 rs_out
->status
.is_v2_dir
= n_v2_dir
> n_statuses
/2;
3727 rs_out
->status
.is_bad_exit
= n_bad_exit
> n_listing_bad_exits
/2;
3728 rs_out
->status
.is_bad_directory
=
3729 n_bad_directory
> n_listing_bad_directories
/2;
3730 rs_out
->status
.version_known
= n_version_known
> 0;
3731 rs_out
->status
.version_supports_begindir
=
3732 n_supports_begindir
> n_version_known
/2;
3733 if (!rs_old
|| memcmp(rs_old
, rs_out
, sizeof(local_routerstatus_t
)))
3734 smartlist_add(changed_list
, rs_out
);
3736 SMARTLIST_FOREACH(routerstatus_list
, local_routerstatus_t
*, rs
,
3737 local_routerstatus_free(rs
));
3739 smartlist_free(routerstatus_list
);
3740 routerstatus_list
= result
;
3742 tor_free(networkstatus
);
3745 tor_free(digest_counts
);
3746 strmap_free(name_map
, NULL
);
3748 networkstatus_list_has_changed
= 0;
3749 routerstatus_list_has_changed
= 1;
3751 control_event_networkstatus_changed(changed_list
);
3752 smartlist_free(changed_list
);
3755 /** Given a list <b>routers</b> of routerinfo_t *, update each routers's
3756 * is_named, is_valid, and is_running fields according to our current
3757 * networkstatus_t documents. */
3759 routers_update_status_from_networkstatus(smartlist_t
*routers
,
3762 trusted_dir_server_t
*ds
;
3763 local_routerstatus_t
*rs
;
3764 or_options_t
*options
= get_options();
3765 int authdir
= options
->AuthoritativeDir
;
3766 int namingdir
= options
->AuthoritativeDir
&&
3767 options
->NamingAuthoritativeDir
;
3769 if (!routerstatus_list
)
3772 SMARTLIST_FOREACH(routers
, routerinfo_t
*, router
,
3774 const char *digest
= router
->cache_info
.identity_digest
;
3775 rs
= router_get_combined_status_by_digest(digest
);
3776 ds
= router_get_trusteddirserver_by_digest(digest
);
3782 router
->is_named
= rs
->status
.is_named
;
3785 /* If we're not an authdir, believe others. */
3786 router
->is_valid
= rs
->status
.is_valid
;
3787 router
->is_running
= rs
->status
.is_running
;
3788 router
->is_fast
= rs
->status
.is_fast
;
3789 router
->is_stable
= rs
->status
.is_stable
;
3790 router
->is_possible_guard
= rs
->status
.is_possible_guard
;
3791 router
->is_exit
= rs
->status
.is_exit
;
3792 router
->is_bad_exit
= rs
->status
.is_bad_exit
;
3794 if (router
->is_running
&& ds
) {
3795 ds
->n_networkstatus_failures
= 0;
3797 if (reset_failures
) {
3798 rs
->n_download_failures
= 0;
3799 rs
->next_attempt_at
= 0;
3802 router_dir_info_changed();
3805 /** For every router descriptor we are currently downloading by descriptor
3806 * digest, set result[d] to 1. */
3808 list_pending_descriptor_downloads(digestmap_t
*result
)
3810 const char *prefix
= "d/";
3811 size_t p_len
= strlen(prefix
);
3813 connection_t
**carray
;
3814 smartlist_t
*tmp
= smartlist_create();
3817 get_connection_array(&carray
, &n_conns
);
3819 for (i
= 0; i
< n_conns
; ++i
) {
3820 connection_t
*conn
= carray
[i
];
3821 if (conn
->type
== CONN_TYPE_DIR
&&
3822 conn
->purpose
== DIR_PURPOSE_FETCH_SERVERDESC
&&
3823 !conn
->marked_for_close
) {
3824 const char *resource
= TO_DIR_CONN(conn
)->requested_resource
;
3825 if (!strcmpstart(resource
, prefix
))
3826 dir_split_resource_into_fingerprints(resource
+ p_len
,
3830 SMARTLIST_FOREACH(tmp
, char *, d
,
3832 digestmap_set(result
, d
, (void*)1);
3835 smartlist_free(tmp
);
3838 /** Launch downloads for all the descriptors whose digests are listed
3839 * as digests[i] for lo <= i < hi. (Lo and hi may be out of range.)
3840 * If <b>source</b> is given, download from <b>source</b>; otherwise,
3841 * download from an appropriate random directory server.
3844 initiate_descriptor_downloads(routerstatus_t
*source
,
3845 smartlist_t
*digests
,
3849 char *resource
, *cp
;
3855 if (hi
> smartlist_len(digests
))
3856 hi
= smartlist_len(digests
);
3858 r_len
= 8 + (HEX_DIGEST_LEN
+1)*n
;
3859 cp
= resource
= tor_malloc(r_len
);
3860 memcpy(cp
, "d/", 2);
3862 for (i
= lo
; i
< hi
; ++i
) {
3863 base16_encode(cp
, r_len
-(cp
-resource
),
3864 smartlist_get(digests
,i
), DIGEST_LEN
);
3865 cp
+= HEX_DIGEST_LEN
;
3868 memcpy(cp
-1, ".z", 3);
3871 /* We know which authority we want. */
3872 directory_initiate_command_routerstatus(source
,
3873 DIR_PURPOSE_FETCH_SERVERDESC
,
3874 0, /* not private */
3877 directory_get_from_dirserver(DIR_PURPOSE_FETCH_SERVERDESC
,
3884 /** Clients don't download any descriptor this recent, since it will probably
3885 * not have propageted to enough caches. */
3886 #define ESTIMATED_PROPAGATION_TIME (10*60)
3888 /** Return 0 if this routerstatus is obsolete, too new, isn't
3889 * running, or otherwise not a descriptor that we would make any
3890 * use of even if we had it. Else return 1. */
3892 client_would_use_router(routerstatus_t
*rs
, time_t now
, or_options_t
*options
)
3894 if (!rs
->is_running
&& !options
->FetchUselessDescriptors
) {
3895 /* If we had this router descriptor, we wouldn't even bother using it.
3896 * But, if we want to have a complete list, fetch it anyway. */
3899 if (rs
->published_on
+ ESTIMATED_PROPAGATION_TIME
> now
) {
3900 /* Most caches probably don't have this descriptor yet. */
3906 /** Return new list of ID fingerprints for routers that we (as a client) would
3909 static smartlist_t
*
3910 router_list_client_downloadable(void)
3912 int n_downloadable
= 0;
3913 smartlist_t
*downloadable
= smartlist_create();
3914 digestmap_t
*downloading
;
3915 time_t now
= time(NULL
);
3916 /* these are just used for logging */
3917 int n_not_ready
= 0, n_in_progress
= 0, n_uptodate
= 0, n_wouldnt_use
= 0;
3918 or_options_t
*options
= get_options();
3920 if (!routerstatus_list
)
3921 return downloadable
;
3923 downloading
= digestmap_new();
3924 list_pending_descriptor_downloads(downloading
);
3926 routerstatus_list_update_from_networkstatus(now
);
3927 SMARTLIST_FOREACH(routerstatus_list
, local_routerstatus_t
*, rs
,
3930 if (router_get_by_descriptor_digest(rs
->status
.descriptor_digest
)) {
3931 /* We have the 'best' descriptor for this router. */
3933 } else if (!client_would_use_router(&rs
->status
, now
, options
)) {
3934 /* We wouldn't want this descriptor even if we got it. */
3936 } else if (digestmap_get(downloading
, rs
->status
.descriptor_digest
)) {
3937 /* We're downloading this one now. */
3939 } else if ((ri
= router_get_by_digest(rs
->status
.identity_digest
)) &&
3940 ri
->cache_info
.published_on
> rs
->status
.published_on
) {
3941 /* Oddly, we have a descriptor more recent than the 'best' one, but it
3942 was once best. So that's okay. */
3944 } else if (rs
->next_attempt_at
> now
) {
3945 /* We failed too recently to try again. */
3948 /* Okay, time to try it. */
3949 smartlist_add(downloadable
, rs
->status
.descriptor_digest
);
3956 "%d router descriptors are downloadable. "
3957 "%d are in progress. %d are up-to-date. "
3958 "%d are non-useful. %d failed too recently to retry.",
3959 n_downloadable
, n_in_progress
, n_uptodate
,
3960 n_wouldnt_use
, n_not_ready
);
3963 digestmap_free(downloading
, NULL
);
3964 return downloadable
;
3967 /** Initiate new router downloads as needed, using the strategy for
3968 * non-directory-servers.
3970 * We don't launch any downloads if there are fewer than MAX_DL_TO_DELAY
3971 * descriptors to get and less than MAX_CLIENT_INTERVAL_WITHOUT_REQUEST
3972 * seconds have passed.
3974 * Otherwise, we ask for all descriptors that we think are different from what
3975 * we have, and that we don't currently have an in-progress download attempt
3978 update_router_descriptor_client_downloads(time_t now
)
3980 /** Max amount of hashes to download per request.
3981 * Since squid does not like URLs >= 4096 bytes we limit it to 96.
3982 * 4096 - strlen(http://255.255.255.255/tor/server/d/.z) == 4058
3983 * 4058/41 (40 for the hash and 1 for the + that separates them) => 98
3984 * So use 96 because it's a nice number.
3986 #define MAX_DL_PER_REQUEST 96
3987 /** Don't split our requests so finely that we are requesting fewer than
3988 * this number per server. */
3989 #define MIN_DL_PER_REQUEST 4
3990 /** To prevent a single screwy cache from confusing us by selective reply,
3991 * try to split our requests into at least this this many requests. */
3992 #define MIN_REQUESTS 3
3993 /** If we want fewer than this many descriptors, wait until we
3994 * want more, or until MAX_CLIENT_INTERVAL_WITHOUT_REQUEST has
3996 #define MAX_DL_TO_DELAY 16
3997 /** When directory clients have only a few servers to request, they batch
3998 * them until they have more, or until this amount of time has passed. */
3999 #define MAX_CLIENT_INTERVAL_WITHOUT_REQUEST (10*60)
4000 smartlist_t
*downloadable
= NULL
;
4001 int should_delay
, n_downloadable
;
4002 or_options_t
*options
= get_options();
4004 if (options
->DirPort
) {
4006 "Called router_descriptor_client_downloads() on a dir mirror?");
4009 if (rep_hist_circbuilding_dormant(now
)) {
4010 log_info(LD_CIRC
, "Skipping descriptor downloads: we haven't needed "
4011 "any circuits lately.");
4015 if (networkstatus_list
&&
4016 smartlist_len(networkstatus_list
) <= get_n_v2_authorities()/2) {
4018 "Not enough networkstatus documents to launch requests.");
4022 downloadable
= router_list_client_downloadable();
4023 n_downloadable
= smartlist_len(downloadable
);
4024 if (n_downloadable
>= MAX_DL_TO_DELAY
) {
4026 "There are enough downloadable routerdescs to launch requests.");
4028 } else if (n_downloadable
== 0) {
4029 // log_debug(LD_DIR, "No routerdescs need to be downloaded.");
4032 should_delay
= (last_routerdesc_download_attempted
+
4033 MAX_CLIENT_INTERVAL_WITHOUT_REQUEST
) > now
;
4034 if (!should_delay
) {
4035 if (last_routerdesc_download_attempted
) {
4037 "There are not many downloadable routerdescs, but we've "
4038 "been waiting long enough (%d seconds). Downloading.",
4039 (int)(now
-last_routerdesc_download_attempted
));
4042 "There are not many downloadable routerdescs, but we haven't "
4043 "tried downloading descriptors recently. Downloading.");
4048 if (! should_delay
) {
4049 int i
, n_per_request
;
4050 n_per_request
= (n_downloadable
+MIN_REQUESTS
-1) / MIN_REQUESTS
;
4051 if (n_per_request
> MAX_DL_PER_REQUEST
)
4052 n_per_request
= MAX_DL_PER_REQUEST
;
4053 if (n_per_request
< MIN_DL_PER_REQUEST
)
4054 n_per_request
= MIN_DL_PER_REQUEST
;
4057 "Launching %d request%s for %d router%s, %d at a time",
4058 (n_downloadable
+n_per_request
-1)/n_per_request
,
4059 n_downloadable
>n_per_request
?"s":"",
4060 n_downloadable
, n_downloadable
>1?"s":"", n_per_request
);
4061 smartlist_sort_digests(downloadable
);
4062 for (i
=0; i
< n_downloadable
; i
+= n_per_request
) {
4063 initiate_descriptor_downloads(NULL
, downloadable
, i
, i
+n_per_request
);
4065 last_routerdesc_download_attempted
= now
;
4067 smartlist_free(downloadable
);
4070 /** Launch downloads for router status as needed, using the strategy used by
4071 * authorities and caches: download every descriptor we don't have but would
4072 * serve, from a random authority that lists it. */
4074 update_router_descriptor_cache_downloads(time_t now
)
4076 smartlist_t
**downloadable
; /* For each authority, what can we dl from it? */
4077 smartlist_t
**download_from
; /* ... and, what will we dl from it? */
4078 digestmap_t
*map
; /* Which descs are in progress, or assigned? */
4081 or_options_t
*options
= get_options();
4084 if (!options
->DirPort
) {
4085 log_warn(LD_BUG
, "Called update_router_descriptor_cache_downloads() "
4086 "on a non-dir-mirror?");
4089 if (!networkstatus_list
|| !smartlist_len(networkstatus_list
))
4092 map
= digestmap_new();
4093 n
= smartlist_len(networkstatus_list
);
4095 downloadable
= tor_malloc_zero(sizeof(smartlist_t
*) * n
);
4096 download_from
= tor_malloc_zero(sizeof(smartlist_t
*) * n
);
4098 /* Set map[d]=1 for the digest of every descriptor that we are currently
4100 list_pending_descriptor_downloads(map
);
4102 /* For the digest of every descriptor that we don't have, and that we aren't
4103 * downloading, add d to downloadable[i] if the i'th networkstatus knows
4104 * about that descriptor, and we haven't already failed to get that
4105 * descriptor from the corresponding authority.
4108 SMARTLIST_FOREACH(networkstatus_list
, networkstatus_t
*, ns
,
4110 trusted_dir_server_t
*ds
;
4112 dl
= downloadable
[ns_sl_idx
] = smartlist_create();
4113 download_from
[ns_sl_idx
] = smartlist_create();
4114 if (ns
->published_on
+ MAX_NETWORKSTATUS_AGE
+10*60 < now
) {
4115 /* Don't download if the networkstatus is almost ancient. */
4116 /* Actually, I suspect what's happening here is that we ask
4117 * for the descriptor when we have a given networkstatus,
4118 * and then we get a newer networkstatus, and then we receive
4119 * the descriptor. Having a networkstatus actually expire is
4120 * probably a rare event, and we'll probably be happiest if
4121 * we take this clause out. -RD */
4125 /* Don't try dirservers that we think are down -- we might have
4126 * just tried them and just marked them as down. */
4127 ds
= router_get_trusteddirserver_by_digest(ns
->identity_digest
);
4128 if (ds
&& !ds
->is_running
)
4131 SMARTLIST_FOREACH(ns
->entries
, routerstatus_t
* , rs
,
4133 if (!rs
->need_to_mirror
)
4135 if (router_get_by_descriptor_digest(rs
->descriptor_digest
)) {
4137 "Bug: We have a router descriptor, but need_to_mirror=1.");
4138 rs
->need_to_mirror
= 0;
4141 if (options
->AuthoritativeDir
&& dirserv_would_reject_router(rs
)) {
4142 rs
->need_to_mirror
= 0;
4145 if (digestmap_get(map
, rs
->descriptor_digest
)) {
4146 /* We're downloading it already. */
4149 /* We could download it from this guy. */
4150 smartlist_add(dl
, rs
->descriptor_digest
);
4156 /* At random, assign descriptors to authorities such that:
4157 * - if d is a member of some downloadable[x], d is a member of some
4158 * download_from[y]. (Everything we want to download, we try to download
4160 * - If d is a member of download_from[y], d is a member of downloadable[y].
4161 * (We only try to download descriptors from authorities who claim to have
4163 * - No d is a member of download_from[x] and download_from[y] s.t. x != y.
4164 * (We don't try to download anything from two authorities concurrently.)
4166 while (n_download
) {
4167 int which_ns
= crypto_rand_int(n
);
4168 smartlist_t
*dl
= downloadable
[which_ns
];
4171 if (!smartlist_len(dl
))
4173 idx
= crypto_rand_int(smartlist_len(dl
));
4174 d
= smartlist_get(dl
, idx
);
4175 if (! digestmap_get(map
, d
)) {
4176 smartlist_add(download_from
[which_ns
], d
);
4177 digestmap_set(map
, d
, (void*) 1);
4179 smartlist_del(dl
, idx
);
4183 /* Now, we can actually launch our requests. */
4184 for (i
=0; i
<n
; ++i
) {
4185 networkstatus_t
*ns
= smartlist_get(networkstatus_list
, i
);
4186 trusted_dir_server_t
*ds
=
4187 router_get_trusteddirserver_by_digest(ns
->identity_digest
);
4188 smartlist_t
*dl
= download_from
[i
];
4190 log_warn(LD_BUG
, "Networkstatus with no corresponding authority!");
4193 if (! smartlist_len(dl
))
4195 log_info(LD_DIR
, "Requesting %d descriptors from authority \"%s\"",
4196 smartlist_len(dl
), ds
->nickname
);
4197 for (j
=0; j
< smartlist_len(dl
); j
+= MAX_DL_PER_REQUEST
) {
4198 initiate_descriptor_downloads(&(ds
->fake_status
.status
), dl
, j
,
4199 j
+MAX_DL_PER_REQUEST
);
4203 for (i
=0; i
<n
; ++i
) {
4204 smartlist_free(download_from
[i
]);
4205 smartlist_free(downloadable
[i
]);
4207 tor_free(download_from
);
4208 tor_free(downloadable
);
4209 digestmap_free(map
,NULL
);
4212 /** Launch downloads for router status as needed. */
4214 update_router_descriptor_downloads(time_t now
)
4216 or_options_t
*options
= get_options();
4217 if (options
->DirPort
) {
4218 update_router_descriptor_cache_downloads(now
);
4220 update_router_descriptor_client_downloads(now
);
4224 /** Return the number of routerstatus_t in <b>entries</b> that we'd actually
4227 routerstatus_count_usable_entries(smartlist_t
*entries
)
4230 time_t now
= time(NULL
);
4231 or_options_t
*options
= get_options();
4232 SMARTLIST_FOREACH(entries
, routerstatus_t
*, rs
,
4233 if (client_would_use_router(rs
, now
, options
)) count
++);
4237 /** True iff, the last time we checked whether we had enough directory info
4238 * to build circuits, the answer was "yes". */
4239 static int have_min_dir_info
= 0;
4240 /** True iff enough has changed since the last time we checked whether we had
4241 * enough directory info to build circuits that our old answer can no longer
4243 static int need_to_update_have_min_dir_info
= 1;
4245 /** Return true iff we have enough networkstatus and router information to
4246 * start building circuits. Right now, this means "more than half the
4247 * networkstatus documents, and at least 1/4 of expected routers." */
4248 //XXX should consider whether we have enough exiting nodes here.
4250 router_have_minimum_dir_info(void)
4252 if (PREDICT(need_to_update_have_min_dir_info
, 0)) {
4253 update_router_have_minimum_dir_info();
4254 need_to_update_have_min_dir_info
= 0;
4256 return have_min_dir_info
;
4259 /** Called when our internal view of the directory has changed. This can be
4260 * when the authorities change, networkstatuses change, the list of routerdescs
4261 * changes, or number of running routers changes.
4264 router_dir_info_changed(void)
4266 need_to_update_have_min_dir_info
= 1;
4269 /** Change the value of have_min_dir_info, setting it true iff we have enough
4270 * network and router information to build circuits. Clear the value of
4271 * need_to_update_have_min_dir_info. */
4273 update_router_have_minimum_dir_info(void)
4275 int tot
= 0, num_running
= 0;
4276 int n_ns
, n_authorities
, res
, avg
;
4277 time_t now
= time(NULL
);
4278 if (!networkstatus_list
|| !routerlist
) {
4282 routerlist_remove_old_routers();
4283 networkstatus_list_clean(now
);
4285 n_authorities
= get_n_v2_authorities();
4286 n_ns
= smartlist_len(networkstatus_list
);
4287 if (n_ns
<=n_authorities
/2) {
4289 "We have %d of %d network statuses, and we want "
4290 "more than %d.", n_ns
, n_authorities
, n_authorities
/2);
4294 SMARTLIST_FOREACH(networkstatus_list
, networkstatus_t
*, ns
,
4295 tot
+= routerstatus_count_usable_entries(ns
->entries
));
4297 if (!routerstatus_list
)
4298 routerstatus_list
= smartlist_create();
4299 SMARTLIST_FOREACH(routerstatus_list
, local_routerstatus_t
*, rs
,
4301 if (rs
->status
.is_running
)
4304 res
= smartlist_len(routerlist
->routers
) >= (avg
/4) && num_running
> 2;
4306 if (res
&& !have_min_dir_info
) {
4307 log(LOG_NOTICE
, LD_DIR
,
4308 "We now have enough directory information to build circuits.");
4309 control_event_client_status(LOG_NOTICE
, "ENOUGH_DIR_INFO");
4311 if (!res
&& have_min_dir_info
) {
4312 log(LOG_NOTICE
, LD_DIR
,"Our directory information is no longer up-to-date "
4313 "enough to build circuits.%s",
4314 num_running
> 2 ? "" : " (Not enough servers seem reachable -- "
4315 "is your network connection down?)");
4316 control_event_client_status(LOG_NOTICE
, "NOT_ENOUGH_DIR_INFO");
4318 have_min_dir_info
= res
;
4321 /** Return true iff we have downloaded, or attempted to download at least
4322 * n_failures times, a network status for each authority. */
4324 have_tried_downloading_all_statuses(int n_failures
)
4326 if (!trusted_dir_servers
)
4329 SMARTLIST_FOREACH(trusted_dir_servers
, trusted_dir_server_t
*, ds
,
4331 if (!ds
->is_v2_authority
)
4333 /* If we don't have the status, and we haven't failed to get the status,
4334 * we haven't tried to get the status. */
4335 if (!networkstatus_get_by_digest(ds
->digest
) &&
4336 ds
->n_networkstatus_failures
<= n_failures
)
4343 /** Reset the descriptor download failure count on all routers, so that we
4344 * can retry any long-failed routers immediately.
4347 router_reset_descriptor_download_failures(void)
4349 if (!routerstatus_list
)
4351 SMARTLIST_FOREACH(routerstatus_list
, local_routerstatus_t
*, rs
,
4353 rs
->n_download_failures
= 0;
4354 rs
->next_attempt_at
= 0;
4356 tor_assert(networkstatus_list
);
4357 SMARTLIST_FOREACH(networkstatus_list
, networkstatus_t
*, ns
,
4358 SMARTLIST_FOREACH(ns
->entries
, routerstatus_t
*, rs
,
4360 if (!router_get_by_descriptor_digest(rs
->descriptor_digest
))
4361 rs
->need_to_mirror
= 1;
4363 last_routerdesc_download_attempted
= 0;
4366 /** Any changes in a router descriptor's publication time larger than this are
4367 * automatically non-cosmetic. */
4368 #define ROUTER_MAX_COSMETIC_TIME_DIFFERENCE (12*60*60)
4370 /** We allow uptime to vary from how much it ought to be by this much. */
4371 #define ROUTER_ALLOW_UPTIME_DRIFT (6*60*60)
4373 /** Return true iff the only differences between r1 and r2 are such that
4374 * would not cause a recent (post 0.1.1.6) dirserver to republish.
4377 router_differences_are_cosmetic(routerinfo_t
*r1
, routerinfo_t
*r2
)
4379 time_t r1pub
, r2pub
;
4380 int time_difference
;
4381 tor_assert(r1
&& r2
);
4383 /* r1 should be the one that was published first. */
4384 if (r1
->cache_info
.published_on
> r2
->cache_info
.published_on
) {
4385 routerinfo_t
*ri_tmp
= r2
;
4390 /* If any key fields differ, they're different. */
4391 if (strcasecmp(r1
->address
, r2
->address
) ||
4392 strcasecmp(r1
->nickname
, r2
->nickname
) ||
4393 r1
->or_port
!= r2
->or_port
||
4394 r1
->dir_port
!= r2
->dir_port
||
4395 crypto_pk_cmp_keys(r1
->onion_pkey
, r2
->onion_pkey
) ||
4396 crypto_pk_cmp_keys(r1
->identity_pkey
, r2
->identity_pkey
) ||
4397 strcasecmp(r1
->platform
, r2
->platform
) ||
4398 (r1
->contact_info
&& !r2
->contact_info
) || /* contact_info is optional */
4399 (!r1
->contact_info
&& r2
->contact_info
) ||
4400 (r1
->contact_info
&& r2
->contact_info
&&
4401 strcasecmp(r1
->contact_info
, r2
->contact_info
)) ||
4402 r1
->is_hibernating
!= r2
->is_hibernating
||
4403 r1
->has_old_dnsworkers
!= r2
->has_old_dnsworkers
||
4404 cmp_addr_policies(r1
->exit_policy
, r2
->exit_policy
))
4406 if ((r1
->declared_family
== NULL
) != (r2
->declared_family
== NULL
))
4408 if (r1
->declared_family
&& r2
->declared_family
) {
4410 if (smartlist_len(r1
->declared_family
)!=smartlist_len(r2
->declared_family
))
4412 n
= smartlist_len(r1
->declared_family
);
4413 for (i
=0; i
< n
; ++i
) {
4414 if (strcasecmp(smartlist_get(r1
->declared_family
, i
),
4415 smartlist_get(r2
->declared_family
, i
)))
4420 /* Did bandwidth change a lot? */
4421 if ((r1
->bandwidthcapacity
< r2
->bandwidthcapacity
/2) ||
4422 (r2
->bandwidthcapacity
< r1
->bandwidthcapacity
/2))
4425 /* Did more than 12 hours pass? */
4426 if (r1
->cache_info
.published_on
+ ROUTER_MAX_COSMETIC_TIME_DIFFERENCE
4427 < r2
->cache_info
.published_on
)
4430 /* Did uptime fail to increase by approximately the amount we would think,
4431 * give or take some slop? */
4432 r1pub
= r1
->cache_info
.published_on
;
4433 r2pub
= r2
->cache_info
.published_on
;
4434 time_difference
= abs(r2
->uptime
- (r1
->uptime
+ (r2pub
- r1pub
)));
4435 if (time_difference
> ROUTER_ALLOW_UPTIME_DRIFT
&&
4436 time_difference
> r1
->uptime
* .05 &&
4437 time_difference
> r2
->uptime
* .05)
4440 /* Otherwise, the difference is cosmetic. */
4444 /** Generate networkstatus lines for a single routerstatus_t object, and
4445 * return the result in a newly allocated string. Used only by controller
4446 * interface (for now.) */
4447 /* XXXX This should eventually merge into generate_v2_networkstatus() */
4449 networkstatus_getinfo_helper_single(routerstatus_t
*rs
)
4456 char published
[ISO_TIME_LEN
+1];
4457 char ipaddr
[INET_NTOA_BUF_LEN
];
4458 char identity64
[BASE64_DIGEST_LEN
+1];
4459 char digest64
[BASE64_DIGEST_LEN
+1];
4461 format_iso_time(published
, rs
->published_on
);
4462 digest_to_base64(identity64
, rs
->identity_digest
);
4463 digest_to_base64(digest64
, rs
->descriptor_digest
);
4464 in
.s_addr
= htonl(rs
->addr
);
4465 tor_inet_ntoa(&in
, ipaddr
, sizeof(ipaddr
));
4467 f_authority
= router_digest_is_trusted_dir(rs
->identity_digest
);
4469 r
= tor_snprintf(buf
, sizeof(buf
),
4470 "r %s %s %s %s %s %d %d\n"
4471 "s%s%s%s%s%s%s%s%s%s%s\n",
4480 f_authority
?" Authority":"",
4481 rs
->is_bad_exit
?" BadExit":"",
4482 rs
->is_exit
?" Exit":"",
4483 rs
->is_fast
?" Fast":"",
4484 rs
->is_possible_guard
?" Guard":"",
4485 rs
->is_named
?" Named":"",
4486 rs
->is_stable
?" Stable":"",
4487 rs
->is_running
?" Running":"",
4488 rs
->is_valid
?" Valid":"",
4489 rs
->is_v2_dir
?" V2Dir":"");
4491 log_warn(LD_BUG
, "Not enough space in buffer.");
4493 return tor_strdup(buf
);
4496 /** If <b>question</b> is a string beginning with "ns/" in a format the
4497 * control interface expects for a GETINFO question, set *<b>answer</b> to a
4498 * newly-allocated string containing networkstatus lines for the appropriate
4499 * ORs. Return 0 on success, -1 on unrecognized question format. */
4501 getinfo_helper_networkstatus(control_connection_t
*conn
,
4502 const char *question
, char **answer
)
4504 local_routerstatus_t
*status
;
4507 if (!routerstatus_list
) {
4508 *answer
= tor_strdup("");
4512 if (!strcmp(question
, "ns/all")) {
4513 smartlist_t
*statuses
= smartlist_create();
4514 SMARTLIST_FOREACH(routerstatus_list
, local_routerstatus_t
*, lrs
,
4516 routerstatus_t
*rs
= &(lrs
->status
);
4517 smartlist_add(statuses
, networkstatus_getinfo_helper_single(rs
));
4519 *answer
= smartlist_join_strings(statuses
, "", 0, NULL
);
4520 SMARTLIST_FOREACH(statuses
, char *, cp
, tor_free(cp
));
4521 smartlist_free(statuses
);
4523 } else if (!strcmpstart(question
, "ns/id/")) {
4526 if (base16_decode(d
, DIGEST_LEN
, question
+6, strlen(question
+6)))
4528 status
= router_get_combined_status_by_digest(d
);
4529 } else if (!strcmpstart(question
, "ns/name/")) {
4530 status
= router_get_combined_status_by_nickname(question
+8, 0);
4536 *answer
= networkstatus_getinfo_helper_single(&status
->status
);
4541 /** Assert that the internal representation of <b>rl</b> is
4542 * self-consistent. */
4544 routerlist_assert_ok(routerlist_t
*rl
)
4546 digestmap_iter_t
*iter
;
4548 signed_descriptor_t
*sd2
;
4551 SMARTLIST_FOREACH(rl
->routers
, routerinfo_t
*, r
,
4553 r2
= digestmap_get(rl
->identity_map
, r
->cache_info
.identity_digest
);
4556 "fatal error: router at %p did not match router at %p. [%d]",
4559 tor_assert(r
== r2
);
4560 sd2
= digestmap_get(rl
->desc_digest_map
,
4561 r
->cache_info
.signed_descriptor_digest
);
4562 tor_assert(&(r
->cache_info
) == sd2
);
4563 tor_assert(r
->routerlist_index
== r_sl_idx
);
4565 SMARTLIST_FOREACH(rl
->old_routers
, signed_descriptor_t
*, sd
,
4567 r2
= digestmap_get(rl
->identity_map
, sd
->identity_digest
);
4568 tor_assert(sd
!= &(r2
->cache_info
));
4569 sd2
= digestmap_get(rl
->desc_digest_map
, sd
->signed_descriptor_digest
);
4570 tor_assert(sd
== sd2
);
4572 iter
= digestmap_iter_init(rl
->identity_map
);
4573 while (!digestmap_iter_done(iter
)) {
4577 digestmap_iter_get(iter
, &d
, &_r
);
4579 tor_assert(!memcmp(r
->cache_info
.identity_digest
, d
, DIGEST_LEN
));
4580 iter
= digestmap_iter_next(rl
->identity_map
, iter
);
4582 iter
= digestmap_iter_init(rl
->desc_digest_map
);
4583 while (!digestmap_iter_done(iter
)) {
4586 signed_descriptor_t
*sd
;
4587 digestmap_iter_get(iter
, &d
, &_sd
);
4589 tor_assert(!memcmp(sd
->signed_descriptor_digest
, d
, DIGEST_LEN
));
4590 iter
= digestmap_iter_next(rl
->desc_digest_map
, iter
);
4594 /** Allocate and return a new string representing the contact info
4595 * and platform string for <b>router</b>,
4596 * surrounded by quotes and using standard C escapes.
4598 * THIS FUNCTION IS NOT REENTRANT. Don't call it from outside the main
4599 * thread. Also, each call invalidates the last-returned value, so don't
4600 * try log_warn(LD_GENERAL, "%s %s", esc_router_info(a), esc_router_info(b));
4603 esc_router_info(routerinfo_t
*router
)
4606 char *esc_contact
, *esc_platform
;
4611 esc_contact
= esc_for_log(router
->contact_info
);
4612 esc_platform
= esc_for_log(router
->platform
);
4614 len
= strlen(esc_contact
)+strlen(esc_platform
)+32;
4615 info
= tor_malloc(len
);
4616 tor_snprintf(info
, len
, "Contact %s, Platform %s", esc_contact
,
4618 tor_free(esc_contact
);
4619 tor_free(esc_platform
);