X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fmain.rs;h=30c363541ceacd3f269c0aa676da6b95afb18c10;hb=eab7aa919b970eaf32fe93ec4407750b2d2afdab;hp=cefbbc1bac1e081a478a7c97a9ec1f92c6df4b78;hpb=c68f31a5fc0135755805a44c1e2ecae9fb17746a;p=dnsseed-rust diff --git a/src/main.rs b/src/main.rs index cefbbc1..30c3635 100644 --- a/src/main.rs +++ b/src/main.rs @@ -48,7 +48,7 @@ struct PeerState { recvd_block: bool, } -pub fn scan_node(scan_time: Instant, node: SocketAddr) { +pub fn scan_node(scan_time: Instant, node: SocketAddr, manual: bool) { if START_SHUTDOWN.load(Ordering::Relaxed) { return; } let printer = unsafe { PRINTER.as_ref().unwrap() }; let store = unsafe { DATA_STORE.as_ref().unwrap() }; @@ -77,7 +77,7 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr) { ($recvd_flag: ident, $msg: expr) => { { if state_lock.$recvd_flag { state_lock.fail_reason = AddressState::ProtocolViolation; - state_lock.msg = (format!("ProtocolViolation due to dup {}", $msg), true); + state_lock.msg = (format!("due to dup {}", $msg), true); state_lock.$recvd_flag = false; return future::err(()); } @@ -93,29 +93,29 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr) { } let safe_ua = ver.user_agent.replace(|c: char| !c.is_ascii() || c < ' ' || c > '~', ""); if (ver.start_height as u64) < state_lock.request.0 { - state_lock.msg = (format!("LowBlockCount ({} < {})", ver.start_height, state_lock.request.0), true); + state_lock.msg = (format!("({} < {})", ver.start_height, state_lock.request.0), true); state_lock.fail_reason = AddressState::LowBlockCount; return future::err(()); } let min_version = store.get_u64(U64Setting::MinProtocolVersion); if (ver.version as u64) < min_version { - state_lock.msg = (format!("LowVersion ({} < {})", ver.version, min_version), true); + state_lock.msg = (format!("({} < {})", ver.version, min_version), true); state_lock.fail_reason = AddressState::LowVersion; return future::err(()); } if ver.services & (1 | (1 << 10)) == 0 { - state_lock.msg = (format!("NotFullNode ({}: services {:x})", safe_ua, ver.services), true); + state_lock.msg = (format!("({}: services {:x})", safe_ua, ver.services), true); state_lock.fail_reason = AddressState::NotFullNode; return future::err(()); } if !store.get_regex(RegexSetting::SubverRegex).is_match(&ver.user_agent) { - state_lock.msg = (format!("BadVersion subver {}", safe_ua), true); + state_lock.msg = (format!("subver {}", safe_ua), true); state_lock.fail_reason = AddressState::BadVersion; return future::err(()); } check_set_flag!(recvd_version, "version"); state_lock.node_services = ver.services; - state_lock.msg = (format!("to Good: {}", safe_ua), false); + state_lock.msg = (format!("(subver: {})", safe_ua), false); if let Err(_) = write.try_send(NetworkMessage::Verack) { return future::err(()); } @@ -134,28 +134,31 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr) { NetworkMessage::Addr(addrs) => { if addrs.len() > 1000 { state_lock.fail_reason = AddressState::ProtocolViolation; - state_lock.msg = (format!("ProtocolViolation due to oversized addr: {}", addrs.len()), true); + state_lock.msg = (format!("due to oversized addr: {}", addrs.len()), true); state_lock.recvd_addrs = false; return future::err(()); } - if !state_lock.recvd_addrs { - if let Err(_) = write.try_send(NetworkMessage::GetData(vec![Inventory { - inv_type: InvType::WitnessBlock, - hash: state_lock.request.1, - }])) { - return future::err(()); + if addrs.len() > 10 { + if !state_lock.recvd_addrs { + if let Err(_) = write.try_send(NetworkMessage::GetData(vec![Inventory { + inv_type: InvType::WitnessBlock, + hash: state_lock.request.1, + }])) { + return future::err(()); + } } + state_lock.recvd_addrs = true; } - state_lock.recvd_addrs = true; unsafe { DATA_STORE.as_ref().unwrap() }.add_fresh_nodes(&addrs); }, NetworkMessage::Block(block) => { if block != state_lock.request.2 { state_lock.fail_reason = AddressState::ProtocolViolation; - state_lock.msg = ("ProtocolViolation due to bad block".to_string(), true); + state_lock.msg = ("due to bad block".to_string(), true); return future::err(()); } check_set_flag!(recvd_block, "block"); + return future::err(()); }, _ => {}, } @@ -168,21 +171,28 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr) { let store = unsafe { DATA_STORE.as_ref().unwrap() }; printer.set_stat(Stat::ConnectionClosed); - let state_lock = final_peer_state.lock().unwrap(); + let mut state_lock = final_peer_state.lock().unwrap(); if state_lock.recvd_version && state_lock.recvd_verack && state_lock.recvd_addrs && state_lock.recvd_block { let old_state = store.set_node_state(node, AddressState::Good, state_lock.node_services); - if old_state != AddressState::Good && state_lock.msg.0 != "" { - printer.add_line(format!("Updating {} from {} to {}", node, old_state.to_str(), &state_lock.msg.0), state_lock.msg.1); + if manual || (old_state != AddressState::Good && state_lock.msg.0 != "") { + printer.add_line(format!("Updating {} from {} to Good {}", node, old_state.to_str(), &state_lock.msg.0), state_lock.msg.1); } } else { assert!(state_lock.fail_reason != AddressState::Good); + if state_lock.fail_reason == AddressState::TimeoutDuringRequest && state_lock.recvd_version && state_lock.recvd_verack { + if !state_lock.recvd_addrs { + state_lock.fail_reason = AddressState::TimeoutAwaitingAddr; + } else if !state_lock.recvd_block { + state_lock.fail_reason = AddressState::TimeoutAwaitingBlock; + } + } let old_state = store.set_node_state(node, state_lock.fail_reason, 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); - } else if old_state != state_lock.fail_reason && state_lock.fail_reason == AddressState::TimeoutDuringRequest { - printer.add_line(format!("Updating {} from {} to Timeout During Request (ver: {}, vack: {}, addr: {}, block: {})", - node, old_state.to_str(), state_lock.recvd_version, state_lock.recvd_verack, state_lock.recvd_addrs, state_lock.recvd_block), true); + if (manual || old_state != state_lock.fail_reason) && state_lock.fail_reason == AddressState::TimeoutDuringRequest { + printer.add_line(format!("Updating {} from {} to Timeout During Request (ver: {}, vack: {})", + node, old_state.to_str(), state_lock.recvd_version, state_lock.recvd_verack), true); + } else if manual || (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.fail_reason.to_str(), &state_lock.msg.0), state_lock.msg.1); } } future::ok(()) @@ -211,15 +221,17 @@ fn poll_dnsseeds() { fn scan_net() { tokio::spawn(future::lazy(|| { + let printer = unsafe { PRINTER.as_ref().unwrap() }; let store = unsafe { DATA_STORE.as_ref().unwrap() }; let mut scan_nodes = store.get_next_scan_nodes(); + printer.add_line(format!("Got {} addresses to scan", scan_nodes.len()), false); let per_iter_time = Duration::from_millis(1000 / store.get_u64(U64Setting::ConnsPerSec)); let start_time = Instant::now(); let mut iter_time = start_time; for node in scan_nodes.drain(..) { - scan_node(iter_time, node); + scan_node(iter_time, node, false); iter_time += per_iter_time; } Delay::new(cmp::max(iter_time, start_time + Duration::from_secs(15))).then(|_| { @@ -356,7 +368,11 @@ fn main() { unsafe { HIGHEST_HEADER = Some(Box::new(Mutex::new((genesis_block(Network::Bitcoin).bitcoin_hash(), 0)))) }; unsafe { REQUEST_BLOCK = Some(Box::new(Mutex::new(Arc::new((0, genesis_block(Network::Bitcoin).bitcoin_hash(), genesis_block(Network::Bitcoin)))))) }; - tokio::run(future::lazy(|| { + let trt = tokio::runtime::Builder::new() + .blocking_threads(2).core_threads(num_cpus::get().max(1) * 3) + .build().unwrap(); + + let _ = trt.block_on_all(future::lazy(|| { let mut args = env::args(); args.next(); let path = args.next().unwrap();