+ 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(());
+ }
+ 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;
+ 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;
+ state_lock.msg = ("ProtocolViolation due to bad block".to_string(), true);
+ return future::err(());
+ }
+ check_set_flag!(recvd_block, "block");
+ },
+ _ => {},
+ }
+ future::ok(())
+ }).then(|_| {
+ future::err(())
+ })
+ }).then(move |_: Result<(), ()>| {
+ let printer = unsafe { PRINTER.as_ref().unwrap() };
+ let store = unsafe { DATA_STORE.as_ref().unwrap() };
+ printer.set_stat(Stat::ConnectionClosed);