X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpeer_handler.rs;h=097e9928677bb4a288e8d44820a1fb7df9567e42;hb=4a12d7656ef8355bfd41f57f2350de4b14bda935;hp=df1ab16f1f83341da4a64bda523b9ac6f48a8fed;hpb=e8a0824dd4b62288805f0e6cf435e52fd022b7c2;p=rust-lightning

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index df1ab16f..097e9928 100644
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -32,9 +32,10 @@ use routing::network_graph::NetGraphMsgHandler;
 
 use std::collections::{HashMap,hash_map,HashSet,LinkedList};
 use std::sync::{Arc, Mutex};
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::{cmp, error, hash, fmt, mem};
-use std::ops::Deref;
+use core::sync::atomic::{AtomicUsize, Ordering};
+use core::{cmp, hash, fmt, mem};
+use core::ops::Deref;
+use std::error;
 
 use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hashes::sha256::HashEngine as Sha256Engine;
@@ -233,7 +234,6 @@ enum InitSyncTracker{
 
 struct Peer {
 	channel_encryptor: PeerChannelEncryptor,
-	outbound: bool,
 	their_node_id: Option<PublicKey>,
 	their_features: Option<InitFeatures>,
 
@@ -465,7 +465,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
 		let mut peers = self.peers.lock().unwrap();
 		if peers.peers.insert(descriptor, Peer {
 			channel_encryptor: peer_encryptor,
-			outbound: true,
 			their_node_id: None,
 			their_features: None,
 
@@ -502,7 +501,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
 		let mut peers = self.peers.lock().unwrap();
 		if peers.peers.insert(descriptor, Peer {
 			channel_encryptor: peer_encryptor,
-			outbound: false,
 			their_node_id: None,
 			their_features: None,
 
@@ -744,6 +742,9 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
 									peer.pending_read_is_header = true;
 									peer.their_node_id = Some(their_node_id);
 									insert_node_id!();
+									let features = InitFeatures::known();
+									let resp = msgs::Init { features };
+									self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &resp);
 								},
 								NextNoiseStep::NoiseComplete => {
 									if peer.pending_read_is_header {
@@ -783,6 +784,10 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
 													}
 													msgs::DecodeError::BadLengthDescriptor => return Err(PeerHandleError { no_connection_possible: false }),
 													msgs::DecodeError::Io(_) => return Err(PeerHandleError { no_connection_possible: false }),
+													msgs::DecodeError::UnsupportedCompression => {
+														log_debug!(self.logger, "We don't support zlib-compressed message fields, ignoring message");
+														continue;
+													}
 												}
 											}
 										};
@@ -854,12 +859,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
 					return Err(PeerHandleError{ no_connection_possible: true }.into());
 				}
 
-				if !peer.outbound {
-					let features = InitFeatures::known();
-					let resp = msgs::Init { features };
-					self.enqueue_message(peers_needing_send, peer, peer_descriptor.clone(), &resp);
-				}
-
 				self.message_handler.route_handler.sync_routing_table(&peer.their_node_id.unwrap(), &msg);
 
 				self.message_handler.chan_handler.peer_connected(&peer.their_node_id.unwrap(), &msg);
@@ -1020,9 +1019,9 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
 			// buffer by doing things like announcing channels on another node. We should be willing to
 			// drop optional-ish messages when send buffers get full!
 
+			let mut peers_lock = self.peers.lock().unwrap();
 			let mut events_generated = self.message_handler.chan_handler.get_and_clear_pending_msg_events();
 			events_generated.append(&mut self.message_handler.route_handler.get_and_clear_pending_msg_events());
-			let mut peers_lock = self.peers.lock().unwrap();
 			let peers = &mut *peers_lock;
 			for event in events_generated.drain(..) {
 				macro_rules! get_peer_for_forwarding {
@@ -1284,6 +1283,17 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
 						peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
 						self.do_attempt_write_data(&mut descriptor, peer);
 					}
+					MessageSendEvent::SendReplyChannelRange { ref node_id, ref msg } => {
+						log_trace!(self.logger, "Handling SendReplyChannelRange event in peer_handler for node {} with num_scids={} first_blocknum={} number_of_blocks={}, sync_complete={}",
+							log_pubkey!(node_id),
+							msg.short_channel_ids.len(),
+							msg.first_blocknum,
+							msg.number_of_blocks,
+							msg.sync_complete);
+						let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, {});
+						peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
+						self.do_attempt_write_data(&mut descriptor, peer);
+					}
 				}
 			}
 
@@ -1411,9 +1421,8 @@ mod tests {
 	use bitcoin::secp256k1::Secp256k1;
 	use bitcoin::secp256k1::key::{SecretKey, PublicKey};
 
-	use std;
 	use std::sync::{Arc, Mutex};
-	use std::sync::atomic::Ordering;
+	use core::sync::atomic::Ordering;
 
 	#[derive(Clone)]
 	struct FileDescriptor {
@@ -1426,8 +1435,8 @@ mod tests {
 		}
 	}
 	impl Eq for FileDescriptor { }
-	impl std::hash::Hash for FileDescriptor {
-		fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
+	impl core::hash::Hash for FileDescriptor {
+		fn hash<H: core::hash::Hasher>(&self, hasher: &mut H) {
 			self.fd.hash(hasher)
 		}
 	}