use std::{cmp, mem};
use std::collections::{HashSet, HashMap, hash_map};
use std::sync::{Arc, RwLock};
-use std::net::SocketAddr;
+use std::net::{IpAddr, SocketAddr};
use std::time::{Duration, Instant};
use std::io::{BufRead, BufReader};
use regex::Regex;
+use crate::bgp_client::BGPClient;
+
#[derive(Clone, Copy, Hash, PartialEq, Eq)]
pub enum AddressState {
Untested,
ProtocolViolation,
Timeout,
TimeoutDuringRequest,
+ TimeoutAwaitingPong,
+ TimeoutAwaitingAddr,
+ TimeoutAwaitingBlock,
Good,
WasGood,
+ EvilNode,
}
impl AddressState {
0x6 => Some(AddressState::ProtocolViolation),
0x7 => Some(AddressState::Timeout),
0x8 => Some(AddressState::TimeoutDuringRequest),
- 0x9 => Some(AddressState::Good),
- 0xa => Some(AddressState::WasGood),
+ 0x9 => Some(AddressState::TimeoutAwaitingPong),
+ 0xa => Some(AddressState::TimeoutAwaitingAddr),
+ 0xb => Some(AddressState::TimeoutAwaitingBlock),
+ 0xc => Some(AddressState::Good),
+ 0xd => Some(AddressState::WasGood),
+ 0xe => Some(AddressState::EvilNode),
_ => None,
}
}
AddressState::ProtocolViolation => 6,
AddressState::Timeout => 7,
AddressState::TimeoutDuringRequest => 8,
- AddressState::Good => 9,
- AddressState::WasGood => 10,
+ AddressState::TimeoutAwaitingPong => 9,
+ AddressState::TimeoutAwaitingAddr => 10,
+ AddressState::TimeoutAwaitingBlock => 11,
+ AddressState::Good => 12,
+ AddressState::WasGood => 13,
+ AddressState::EvilNode => 14,
}
}
AddressState::ProtocolViolation => "Protocol Violation",
AddressState::Timeout => "Timeout",
AddressState::TimeoutDuringRequest => "Timeout During Request",
+ AddressState::TimeoutAwaitingPong => "Timeout Awaiting Pong",
+ AddressState::TimeoutAwaitingAddr => "Timeout Awaiting Addr",
+ AddressState::TimeoutAwaitingBlock => "Timeout Awaiting Block",
AddressState::Good => "Good",
AddressState::WasGood => "Was Good",
+ AddressState::EvilNode => "Evil Node",
}
}
- pub fn get_count() -> u8 {
- 11
+ pub const fn get_count() -> u8 {
+ 15
}
}
}
} }
}
- let mut u64s = HashMap::with_capacity(15);
+ let mut u64s = HashMap::with_capacity(AddressState::get_count() as usize + 4);
u64s.insert(U64Setting::ConnsPerSec, try_read!(l, u64));
u64s.insert(U64Setting::RunTimeout, try_read!(l, u64));
u64s.insert(U64Setting::WasGoodTimeout, try_read!(l, u64));
u64s.insert(U64Setting::RescanInterval(AddressState::ProtocolViolation), try_read!(l, u64));
u64s.insert(U64Setting::RescanInterval(AddressState::Timeout), try_read!(l, u64));
u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutDuringRequest), try_read!(l, u64));
+ u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutAwaitingPong), try_read!(l, u64));
+ u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutAwaitingAddr), try_read!(l, u64));
+ u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutAwaitingBlock), try_read!(l, u64));
u64s.insert(U64Setting::RescanInterval(AddressState::Good), try_read!(l, u64));
u64s.insert(U64Setting::RescanInterval(AddressState::WasGood), try_read!(l, u64));
+ u64s.insert(U64Setting::RescanInterval(AddressState::EvilNode), try_read!(l, u64));
future::ok((u64s, try_read!(l, Regex)))
}).or_else(|_| -> future::FutureResult<(HashMap<U64Setting, u64>, Regex), ()> {
let mut u64s = HashMap::with_capacity(15);
u64s.insert(U64Setting::RescanInterval(AddressState::ProtocolViolation), 86400);
u64s.insert(U64Setting::RescanInterval(AddressState::Timeout), 86400);
u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutDuringRequest), 21600);
+ u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutAwaitingPong), 3600);
+ u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutAwaitingAddr), 1800);
+ u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutAwaitingBlock), 3600);
u64s.insert(U64Setting::RescanInterval(AddressState::Good), 1800);
u64s.insert(U64Setting::RescanInterval(AddressState::WasGood), 1800);
- u64s.insert(U64Setting::MinProtocolVersion, 10000); //XXX
+ u64s.insert(U64Setting::RescanInterval(AddressState::EvilNode), 315360000);
+ u64s.insert(U64Setting::MinProtocolVersion, 70002);
future::ok((u64s, Regex::new(".*").unwrap()))
});
pub fn save_data(&'static self) -> impl Future<Item=(), Error=()> {
let settings_file = self.store.clone() + "/settings";
let settings_future = File::create(settings_file.clone() + ".tmp").and_then(move |f| {
- let settings_string = format!("{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}",
+ let settings_string = format!("{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}",
self.get_u64(U64Setting::ConnsPerSec),
self.get_u64(U64Setting::RunTimeout),
self.get_u64(U64Setting::WasGoodTimeout),
self.get_u64(U64Setting::RescanInterval(AddressState::ProtocolViolation)),
self.get_u64(U64Setting::RescanInterval(AddressState::Timeout)),
self.get_u64(U64Setting::RescanInterval(AddressState::TimeoutDuringRequest)),
+ self.get_u64(U64Setting::RescanInterval(AddressState::TimeoutAwaitingPong)),
+ self.get_u64(U64Setting::RescanInterval(AddressState::TimeoutAwaitingAddr)),
+ self.get_u64(U64Setting::RescanInterval(AddressState::TimeoutAwaitingBlock)),
self.get_u64(U64Setting::RescanInterval(AddressState::Good)),
self.get_u64(U64Setting::RescanInterval(AddressState::WasGood)),
+ self.get_u64(U64Setting::RescanInterval(AddressState::EvilNode)),
self.get_regex(RegexSetting::SubverRegex).as_str());
write_all(f, settings_string).and_then(|(mut f, _)| {
f.poll_sync_all()
tokio::fs::rename(nodes_file.clone() + ".tmp", nodes_file)
});
+ settings_future.join(nodes_future).then(|_| { future::ok(()) })
+ }
+
+ pub fn write_dns(&'static self, bgp_client: Arc<BGPClient>) -> impl Future<Item=(), Error=()> {
let dns_file = self.store.clone() + "/nodes.dump";
- let dns_future = File::create(dns_file.clone() + ".tmp").and_then(move |f| {
+ File::create(dns_file.clone() + ".tmp").and_then(move |f| {
let mut dns_buff = String::new();
{
- let nodes = self.nodes.read().unwrap();
let mut rng = thread_rng();
for i in &[1u64, 4, 5, 8, 9, 12, 13, 1024, 1025, 1028, 1029, 1032, 1033, 1036, 1037] {
- let mut v6_set = Vec::new();
- let mut v4_set = Vec::new();
- if i.count_ones() == 1 {
- for j in 0..64 {
- if i & (1 << j) != 0 {
- let set_ref = &nodes.good_node_services[j];
- v4_set = set_ref.iter().filter(|e| e.is_ipv4() && e.port() == 8333)
- .choose_multiple(&mut rng, 21).iter().map(|e| e.ip()).collect();
- v6_set = set_ref.iter().filter(|e| e.is_ipv6() && e.port() == 8333)
- .choose_multiple(&mut rng, 12).iter().map(|e| e.ip()).collect();
- break;
- }
- }
- } else if i.count_ones() == 2 {
- let mut first_set = None;
- let mut second_set = None;
- for j in 0..64 {
- if i & (1 << j) != 0 {
- if first_set == None {
- first_set = Some(&nodes.good_node_services[j]);
- } else {
- second_set = Some(&nodes.good_node_services[j]);
+ let mut v6_set: Vec<IpAddr> = Vec::new();
+ let mut v4_set: Vec<IpAddr> = Vec::new();
+ {
+ let nodes = self.nodes.read().unwrap();
+ if i.count_ones() == 1 {
+ for j in 0..64 {
+ if i & (1 << j) != 0 {
+ let set_ref = &nodes.good_node_services[j];
+ v4_set = set_ref.iter().filter(|e| e.is_ipv4() && e.port() == 8333).map(|e| e.ip()).collect();
+ v6_set = set_ref.iter().filter(|e| e.is_ipv6() && e.port() == 8333).map(|e| e.ip()).collect();
break;
}
}
- }
- v4_set = first_set.unwrap().intersection(&second_set.unwrap())
- .filter(|e| e.is_ipv4() && e.port() == 8333)
- .choose_multiple(&mut rng, 21).iter().map(|e| e.ip()).collect();
- v6_set = first_set.unwrap().intersection(&second_set.unwrap())
- .filter(|e| e.is_ipv6() && e.port() == 8333)
- .choose_multiple(&mut rng, 12).iter().map(|e| e.ip()).collect();
- } else {
- //TODO: Could optimize this one a bit
- let mut intersection;
- let mut intersection_set_ref = None;
- for j in 0..64 {
- if i & (1 << j) != 0 {
- if intersection_set_ref == None {
- intersection_set_ref = Some(&nodes.good_node_services[j]);
- } else {
- let new_intersection = intersection_set_ref.unwrap()
- .intersection(&nodes.good_node_services[j]).map(|e| (*e).clone()).collect();
- intersection = Some(new_intersection);
- intersection_set_ref = Some(intersection.as_ref().unwrap());
+ } else if i.count_ones() == 2 {
+ let mut first_set = None;
+ let mut second_set = None;
+ for j in 0..64 {
+ if i & (1 << j) != 0 {
+ if first_set == None {
+ first_set = Some(&nodes.good_node_services[j]);
+ } else {
+ second_set = Some(&nodes.good_node_services[j]);
+ break;
+ }
+ }
+ }
+ v4_set = first_set.unwrap().intersection(&second_set.unwrap())
+ .filter(|e| e.is_ipv4() && e.port() == 8333).map(|e| e.ip()).collect();
+ v6_set = first_set.unwrap().intersection(&second_set.unwrap())
+ .filter(|e| e.is_ipv6() && e.port() == 8333).map(|e| e.ip()).collect();
+ } else {
+ //TODO: Could optimize this one a bit
+ let mut intersection;
+ let mut intersection_set_ref = None;
+ for j in 0..64 {
+ if i & (1 << j) != 0 {
+ if intersection_set_ref == None {
+ intersection_set_ref = Some(&nodes.good_node_services[j]);
+ } else {
+ let new_intersection = intersection_set_ref.unwrap()
+ .intersection(&nodes.good_node_services[j]).map(|e| (*e).clone()).collect();
+ intersection = Some(new_intersection);
+ intersection_set_ref = Some(intersection.as_ref().unwrap());
+ }
}
}
+ v4_set = intersection_set_ref.unwrap().iter()
+ .filter(|e| e.is_ipv4() && e.port() == 8333).map(|e| e.ip()).collect();
+ v6_set = intersection_set_ref.unwrap().iter()
+ .filter(|e| e.is_ipv6() && e.port() == 8333).map(|e| e.ip()).collect();
}
- v4_set = intersection_set_ref.unwrap().iter()
- .filter(|e| e.is_ipv4() && e.port() == 8333)
- .choose_multiple(&mut rng, 21).iter().map(|e| e.ip()).collect();
- v6_set = intersection_set_ref.unwrap().iter()
- .filter(|e| e.is_ipv6() && e.port() == 8333)
- .choose_multiple(&mut rng, 12).iter().map(|e| e.ip()).collect();
}
- for a in v4_set {
+ let mut asn_set = HashSet::with_capacity(cmp::max(v4_set.len(), v6_set.len()));
+ for a in v4_set.iter().filter(|a| asn_set.insert(bgp_client.get_asn(**a))).choose_multiple(&mut rng, 21) {
dns_buff += &format!("x{:x}.dnsseed\tIN\tA\t{}\n", i, a);
}
- for a in v6_set {
+ asn_set.clear();
+ for a in v6_set.iter().filter(|a| asn_set.insert(bgp_client.get_asn(**a))).choose_multiple(&mut rng, 12) {
dns_buff += &format!("x{:x}.dnsseed\tIN\tAAAA\t{}\n", i, a);
}
}
f.poll_sync_all()
}).and_then(|_| {
tokio::fs::rename(dns_file.clone() + ".tmp", dns_file)
- });
-
- settings_future.join3(nodes_future, dns_future).then(|_| { future::ok(()) })
+ }).then(|_| { future::ok(()) })
}
pub fn get_next_scan_nodes(&self) -> Vec<SocketAddr> {
let mut nodes = self.nodes.write().unwrap();
for (idx, state_nodes) in nodes.state_next_scan.iter_mut().enumerate() {
let cmp_time = cur_time - Duration::from_secs(self.get_u64(U64Setting::RescanInterval(AddressState::from_num(idx as u8).unwrap())));
- let split_point = cmp::min(cmp::min(results - res.len(), results - (per_bucket_results * (AddressState::get_count() as usize - idx))),
+ let split_point = cmp::min(cmp::min(results - res.len(), (per_bucket_results * (idx + 1)) - res.len()),
state_nodes.binary_search_by(|a| a.0.cmp(&cmp_time)).unwrap_or_else(|idx| idx));
let mut new_nodes = state_nodes.split_off(split_point);
mem::swap(&mut new_nodes, state_nodes);
projects / dnsseed-rust / blobdiff