- state_lock.fail_reason = AddressState::TimeoutDuringRequest;
- match msg {
- NetworkMessage::Version(ver) => {
- if ver.start_height < 0 || ver.start_height as u64 > state_lock.request.0 + 1008*2 {
- state_lock.fail_reason = AddressState::HighBlockCount;
- return future::err(());
- }
- if (ver.start_height as u64) < state_lock.request.0 {
- printer.add_line(format!("Updating {} to LowBlockCount ({} < {})", node, 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 {
- printer.add_line(format!("Updating {} to LowVersion ({} < {})", node, ver.version, min_version), true);
- state_lock.fail_reason = AddressState::LowVersion;
- return future::err(());
- }
- if ver.services & 1 != 1 {
- printer.add_line(format!("Updating {} to NotFullNode (services {:x})", node, ver.services), true);
- state_lock.fail_reason = AddressState::NotFullNode;
- return future::err(());
- }
- check_set_flag!(recvd_version, "version");
- state_lock.node_services = ver.services;
- if let Err(_) = write.try_send(NetworkMessage::Verack) {
- return future::err(());
- }
- },
- NetworkMessage::Verack => {
- check_set_flag!(recvd_verack, "verack");
- if let Err(_) = write.try_send(NetworkMessage::GetAddr) {
- return future::err(());
- }
- if let Err(_) = write.try_send(NetworkMessage::GetData(vec![Inventory {
- inv_type: InvType::WitnessBlock,
- hash: state_lock.request.1,
- }])) {
- return future::err(());
- }
- },
- NetworkMessage::Ping(v) => {
- if let Err(_) = write.try_send(NetworkMessage::Pong(v)) {
- return future::err(())
- }
- },
- NetworkMessage::Addr(addrs) => {
- if addrs.len() > 1 {
- check_set_flag!(recvd_addrs, "addr");
- unsafe { DATA_STORE.as_ref().unwrap() }.add_fresh_nodes(&addrs);
- }
- },
- NetworkMessage::Block(block) => {
- if block.header.bitcoin_hash() != state_lock.request.1 ||
- !block.check_merkle_root() || !block.check_witness_commitment() {
- state_lock.fail_reason = AddressState::ProtocolViolation;
- printer.add_line(format!("Updating {} to ProtocolViolation due to bad block", node), true);
- return future::err(());
- }
- check_set_flag!(recvd_block, "block");
- },
- _ => {},
+ state_lock.$recvd_flag = true;
+ } }
+ }
+ state_lock.fail_reason = AddressState::TimeoutDuringRequest;
+ match msg {
+ NetworkMessage::Version(ver) => {
+ if ver.start_height < 0 || ver.start_height as u64 > state_lock.request.0 + 1008*2 {
+ state_lock.fail_reason = AddressState::HighBlockCount;
+ return future::err(());
+ }
+ 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.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.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.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.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);
+ if let Err(_) = write.try_send(NetworkMessage::Verack) {
+ return future::err(());
+ }
+ },
+ NetworkMessage::Verack => {
+ check_set_flag!(recvd_verack, "verack");
+ if let Err(_) = write.try_send(NetworkMessage::GetAddr) {
+ return future::err(());
+ }
+ },
+ NetworkMessage::Ping(v) => {
+ if let Err(_) = write.try_send(NetworkMessage::Pong(v)) {
+ return future::err(())
+ }
+ },
+ 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.recvd_addrs = false;
+ return future::err(());