X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpeer_handler.rs;h=2559acfc2dd5370b93d59d1cdb47a591c80a1c56;hb=38a544eafd51f0446b1bb460a42107d35c740388;hp=b977f791389f2eadade27b0d739539f441341290;hpb=81c6bdc953ce3191e2428a3575e5994381f31c1f;p=rust-lightning

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index b977f791..2559acfc 100644
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -42,7 +42,7 @@ use bitcoin::hashes::{HashEngine, Hash};
 
 /// A dummy struct which implements `RoutingMessageHandler` without storing any routing information
 /// or doing any processing. You can provide one of these as the route_handler in a MessageHandler.
-struct IgnoringMessageHandler{}
+pub struct IgnoringMessageHandler{}
 impl MessageSendEventsProvider for IgnoringMessageHandler {
 	fn get_and_clear_pending_msg_events(&self) -> Vec<MessageSendEvent> { Vec::new() }
 }
@@ -67,7 +67,7 @@ impl Deref for IgnoringMessageHandler {
 
 /// A dummy struct which implements `ChannelMessageHandler` without having any channels.
 /// You can provide one of these as the route_handler in a MessageHandler.
-struct ErroringMessageHandler {
+pub struct ErroringMessageHandler {
 	message_queue: Mutex<Vec<MessageSendEvent>>
 }
 impl ErroringMessageHandler {
@@ -142,6 +142,8 @@ impl ChannelMessageHandler for ErroringMessageHandler {
 	fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &msgs::ChannelReestablish) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
 	}
+	// msgs::ChannelUpdate does not contain the channel_id field, so we just drop them.
+	fn handle_channel_update(&self, _their_node_id: &PublicKey, _msg: &msgs::ChannelUpdate) {}
 	fn peer_disconnected(&self, _their_node_id: &PublicKey, _no_connection_possible: bool) {}
 	fn peer_connected(&self, _their_node_id: &PublicKey, _msg: &msgs::Init) {}
 	fn handle_error(&self, _their_node_id: &PublicKey, _msg: &msgs::ErrorMessage) {}
@@ -231,7 +233,6 @@ enum InitSyncTracker{
 
 struct Peer {
 	channel_encryptor: PeerChannelEncryptor,
-	outbound: bool,
 	their_node_id: Option<PublicKey>,
 	their_features: Option<InitFeatures>,
 
@@ -293,7 +294,7 @@ fn _check_usize_is_32_or_64() {
 /// lifetimes). Other times you can afford a reference, which is more efficient, in which case
 /// SimpleRefPeerManager is the more appropriate type. Defining these type aliases prevents
 /// issues such as overly long function definitions.
-pub type SimpleArcPeerManager<SD, M, T, F, C, L> = Arc<PeerManager<SD, SimpleArcChannelManager<M, T, F, L>, Arc<NetGraphMsgHandler<Arc<C>, Arc<L>>>, Arc<L>>>;
+pub type SimpleArcPeerManager<SD, M, T, F, C, L> = PeerManager<SD, Arc<SimpleArcChannelManager<M, T, F, L>>, Arc<NetGraphMsgHandler<Arc<C>, Arc<L>>>, Arc<L>>;
 
 /// SimpleRefPeerManager is a type alias for a PeerManager reference, and is the reference
 /// counterpart to the SimpleArcPeerManager type alias. Use this type by default when you don't
@@ -463,7 +464,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,
 
@@ -500,7 +500,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,
 
@@ -742,6 +741,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 {
@@ -852,12 +854,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);
@@ -970,6 +966,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
 				}
 			},
 			wire::Message::ChannelUpdate(msg) => {
+				self.message_handler.chan_handler.handle_channel_update(&peer.their_node_id.unwrap(), &msg);
 				let should_forward = match self.message_handler.route_handler.handle_channel_update(&msg) {
 					Ok(v) => v,
 					Err(e) => { return Err(e.into()); },
@@ -1017,9 +1014,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 {
@@ -1281,6 +1278,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);
+					}
 				}
 			}
 
@@ -1345,7 +1353,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
 	/// It will send pings to each peer and disconnect those which did not respond to the last round of pings.
 
 	/// Will most likely call send_data on all of the registered descriptors, thus, be very careful with reentrancy issues!
-	pub fn timer_tick_occured(&self) {
+	pub fn timer_tick_occurred(&self) {
 		let mut peers_lock = self.peers.lock().unwrap();
 		{
 			let peers = &mut *peers_lock;
@@ -1518,11 +1526,11 @@ mod tests {
 		assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1);
 
 		// peers[0] awaiting_pong is set to true, but the Peer is still connected
-		peers[0].timer_tick_occured();
+		peers[0].timer_tick_occurred();
 		assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1);
 
-		// Since timer_tick_occured() is called again when awaiting_pong is true, all Peers are disconnected
-		peers[0].timer_tick_occured();
+		// Since timer_tick_occurred() is called again when awaiting_pong is true, all Peers are disconnected
+		peers[0].timer_tick_occurred();
 		assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 0);
 	}