Regularly poll other dnsseeds for new addrs

[dnsseed-rust] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index 0f14333a75058b6f2a23e7cede3f6afb45e6778d..be27835cf6b0df05fbd637b6f713deac21d76572 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,12 +4,12 @@ mod peer;
 mod timeout_stream;
 mod datastore;
 
-use std::env;
+use std::{cmp, env};
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 use std::sync::atomic::{Ordering, AtomicBool};
 use std::time::{Duration, Instant};
-use std::net::SocketAddr;
+use std::net::{SocketAddr, ToSocketAddrs};
 
 use bitcoin_hashes::sha256d;
 
@@ -33,6 +33,7 @@ static mut HEIGHT_MAP: Option<Box<Mutex<HashMap<u64, sha256d::Hash>>>> = None;
 static mut DATA_STORE: Option<Box<Store>> = None;
 static mut PRINTER: Option<Box<Printer>> = None;
 pub static START_SHUTDOWN: AtomicBool = AtomicBool::new(false);
+static SCANNING: AtomicBool = AtomicBool::new(false);
 
 struct PeerState {
        request: (u64, sha256d::Hash),
@@ -180,7 +181,7 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr) {
                } else {
                        assert!(state_lock.fail_reason != AddressState::Good);
                        let old_state = store.set_node_state(node, state_lock.fail_reason, 0);
-                       if old_state != state_lock.fail_reason && state_lock.msg.0 != "" {
+                       if old_state != state_lock.fail_reason && state_lock.msg.0 != "" && state_lock.msg.1 {
                                printer.add_line(format!("Updating {} from {} to {}", node, old_state.to_str(), &state_lock.msg.0), state_lock.msg.1);
                        }
                }
@@ -188,18 +189,40 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr) {
        }));
 }
 
+fn poll_dnsseeds() {
+       tokio::spawn(future::lazy(|| {
+               let printer = unsafe { PRINTER.as_ref().unwrap() };
+               let store = unsafe { DATA_STORE.as_ref().unwrap() };
+
+               let mut new_addrs = 0;
+               for seed in ["seed.bitcoin.sipa.be", "dnsseed.bitcoin.dashjr.org", "seed.bitcoinstats.com", "seed.bitcoin.jonasschnelli.ch", "seed.btc.petertodd.org", "seed.bitcoin.sprovoost.nl", "dnsseed.emzy.de"].iter() {
+                       new_addrs += store.add_fresh_addrs((*seed, 8333u16).to_socket_addrs().unwrap_or(Vec::new().into_iter()));
+                       new_addrs += store.add_fresh_addrs((("x9.".to_string() + seed).as_str(), 8333u16).to_socket_addrs().unwrap_or(Vec::new().into_iter()));
+               }
+               printer.add_line(format!("Added {} new addresses from other DNS seeds", new_addrs), false);
+               Delay::new(Instant::now() + Duration::from_secs(60)).then(|_| {
+                       if !START_SHUTDOWN.load(Ordering::Relaxed) {
+                               poll_dnsseeds();
+                       }
+                       future::ok(())
+               })
+       }));
+}
+
 fn scan_net() {
        tokio::spawn(future::lazy(|| {
                let store = unsafe { DATA_STORE.as_ref().unwrap() };
+
                let mut scan_nodes = store.get_next_scan_nodes();
                let per_iter_time = Duration::from_millis(1000 / store.get_u64(U64Setting::ConnsPerSec));
-               let mut iter_time = Instant::now();
+               let start_time = Instant::now();
+               let mut iter_time = start_time;
 
                for node in scan_nodes.drain(..) {
                        scan_node(iter_time, node);
                        iter_time += per_iter_time;
                }
-               Delay::new(iter_time).then(|_| {
+               Delay::new(cmp::max(iter_time, start_time + Duration::from_secs(15))).then(|_| {
                        let store = unsafe { DATA_STORE.as_ref().unwrap() };
                        store.save_data().then(|_| {
                                if !START_SHUTDOWN.load(Ordering::Relaxed) {
@@ -229,6 +252,9 @@ fn make_trusted_conn(trusted_sockaddr: SocketAddr) {
                                        starting_height = ver.start_height;
                                },
                                NetworkMessage::Verack => {
+                                       if let Err(_) = trusted_write.try_send(NetworkMessage::SendHeaders) {
+                                               return future::err(());
+                                       }
                                        if let Err(_) = trusted_write.try_send(NetworkMessage::GetHeaders(GetHeadersMessage {
                                                version: 70015,
                                                locator_hashes: vec![unsafe { HIGHEST_HEADER.as_ref().unwrap() }.lock().unwrap().0.clone()],
@@ -263,7 +289,10 @@ fn make_trusted_conn(trusted_sockaddr: SocketAddr) {
                                                        = (headers.last().unwrap().bitcoin_hash(), top_height);
                                                printer.set_stat(printer::Stat::HeaderCount(top_height));
                                                if top_height >= starting_height as u64 {
-                                                       scan_net();
+                                                       if !SCANNING.swap(true, Ordering::SeqCst) {
+                                                               scan_net();
+                                                               poll_dnsseeds();
+                                                       }
                                                }
                                        } else {
                                                // Wat? Lets start again...
@@ -303,8 +332,8 @@ fn main() {
                return;
        }
 
-       unsafe { HEADER_MAP = Some(Box::new(Mutex::new(HashMap::new()))) };
-       unsafe { HEIGHT_MAP = Some(Box::new(Mutex::new(HashMap::new()))) };
+       unsafe { HEADER_MAP = Some(Box::new(Mutex::new(HashMap::with_capacity(600000)))) };
+       unsafe { HEIGHT_MAP = Some(Box::new(Mutex::new(HashMap::with_capacity(600000)))) };
        unsafe { HEADER_MAP.as_ref().unwrap() }.lock().unwrap().insert(genesis_block(Network::Bitcoin).bitcoin_hash(), 0);
        unsafe { HEIGHT_MAP.as_ref().unwrap() }.lock().unwrap().insert(0, genesis_block(Network::Bitcoin).bitcoin_hash());
        unsafe { HIGHEST_HEADER = Some(Box::new(Mutex::new((genesis_block(Network::Bitcoin).bitcoin_hash(), 0)))) };