X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpeer_handler.rs;h=ae2a52378e4279337afe4e04731eb1e1727b6487;hb=3313abb37d8745597c7fe8aeaa230f4e89160e02;hp=bb4b076b1bef313c72486a5d00b3494b66fdbaef;hpb=369eea45a1efadda2dc1fe6496dfdcaad0c4d1e1;p=rust-lightning diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index bb4b076b..ae2a5237 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -17,7 +17,7 @@ use bitcoin::secp256k1::{self, Secp256k1, SecretKey, PublicKey}; -use crate::chain::keysinterface::{KeysManager, NodeSigner, Recipient}; +use crate::sign::{KeysManager, NodeSigner, Recipient}; use crate::events::{MessageSendEvent, MessageSendEventsProvider, OnionMessageProvider}; use crate::ln::features::{InitFeatures, NodeFeatures}; use crate::ln::msgs; @@ -28,7 +28,7 @@ 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::logger::Logger; @@ -64,6 +64,20 @@ pub trait CustomMessageHandler: wire::CustomMessageReader { /// in the process. Each message is paired with the node id of the intended recipient. If no /// connection to the node exists, then the message is simply not sent. fn get_and_clear_pending_msg(&self) -> Vec<(PublicKey, Self::CustomMessage)>; + + /// Gets the node feature flags which this handler itself supports. All available handlers are + /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`] + /// which are broadcasted in our [`NodeAnnouncement`] message. + /// + /// [`NodeAnnouncement`]: crate::ln::msgs::NodeAnnouncement + fn provided_node_features(&self) -> NodeFeatures; + + /// Gets the init feature flags which should be sent to the given peer. All available handlers + /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`] + /// which are sent in our [`Init`] message. + /// + /// [`Init`]: crate::ln::msgs::Init + fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures; } /// A dummy struct which implements `RoutingMessageHandler` without storing any routing information @@ -149,6 +163,12 @@ impl CustomMessageHandler for IgnoringMessageHandler { } fn get_and_clear_pending_msg(&self) -> Vec<(PublicKey, Self::CustomMessage)> { Vec::new() } + + fn provided_node_features(&self) -> NodeFeatures { NodeFeatures::empty() } + + fn provided_init_features(&self, _their_node_id: &PublicKey) -> InitFeatures { + InitFeatures::empty() + } } /// A dummy struct which implements `ChannelMessageHandler` without having any channels. @@ -259,10 +279,11 @@ impl Deref for ErroringMessageHandler { } /// Provides references to trait impls which handle different types of messages. -pub struct MessageHandler where - CM::Target: ChannelMessageHandler, - RM::Target: RoutingMessageHandler, - OM::Target: OnionMessageHandler, +pub struct MessageHandler 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,9 +296,15 @@ pub struct MessageHandler 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 @@ -416,7 +443,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, @@ -535,6 +562,54 @@ pub type SimpleArcPeerManager = PeerManager = PeerManager, &'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; + type RMT: RoutingMessageHandler + ?Sized; + type RM: Deref; + type OMT: OnionMessageHandler + ?Sized; + type OM: Deref; + type LT: Logger + ?Sized; + type L: Deref; + type CMHT: CustomMessageHandler + ?Sized; + type CMH: Deref; + type NST: NodeSigner + ?Sized; + type NS: Deref; + /// Gets a reference to the underlying [`PeerManager`]. + fn as_ref(&self) -> &PeerManager; +} + +impl +APeerManager for PeerManager where + CM::Target: ChannelMessageHandler, + RM::Target: RoutingMessageHandler, + OM::Target: OnionMessageHandler, + L::Target: Logger, + CMH::Target: CustomMessageHandler, + NS::Target: NodeSigner, +{ + type Descriptor = Descriptor; + type CMT = ::Target; + type CM = CM; + type RMT = ::Target; + type RM = RM; + type OMT = ::Target; + type OM = OM; + type LT = ::Target; + type L = L; + type CMHT = ::Target; + type CMH = CMH; + type NST = ::Target; + type NS = NS; + fn as_ref(&self) -> &PeerManager { 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`]. /// @@ -561,7 +636,7 @@ pub struct PeerManager, + message_handler: MessageHandler, /// 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 +666,6 @@ pub struct PeerManager Pe 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) } } @@ -679,7 +754,8 @@ impl PeerManager, current_time: u32, ephemeral_random_data: &[u8; 32], logger: L, custom_message_handler: CMH, node_signer: NS) -> Self { + pub fn new(message_handler: MessageHandler, 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); @@ -761,7 +837,6 @@ impl InitFeatures { + self.message_handler.chan_handler.provided_init_features(their_node_id) + | self.message_handler.route_handler.provided_init_features(their_node_id) + | self.message_handler.onion_message_handler.provided_init_features(their_node_id) + | self.message_handler.custom_message_handler.provided_init_features(their_node_id) + } + /// Indicates a new outbound connection has been established to a node with the given `node_id` /// and an optional remote network address. /// @@ -1056,7 +1138,7 @@ impl 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) } @@ -1190,9 +1272,7 @@ impl x, Err(e) => { @@ -1543,7 +1621,7 @@ impl { - 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) @@ -1896,7 +1974,7 @@ impl bool { #[cfg(test)] mod tests { - use crate::chain::keysinterface::{NodeSigner, Recipient}; + use crate::sign::{NodeSigner, Recipient}; use crate::events; use crate::ln::peer_channel_encryptor::PeerChannelEncryptor; use crate::ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor, IgnoringMessageHandler, filter_addresses}; @@ -2262,8 +2343,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); }