X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpeer_handler.rs;h=25ac234a847c5959f5414c74755d975b56a173f3;hb=ca1d5693566b8a44cdf4739bb61f0b102436e172;hp=edc9c68a5068c25b419a5e21dc16a4cb7d850ac9;hpb=d64e1b9027d59a61654a95a9e26e21ea7f68771f;p=rust-lightning

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index edc9c68a..25ac234a 100644
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -18,6 +18,7 @@
 use bitcoin::secp256k1::{self, Secp256k1, SecretKey, PublicKey};
 
 use crate::chain::keysinterface::{KeysManager, NodeSigner, Recipient};
+use crate::events::{MessageSendEvent, MessageSendEventsProvider, OnionMessageProvider};
 use crate::ln::features::{InitFeatures, NodeFeatures};
 use crate::ln::msgs;
 use crate::ln::msgs::{ChannelMessageHandler, LightningError, NetAddress, OnionMessageHandler, RoutingMessageHandler};
@@ -27,9 +28,8 @@ use crate::ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
 use crate::ln::wire;
 use crate::ln::wire::Encode;
 use crate::onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
-use crate::routing::gossip::{NetworkGraph, P2PGossipSync, NodeId};
+use crate::routing::gossip::{NetworkGraph, P2PGossipSync, NodeId, NodeAlias};
 use crate::util::atomic_counter::AtomicCounter;
-use crate::util::events::{MessageSendEvent, MessageSendEventsProvider, OnionMessageProvider};
 use crate::util::logger::Logger;
 
 use crate::prelude::*;
@@ -259,10 +259,11 @@ impl Deref for ErroringMessageHandler {
 }
 
 /// Provides references to trait impls which handle different types of messages.
-pub struct MessageHandler<CM: Deref, RM: Deref, OM: Deref> where
-		CM::Target: ChannelMessageHandler,
-		RM::Target: RoutingMessageHandler,
-		OM::Target: OnionMessageHandler,
+pub struct MessageHandler<CM: Deref, RM: Deref, OM: Deref, CustomM: Deref> where
+	CM::Target: ChannelMessageHandler,
+	RM::Target: RoutingMessageHandler,
+	OM::Target: OnionMessageHandler,
+	CustomM::Target: CustomMessageHandler,
 {
 	/// A message handler which handles messages specific to channels. Usually this is just a
 	/// [`ChannelManager`] object or an [`ErroringMessageHandler`].
@@ -275,16 +276,22 @@ pub struct MessageHandler<CM: Deref, RM: Deref, OM: Deref> where
 	/// [`P2PGossipSync`]: crate::routing::gossip::P2PGossipSync
 	pub route_handler: RM,
 
-	/// A message handler which handles onion messages. For now, this can only be an
-	/// [`IgnoringMessageHandler`].
+	/// A message handler which handles onion messages. This should generally be an
+	/// [`OnionMessenger`], but can also be an [`IgnoringMessageHandler`].
+	///
+	/// [`OnionMessenger`]: crate::onion_message::OnionMessenger
 	pub onion_message_handler: OM,
+
+	/// A message handler which handles custom messages. The only LDK-provided implementation is
+	/// [`IgnoringMessageHandler`].
+	pub custom_message_handler: CustomM,
 }
 
 /// Provides an object which can be used to send data to and which uniquely identifies a connection
 /// to a remote host. You will need to be able to generate multiple of these which meet Eq and
 /// implement Hash to meet the PeerManager API.
 ///
-/// For efficiency, Clone should be relatively cheap for this type.
+/// For efficiency, [`Clone`] should be relatively cheap for this type.
 ///
 /// Two descriptors may compare equal (by [`cmp::Eq`] and [`hash::Hash`]) as long as the original
 /// has been disconnected, the [`PeerManager`] has been informed of the disconnection (either by it
@@ -416,7 +423,7 @@ struct Peer {
 	sync_status: InitSyncTracker,
 
 	msgs_sent_since_pong: usize,
-	awaiting_pong_timer_tick_intervals: i8,
+	awaiting_pong_timer_tick_intervals: i64,
 	received_message_since_timer_tick: bool,
 	sent_gossip_timestamp_filter: bool,
 
@@ -522,7 +529,7 @@ impl Peer {
 /// SimpleRefPeerManager is the more appropriate type. Defining these type aliases prevents
 /// issues such as overly long function definitions.
 ///
-/// (C-not exported) as `Arc`s don't make sense in bindings.
+/// This is not exported to bindings users as `Arc`s don't make sense in bindings.
 pub type SimpleArcPeerManager<SD, M, T, F, C, L> = PeerManager<SD, Arc<SimpleArcChannelManager<M, T, F, L>>, Arc<P2PGossipSync<Arc<NetworkGraph<Arc<L>>>, Arc<C>, Arc<L>>>, Arc<SimpleArcOnionMessenger<L>>, Arc<L>, IgnoringMessageHandler, Arc<KeysManager>>;
 
 /// SimpleRefPeerManager is a type alias for a PeerManager reference, and is the reference
@@ -532,9 +539,57 @@ pub type SimpleArcPeerManager<SD, M, T, F, C, L> = PeerManager<SD, Arc<SimpleArc
 /// But if this is not necessary, using a reference is more efficient. Defining these type aliases
 /// helps with issues such as long function definitions.
 ///
-/// (C-not exported) as general type aliases don't make sense in bindings.
+/// This is not exported to bindings users as general type aliases don't make sense in bindings.
 pub type SimpleRefPeerManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, SD, M, T, F, C, L> = PeerManager<SD, SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'm, M, T, F, L>, &'f P2PGossipSync<&'g NetworkGraph<&'f L>, &'h C, &'f L>, &'i SimpleRefOnionMessenger<'j, 'k, L>, &'f L, IgnoringMessageHandler, &'c KeysManager>;
 
+
+/// A generic trait which is implemented for all [`PeerManager`]s. This makes bounding functions or
+/// structs on any [`PeerManager`] much simpler as only this trait is needed as a bound, rather
+/// than the full set of bounds on [`PeerManager`] itself.
+#[allow(missing_docs)]
+pub trait APeerManager {
+	type Descriptor: SocketDescriptor;
+	type CMT: ChannelMessageHandler + ?Sized;
+	type CM: Deref<Target=Self::CMT>;
+	type RMT: RoutingMessageHandler + ?Sized;
+	type RM: Deref<Target=Self::RMT>;
+	type OMT: OnionMessageHandler + ?Sized;
+	type OM: Deref<Target=Self::OMT>;
+	type LT: Logger + ?Sized;
+	type L: Deref<Target=Self::LT>;
+	type CMHT: CustomMessageHandler + ?Sized;
+	type CMH: Deref<Target=Self::CMHT>;
+	type NST: NodeSigner + ?Sized;
+	type NS: Deref<Target=Self::NST>;
+	/// Gets a reference to the underlying [`PeerManager`].
+	fn as_ref(&self) -> &PeerManager<Self::Descriptor, Self::CM, Self::RM, Self::OM, Self::L, Self::CMH, Self::NS>;
+}
+
+impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CMH: Deref, NS: Deref>
+APeerManager for PeerManager<Descriptor, CM, RM, OM, L, CMH, NS> where
+	CM::Target: ChannelMessageHandler,
+	RM::Target: RoutingMessageHandler,
+	OM::Target: OnionMessageHandler,
+	L::Target: Logger,
+	CMH::Target: CustomMessageHandler,
+	NS::Target: NodeSigner,
+{
+	type Descriptor = Descriptor;
+	type CMT = <CM as Deref>::Target;
+	type CM = CM;
+	type RMT = <RM as Deref>::Target;
+	type RM = RM;
+	type OMT = <OM as Deref>::Target;
+	type OM = OM;
+	type LT = <L as Deref>::Target;
+	type L = L;
+	type CMHT = <CMH as Deref>::Target;
+	type CMH = CMH;
+	type NST = <NS as Deref>::Target;
+	type NS = NS;
+	fn as_ref(&self) -> &PeerManager<Descriptor, CM, RM, OM, L, CMH, NS> { self }
+}
+
 /// A PeerManager manages a set of peers, described by their [`SocketDescriptor`] and marshalls
 /// socket events into messages which it passes on to its [`MessageHandler`].
 ///
@@ -547,10 +602,10 @@ pub type SimpleRefPeerManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm
 /// [`PeerManager`] functions related to the same connection must occur only in serial, making new
 /// calls only after previous ones have returned.
 ///
-/// Rather than using a plain PeerManager, it is preferable to use either a SimpleArcPeerManager
-/// a SimpleRefPeerManager, for conciseness. See their documentation for more details, but
-/// essentially you should default to using a SimpleRefPeerManager, and use a
-/// SimpleArcPeerManager when you require a PeerManager with a static lifetime, such as when
+/// Rather than using a plain [`PeerManager`], it is preferable to use either a [`SimpleArcPeerManager`]
+/// a [`SimpleRefPeerManager`], for conciseness. See their documentation for more details, but
+/// essentially you should default to using a [`SimpleRefPeerManager`], and use a
+/// [`SimpleArcPeerManager`] when you require a `PeerManager` with a static lifetime, such as when
 /// you're using lightning-net-tokio.
 ///
 /// [`read_event`]: PeerManager::read_event
@@ -561,7 +616,7 @@ pub struct PeerManager<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: D
 		L::Target: Logger,
 		CMH::Target: CustomMessageHandler,
 		NS::Target: NodeSigner {
-	message_handler: MessageHandler<CM, RM, OM>,
+	message_handler: MessageHandler<CM, RM, OM, CMH>,
 	/// Connection state for each connected peer - we have an outer read-write lock which is taken
 	/// as read while we're doing processing for a peer and taken write when a peer is being added
 	/// or removed.
@@ -591,7 +646,6 @@ pub struct PeerManager<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: D
 	last_node_announcement_serial: AtomicU32,
 
 	ephemeral_key_midstate: Sha256Engine,
-	custom_message_handler: CMH,
 
 	peer_counter: AtomicCounter,
 
@@ -638,7 +692,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, OM: Deref, L: Deref, NS: Deref> Pe
 	/// `OnionMessageHandler`. No routing message handler is used and network graph messages are
 	/// ignored.
 	///
-	/// ephemeral_random_data is used to derive per-connection ephemeral keys and must be
+	/// `ephemeral_random_data` is used to derive per-connection ephemeral keys and must be
 	/// cryptographically secure random bytes.
 	///
 	/// `current_time` is used as an always-increasing counter that survives across restarts and is
@@ -646,13 +700,14 @@ impl<Descriptor: SocketDescriptor, CM: Deref, OM: Deref, L: Deref, NS: Deref> Pe
 	/// timestamp, however if it is not available a persistent counter that increases once per
 	/// minute should suffice.
 	///
-	/// (C-not exported) as we can't export a PeerManager with a dummy route handler
+	/// This is not exported to bindings users as we can't export a PeerManager with a dummy route handler
 	pub fn new_channel_only(channel_message_handler: CM, onion_message_handler: OM, current_time: u32, ephemeral_random_data: &[u8; 32], logger: L, node_signer: NS) -> Self {
 		Self::new(MessageHandler {
 			chan_handler: channel_message_handler,
 			route_handler: IgnoringMessageHandler{},
 			onion_message_handler,
-		}, current_time, ephemeral_random_data, logger, IgnoringMessageHandler{}, node_signer)
+			custom_message_handler: IgnoringMessageHandler{},
+		}, current_time, ephemeral_random_data, logger, node_signer)
 	}
 }
 
@@ -670,16 +725,17 @@ impl<Descriptor: SocketDescriptor, RM: Deref, L: Deref, NS: Deref> PeerManager<D
 	/// timestamp, however if it is not available a persistent counter that increases once per
 	/// minute should suffice.
 	///
-	/// ephemeral_random_data is used to derive per-connection ephemeral keys and must be
+	/// `ephemeral_random_data` is used to derive per-connection ephemeral keys and must be
 	/// cryptographically secure random bytes.
 	///
-	/// (C-not exported) as we can't export a PeerManager with a dummy channel handler
+	/// This is not exported to bindings users as we can't export a PeerManager with a dummy channel handler
 	pub fn new_routing_only(routing_message_handler: RM, current_time: u32, ephemeral_random_data: &[u8; 32], logger: L, node_signer: NS) -> Self {
 		Self::new(MessageHandler {
 			chan_handler: ErroringMessageHandler::new(),
 			route_handler: routing_message_handler,
 			onion_message_handler: IgnoringMessageHandler{},
-		}, current_time, ephemeral_random_data, logger, IgnoringMessageHandler{}, node_signer)
+			custom_message_handler: IgnoringMessageHandler{},
+		}, current_time, ephemeral_random_data, logger, node_signer)
 	}
 }
 
@@ -732,15 +788,16 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 		CMH::Target: CustomMessageHandler,
 		NS::Target: NodeSigner
 {
-	/// Constructs a new PeerManager with the given message handlers and node_id secret key
-	/// ephemeral_random_data is used to derive per-connection ephemeral keys and must be
+	/// Constructs a new `PeerManager` with the given message handlers.
+	///
+	/// `ephemeral_random_data` is used to derive per-connection ephemeral keys and must be
 	/// cryptographically secure random bytes.
 	///
 	/// `current_time` is used as an always-increasing counter that survives across restarts and is
 	/// incremented irregularly internally. In general it is best to simply use the current UNIX
 	/// timestamp, however if it is not available a persistent counter that increases once per
 	/// minute should suffice.
-	pub fn new(message_handler: MessageHandler<CM, RM, OM>, current_time: u32, ephemeral_random_data: &[u8; 32], logger: L, custom_message_handler: CMH, node_signer: NS) -> Self {
+	pub fn new(message_handler: MessageHandler<CM, RM, OM, CMH>, current_time: u32, ephemeral_random_data: &[u8; 32], logger: L, node_signer: NS) -> Self {
 		let mut ephemeral_key_midstate = Sha256::engine();
 		ephemeral_key_midstate.input(ephemeral_random_data);
 
@@ -760,7 +817,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 			gossip_processing_backlog_lifted: AtomicBool::new(false),
 			last_node_announcement_serial: AtomicU32::new(current_time),
 			logger,
-			custom_message_handler,
 			node_signer,
 			secp_ctx,
 		}
@@ -806,9 +862,9 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 	/// Returns a small number of bytes to send to the remote node (currently always 50).
 	///
 	/// Panics if descriptor is duplicative with some other descriptor which has not yet been
-	/// [`socket_disconnected()`].
+	/// [`socket_disconnected`].
 	///
-	/// [`socket_disconnected()`]: PeerManager::socket_disconnected
+	/// [`socket_disconnected`]: PeerManager::socket_disconnected
 	pub fn new_outbound_connection(&self, their_node_id: PublicKey, descriptor: Descriptor, remote_network_address: Option<NetAddress>) -> Result<Vec<u8>, PeerHandleError> {
 		let mut peer_encryptor = PeerChannelEncryptor::new_outbound(their_node_id.clone(), self.get_ephemeral_key());
 		let res = peer_encryptor.get_act_one(&self.secp_ctx).to_vec();
@@ -863,9 +919,9 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 	/// the connection immediately.
 	///
 	/// Panics if descriptor is duplicative with some other descriptor which has not yet been
-	/// [`socket_disconnected()`].
+	/// [`socket_disconnected`].
 	///
-	/// [`socket_disconnected()`]: PeerManager::socket_disconnected
+	/// [`socket_disconnected`]: PeerManager::socket_disconnected
 	pub fn new_inbound_connection(&self, descriptor: Descriptor, remote_network_address: Option<NetAddress>) -> Result<(), PeerHandleError> {
 		let peer_encryptor = PeerChannelEncryptor::new_inbound(&self.node_signer);
 		let pending_read_buffer = [0; 50].to_vec(); // Noise act one is 50 bytes
@@ -1011,7 +1067,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 	/// May call [`send_data`] on the descriptor passed in (or an equal descriptor) before
 	/// returning. Thus, be very careful with reentrancy issues! The invariants around calling
 	/// [`write_buffer_space_avail`] in case a write did not fully complete must still hold - be
-	/// ready to call `[write_buffer_space_avail`] again if a write call generated here isn't
+	/// ready to call [`write_buffer_space_avail`] again if a write call generated here isn't
 	/// sufficient!
 	///
 	/// [`send_data`]: SocketDescriptor::send_data
@@ -1055,7 +1111,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 		match self.do_read_event(peer_descriptor, data) {
 			Ok(res) => Ok(res),
 			Err(e) => {
-				log_trace!(self.logger, "Peer sent invalid data or we decided to disconnect due to a protocol error");
+				log_trace!(self.logger, "Disconnecting peer due to a protocol error (usually a duplicate connection).");
 				self.disconnect_event_internal(peer_descriptor);
 				Err(e)
 			}
@@ -1231,7 +1287,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 									peer.pending_read_is_header = true;
 
 									let mut reader = io::Cursor::new(&msg_data[..]);
-									let message_result = wire::read(&mut reader, &*self.custom_message_handler);
+									let message_result = wire::read(&mut reader, &*self.message_handler.custom_message_handler);
 									let message = match message_result {
 										Ok(x) => x,
 										Err(e) => {
@@ -1542,7 +1598,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 				log_trace!(self.logger, "Received unknown odd message of type {}, ignoring", type_id);
 			},
 			wire::Message::Custom(custom) => {
-				self.custom_message_handler.handle_custom_message(custom, &their_node_id)?;
+				self.message_handler.custom_message_handler.handle_custom_message(custom, &their_node_id)?;
 			},
 		};
 		Ok(should_forward)
@@ -1895,7 +1951,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 				}
 			}
 
-			for (node_id, msg) in self.custom_message_handler.get_and_clear_pending_msg() {
+			for (node_id, msg) in self.message_handler.custom_message_handler.get_and_clear_pending_msg() {
 				if peers_to_disconnect.get(&node_id).is_some() { continue; }
 				self.enqueue_message(&mut *get_peer_for_forwarding!(&node_id), &msg);
 			}
@@ -2102,7 +2158,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 						if let Some((node_id, _)) = peer.their_node_id {
 							self.node_id_to_descriptor.lock().unwrap().remove(&node_id);
 						}
-						self.do_disconnect(descriptor, &*peer, "ping timeout");
+						self.do_disconnect(descriptor, &*peer, "ping/handshake timeout");
 					}
 				}
 			}
@@ -2152,7 +2208,9 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 			features,
 			timestamp: self.last_node_announcement_serial.fetch_add(1, Ordering::AcqRel),
 			node_id: NodeId::from_pubkey(&self.node_signer.get_node_id(Recipient::Node).unwrap()),
-			rgb, alias, addresses,
+			rgb,
+			alias: NodeAlias(alias),
+			addresses,
 			excess_address_data: Vec::new(),
 			excess_data: Vec::new(),
 		};
@@ -2193,11 +2251,11 @@ fn is_gossip_msg(type_id: u16) -> bool {
 #[cfg(test)]
 mod tests {
 	use crate::chain::keysinterface::{NodeSigner, Recipient};
+	use crate::events;
 	use crate::ln::peer_channel_encryptor::PeerChannelEncryptor;
 	use crate::ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor, IgnoringMessageHandler, filter_addresses};
 	use crate::ln::{msgs, wire};
 	use crate::ln::msgs::NetAddress;
-	use crate::util::events;
 	use crate::util::test_utils;
 
 	use bitcoin::secp256k1::SecretKey;
@@ -2261,8 +2319,11 @@ mod tests {
 		let mut peers = Vec::new();
 		for i in 0..peer_count {
 			let ephemeral_bytes = [i as u8; 32];
-			let msg_handler = MessageHandler { chan_handler: &cfgs[i].chan_handler, route_handler: &cfgs[i].routing_handler, onion_message_handler: IgnoringMessageHandler {} };
-			let peer = PeerManager::new(msg_handler, 0, &ephemeral_bytes, &cfgs[i].logger, IgnoringMessageHandler {}, &cfgs[i].node_signer);
+			let msg_handler = MessageHandler {
+				chan_handler: &cfgs[i].chan_handler, route_handler: &cfgs[i].routing_handler,
+				onion_message_handler: IgnoringMessageHandler {}, custom_message_handler: IgnoringMessageHandler {}
+			};
+			let peer = PeerManager::new(msg_handler, 0, &ephemeral_bytes, &cfgs[i].logger, &cfgs[i].node_signer);
 			peers.push(peer);
 		}
 
@@ -2348,7 +2409,7 @@ mod tests {
 						if peers[0].read_event(&mut fd_a, &b_data).is_err() { break; }
 
 						cfgs[0].chan_handler.pending_events.lock().unwrap()
-							.push(crate::util::events::MessageSendEvent::SendShutdown {
+							.push(crate::events::MessageSendEvent::SendShutdown {
 								node_id: peers[1].node_signer.get_node_id(Recipient::Node).unwrap(),
 								msg: msgs::Shutdown {
 									channel_id: [0; 32],
@@ -2356,7 +2417,7 @@ mod tests {
 								},
 							});
 						cfgs[1].chan_handler.pending_events.lock().unwrap()
-							.push(crate::util::events::MessageSendEvent::SendShutdown {
+							.push(crate::events::MessageSendEvent::SendShutdown {
 								node_id: peers[0].node_signer.get_node_id(Recipient::Node).unwrap(),
 								msg: msgs::Shutdown {
 									channel_id: [0; 32],