Merge pull request #30 from TheBlueMatt/master

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

diff --git a/src/ln/peer_handler.rs b/src/ln/peer_handler.rs
index 7b140b0797284f04ca55d993b75a45f53be5069a..aec3a32e945b3f773c0519e46aec957696d1f50c 100644 (file)
--- a/src/ln/peer_handler.rs
+++ b/src/ln/peer_handler.rs
@@ -8,6 +8,7 @@ use util::events::{EventsProvider,Event};
 
 use std::collections::{HashMap,LinkedList};
 use std::sync::{Arc, Mutex};
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::{cmp,error,mem,hash,fmt};
 
 pub struct MessageHandler {
@@ -86,6 +87,7 @@ pub struct PeerManager<Descriptor: SocketDescriptor> {
        peers: Mutex<PeerHolder<Descriptor>>,
        pending_events: Mutex<Vec<Event>>,
        our_node_secret: SecretKey,
+       initial_syncs_sent: AtomicUsize,
 }
 
 
@@ -101,6 +103,9 @@ macro_rules! encode_msg {
        }
 }
 
+//TODO: Really should do something smarter for this
+const INITIAL_SYNCS_TO_SEND: usize = 5;
+
 /// Manages and reacts to connection events. You probably want to use file descriptors as PeerIds.
 /// PeerIds may repeat, but only after disconnect_event() has been called.
 impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
@@ -110,6 +115,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                        peers: Mutex::new(PeerHolder { peers: HashMap::new(), node_id_to_descriptor: HashMap::new() }),
                        pending_events: Mutex::new(Vec::new()),
                        our_node_secret: our_node_secret,
+                       initial_syncs_sent: AtomicUsize::new(0),
                }
        }
 
@@ -272,16 +278,19 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                        match $thing {
                                                                                Ok(x) => x,
                                                                                Err(e) => {
-                                                                                       // TODO: Log e.err
+                                                                                       println!("Got error handling message: {}!", e.err);
                                                                                        if let Some(action) = e.msg {
                                                                                                match action {
                                                                                                        msgs::ErrorAction::UpdateFailHTLC { msg } => {
                                                                                                                encode_and_send_msg!(msg, 131);
                                                                                                                continue;
                                                                                                        },
-                                                                                                       msgs::ErrorAction::DisconnectPeer {} => {
+                                                                                                       msgs::ErrorAction::DisconnectPeer => {
                                                                                                                return Err(PeerHandleError{ no_connection_possible: false });
                                                                                                        },
+                                                                                                       msgs::ErrorAction::IgnoreError => {
+                                                                                                               continue;
+                                                                                                       },
                                                                                                }
                                                                                        } else {
                                                                                                return Err(PeerHandleError{ no_connection_possible: false });
@@ -296,6 +305,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                        match $thing {
                                                                                Ok(x) => x,
                                                                                Err(_e) => {
+                                                                                       println!("Error decoding message");
                                                                                        //TODO: Handle e?
                                                                                        return Err(PeerHandleError{ no_connection_possible: false });
                                                                                }
@@ -303,6 +313,18 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                }
                                                        }
 
+                                                       macro_rules! try_ignore_potential_decodeerror {
+                                                               ($thing: expr) => {
+                                                                       match $thing {
+                                                                               Ok(x) => x,
+                                                                               Err(_e) => {
+                                                                                       println!("Error decoding message, ignoring due to lnd spec incompatibility. See https://github.com/lightningnetwork/lnd/issues/1407");
+                                                                                       continue;
+                                                                               }
+                                                                       };
+                                                               }
+                                                       }
+
                                                        let next_step = peer.channel_encryptor.get_noise_step();
                                                        match next_step {
                                                                NextNoiseStep::ActOne => {
@@ -317,9 +339,14 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                        peer.pending_read_is_header = true;
 
                                                                        insert_node_id = Some(peer.their_node_id.unwrap());
+                                                                       let mut local_features = msgs::LocalFeatures::new();
+                                                                       if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND {
+                                                                               self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel);
+                                                                               local_features.set_initial_routing_sync();
+                                                                       }
                                                                        encode_and_send_msg!(msgs::Init {
                                                                                global_features: msgs::GlobalFeatures::new(),
-                                                                               local_features: msgs::LocalFeatures::new(),
+                                                                               local_features,
                                                                        }, 16);
                                                                },
                                                                NextNoiseStep::ActThree => {
@@ -365,17 +392,29 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                                                peer.their_local_features = Some(msg.local_features);
 
                                                                                                if !peer.outbound {
+                                                                                                       let mut local_features = msgs::LocalFeatures::new();
+                                                                                                       if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND {
+                                                                                                               self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel);
+                                                                                                               local_features.set_initial_routing_sync();
+                                                                                                       }
                                                                                                        encode_and_send_msg!(msgs::Init {
                                                                                                                global_features: msgs::GlobalFeatures::new(),
-                                                                                                               local_features: msgs::LocalFeatures::new(),
+                                                                                                               local_features,
                                                                                                        }, 16);
                                                                                                }
                                                                                        },
                                                                                        17 => {
                                                                                                // Error msg
                                                                                        },
-                                                                                       18 => { }, // ping
-                                                                                       19 => { }, // pong
+
+                                                                                       18 => {
+                                                                                               let msg = try_potential_decodeerror!(msgs::Ping::decode(&msg_data[2..]));
+                                                                                               let resp = msgs::Pong { byteslen: msg.ponglen };
+                                                                                               encode_and_send_msg!(resp, 19);
+                                                                                       },
+                                                                                       19 => {
+                                                                                               try_potential_decodeerror!(msgs::Pong::decode(&msg_data[2..]));
+                                                                                       },
 
                                                                                        // Channel control:
                                                                                        32 => {
@@ -491,7 +530,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                                                }
                                                                                        },
                                                                                        257 => {
-                                                                                               let msg = try_potential_decodeerror!(msgs::NodeAnnouncement::decode(&msg_data[2..]));
+                                                                                               let msg = try_ignore_potential_decodeerror!(msgs::NodeAnnouncement::decode(&msg_data[2..]));
                                                                                                try_potential_handleerror!(self.message_handler.route_handler.handle_node_announcement(&msg));
                                                                                        },
                                                                                        258 => {