Pass peer's Init message through to ChannelManager

[rust-lightning] / lightning / src / ln / peer_handler.rs

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index 902598a79abceed04b68d28f009c29a4d32a3a58..481737f362adbef751ca121bf1a470ac00258f20 100644 (file)
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -8,6 +8,7 @@
 
 use secp256k1::key::{SecretKey,PublicKey};
 
+use ln::features::InitFeatures;
 use ln::msgs;
 use util::ser::{Writeable, Writer, Readable};
 use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
@@ -103,7 +104,7 @@ struct Peer {
        channel_encryptor: PeerChannelEncryptor,
        outbound: bool,
        their_node_id: Option<PublicKey>,
-       their_features: Option<msgs::InitFeatures>,
+       their_features: Option<InitFeatures>,
 
        pending_outbound_buffer: LinkedList<Vec<u8>>,
        pending_outbound_buffer_first_msg_offset: usize,
@@ -142,20 +143,6 @@ struct PeerHolder<Descriptor: SocketDescriptor> {
        /// Only add to this set when noise completes:
        node_id_to_descriptor: HashMap<PublicKey, Descriptor>,
 }
-struct MutPeerHolder<'a, Descriptor: SocketDescriptor + 'a> {
-       peers: &'a mut HashMap<Descriptor, Peer>,
-       peers_needing_send: &'a mut HashSet<Descriptor>,
-       node_id_to_descriptor: &'a mut HashMap<PublicKey, Descriptor>,
-}
-impl<Descriptor: SocketDescriptor> PeerHolder<Descriptor> {
-       fn borrow_parts(&mut self) -> MutPeerHolder<Descriptor> {
-               MutPeerHolder {
-                       peers: &mut self.peers,
-                       peers_needing_send: &mut self.peers_needing_send,
-                       node_id_to_descriptor: &mut self.node_id_to_descriptor,
-               }
-       }
-}
 
 #[cfg(not(any(target_pointer_width = "32", target_pointer_width = "64")))]
 fn _check_usize_is_32_or_64() {
@@ -450,7 +437,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
        fn do_read_event(&self, peer_descriptor: &mut Descriptor, data: Vec<u8>) -> Result<bool, PeerHandleError> {
                let pause_read = {
                        let mut peers_lock = self.peers.lock().unwrap();
-                       let peers = peers_lock.borrow_parts();
+                       let peers = &mut *peers_lock;
                        let pause_read = match peers.peers.get_mut(peer_descriptor) {
                                None => panic!("Descriptor for read_event is not already known to PeerManager"),
                                Some(peer) => {
@@ -567,7 +554,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
 
                                                                        peer.their_node_id = Some(their_node_id);
                                                                        insert_node_id!();
-                                                                       let mut features = msgs::InitFeatures::supported();
+                                                                       let mut features = InitFeatures::supported();
                                                                        if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND {
                                                                                self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel);
                                                                                features.set_initial_routing_sync();
@@ -635,10 +622,9 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                                                        peer.sync_status = InitSyncTracker::ChannelsSyncing(0);
                                                                                                        peers.peers_needing_send.insert(peer_descriptor.clone());
                                                                                                }
-                                                                                               peer.their_features = Some(msg.features);
 
                                                                                                if !peer.outbound {
-                                                                                                       let mut features = msgs::InitFeatures::supported();
+                                                                                                       let mut features = InitFeatures::supported();
                                                                                                        if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND {
                                                                                                                self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel);
                                                                                                                features.set_initial_routing_sync();
@@ -649,7 +635,8 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                                                        }, 16);
                                                                                                }
 
-                                                                                               self.message_handler.chan_handler.peer_connected(&peer.their_node_id.unwrap());
+                                                                                               self.message_handler.chan_handler.peer_connected(&peer.their_node_id.unwrap(), &msg);
+                                                                                               peer.their_features = Some(msg.features);
                                                                                        },
                                                                                        17 => {
                                                                                                let msg = try_potential_decodeerror!(msgs::ErrorMessage::read(&mut reader));
@@ -813,7 +800,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
 
                        let mut events_generated = self.message_handler.chan_handler.get_and_clear_pending_msg_events();
                        let mut peers_lock = self.peers.lock().unwrap();
-                       let peers = peers_lock.borrow_parts();
+                       let peers = &mut *peers_lock;
                        for event in events_generated.drain(..) {
                                macro_rules! get_peer_for_forwarding {
                                        ($node_id: expr, $handle_no_such_peer: block) => {
@@ -1096,10 +1083,10 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
        pub fn timer_tick_occured(&self) {
                let mut peers_lock = self.peers.lock().unwrap();
                {
-                       let peers = peers_lock.borrow_parts();
-                       let peers_needing_send = peers.peers_needing_send;
-                       let node_id_to_descriptor = peers.node_id_to_descriptor;
-                       let peers = peers.peers;
+                       let peers = &mut *peers_lock;
+                       let peers_needing_send = &mut peers.peers_needing_send;
+                       let node_id_to_descriptor = &mut peers.node_id_to_descriptor;
+                       let peers = &mut peers.peers;
 
                        peers.retain(|descriptor, peer| {
                                if peer.awaiting_pong == true {