X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fmain.rs;h=a1d03d2b978533266f94c80f03d25e4196387c5b;hb=591344ed66e57115f5847b995f7ec42dc9eaa871;hp=5c7e506a18ba5fa7ba016b77ac9a4874be5afc4f;hpb=a823c0486de0cdefd1742adb953cb1e5f1ab7e5c;p=dnsseed-rust

diff --git a/src/main.rs b/src/main.rs
index 5c7e506..a1d03d2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -24,6 +24,7 @@ use printer::{Printer, Stat};
 use peer::Peer;
 use datastore::{AddressState, Store, U64Setting, RegexSetting};
 use timeout_stream::TimeoutStream;
+use rand::Rng;
 
 use tokio::prelude::*;
 use tokio::timer::Delay;
@@ -44,8 +45,10 @@ struct PeerState {
 	fail_reason: AddressState,
 	recvd_version: bool,
 	recvd_verack: bool,
+	recvd_pong: bool,
 	recvd_addrs: bool,
 	recvd_block: bool,
+	pong_nonce: u64,
 }
 
 pub fn scan_node(scan_time: Instant, node: SocketAddr, manual: bool) {
@@ -53,11 +56,14 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr, manual: bool) {
 	let printer = unsafe { PRINTER.as_ref().unwrap() };
 	let store = unsafe { DATA_STORE.as_ref().unwrap() };
 
+	let mut rng = rand::thread_rng();
 	let peer_state = Arc::new(Mutex::new(PeerState {
 		recvd_version: false,
 		recvd_verack: false,
+		recvd_pong: false,
 		recvd_addrs: false,
 		recvd_block: false,
+		pong_nonce: rng.gen(),
 		node_services: 0,
 		fail_reason: AddressState::Timeout,
 		msg: (String::new(), false),
@@ -122,7 +128,7 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr, manual: bool) {
 				},
 				NetworkMessage::Verack => {
 					check_set_flag!(recvd_verack, "verack");
-					if let Err(_) = write.try_send(NetworkMessage::GetAddr) {
+					if let Err(_) = write.try_send(NetworkMessage::Ping(state_lock.pong_nonce)) {
 						return future::err(());
 					}
 				},
@@ -131,6 +137,17 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr, manual: bool) {
 						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;
@@ -160,6 +177,11 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr, manual: bool) {
 					check_set_flag!(recvd_block, "block");
 					return future::err(());
 				},
+				NetworkMessage::Tx(_) => {
+					state_lock.fail_reason = AddressState::ProtocolViolation;
+					state_lock.msg = ("due to unrequested transaction".to_string(), true);
+					return future::err(());
+				},
 				_ => {},
 			}
 			future::ok(())
@@ -172,7 +194,7 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr, manual: bool) {
 		printer.set_stat(Stat::ConnectionClosed);
 
 		let mut state_lock = final_peer_state.lock().unwrap();
-		if state_lock.recvd_version && state_lock.recvd_verack &&
+		if state_lock.recvd_version && state_lock.recvd_verack && state_lock.recvd_pong &&
 				state_lock.recvd_addrs && state_lock.recvd_block {
 			let old_state = store.set_node_state(node, AddressState::Good, state_lock.node_services);
 			if manual || (old_state != AddressState::Good && state_lock.msg.0 != "") {
@@ -180,7 +202,7 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr, manual: bool) {
 			}
 		} 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.fail_reason == AddressState::TimeoutDuringRequest && state_lock.recvd_version && state_lock.recvd_verack && state_lock.recvd_pong {
 				if !state_lock.recvd_addrs {
 					state_lock.fail_reason = AddressState::TimeoutAwaitingAddr;
 				} else if !state_lock.recvd_block {
@@ -189,8 +211,8 @@ pub fn scan_node(scan_time: Instant, node: SocketAddr, manual: bool) {
 			}
 			let old_state = store.set_node_state(node, state_lock.fail_reason, 0);
 			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);
+				printer.add_line(format!("Updating {} from {} to Timeout During Request (ver: {}, vack: {}, pong: {})",
+					node, old_state.to_str(), state_lock.recvd_version, state_lock.recvd_verack, state_lock.recvd_pong), 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);
 			}
@@ -306,7 +328,7 @@ fn make_trusted_conn(trusted_sockaddr: SocketAddr) {
 						if top_height >= starting_height as u64 {
 							if let Err(_) = trusted_write.try_send(NetworkMessage::GetData(vec![Inventory {
 								inv_type: InvType::WitnessBlock,
-								hash: height_map.get(&(top_height - 1008)).unwrap().clone(),
+								hash: height_map.get(&(top_height - 216)).unwrap().clone(),
 							}])) {
 								return future::err(());
 							}
@@ -327,7 +349,7 @@ fn make_trusted_conn(trusted_sockaddr: SocketAddr) {
 					let hash = block.header.bitcoin_hash();
 					let header_map = unsafe { HEADER_MAP.as_ref().unwrap() }.lock().unwrap();
 					let height = *header_map.get(&hash).expect("Got loose block from trusted peer we coulnd't have requested");
-					if height == unsafe { HIGHEST_HEADER.as_ref().unwrap() }.lock().unwrap().1 - 1008 {
+					if height == unsafe { HIGHEST_HEADER.as_ref().unwrap() }.lock().unwrap().1 - 216 {
 						*unsafe { REQUEST_BLOCK.as_ref().unwrap() }.lock().unwrap() = Arc::new((height, hash, block));
 						if !SCANNING.swap(true, Ordering::SeqCst) {
 							scan_net();