- 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(());
- }
+ 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!("({} < {})", 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!("({} < {})", 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!("({}: 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!("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!("(subver: {})", 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::Ping(state_lock.pong_nonce)) {
+ return future::err(());
+ }
+ },
+ NetworkMessage::Ping(v) => {
+ if let Err(_) = write.try_send(NetworkMessage::Pong(v)) {
+ return future::err(())
+ }
+ },
+ NetworkMessage::Pong(v) => {
+ if v != state_lock.pong_nonce {
+ state_lock.fail_reason = AddressState::ProtocolViolation;
+ state_lock.msg = ("due to invalid pong nonce".to_string(), true);
+ return future::err(());
+ }
+ check_set_flag!(recvd_pong, "pong");
+ if let Err(_) = write.try_send(NetworkMessage::GetAddr) {
+ return future::err(());
+ }
+ },
+ NetworkMessage::Addr(addrs) => {
+ if addrs.len() > 1000 {
+ state_lock.fail_reason = AddressState::ProtocolViolation;
+ state_lock.msg = (format!("due to oversized addr: {}", addrs.len()), true);
+ state_lock.recvd_addrs = false;
+ return future::err(());
+ }
+ if addrs.len() > 10 {
+ if !state_lock.recvd_addrs {