Merge pull request #13 from TheBlueMatt/2018-03-htlc-failures

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

diff --git a/src/ln/peer_handler.rs b/src/ln/peer_handler.rs
index bddc87b99fd7d6b95c9b603a7bd33062d405e0d3..2b60bbf122bce3af47a16997afe48740ede9805a 100644 (file)
--- a/src/ln/peer_handler.rs
+++ b/src/ln/peer_handler.rs
@@ -8,13 +8,11 @@ use util::events::{EventsProvider,Event};
 
 use std::collections::{HashMap,LinkedList};
 use std::sync::{Arc, Mutex};
-use std::cmp;
-use std::mem;
-use std::hash;
+use std::{cmp,mem,hash,fmt};
 
 pub struct MessageHandler {
-    pub chan_handler: Arc<msgs::ChannelMessageHandler>,
-    pub route_handler: Arc<msgs::RoutingMessageHandler>,
+       pub chan_handler: Arc<msgs::ChannelMessageHandler>,
+       pub route_handler: Arc<msgs::RoutingMessageHandler>,
 }
 
 /// Provides an object which can be used to send data to and which uniquely identifies a connection
@@ -43,6 +41,11 @@ pub trait SocketDescriptor : cmp::Eq + hash::Hash + Clone {
 /// disconnect_event (unless it was provided in response to a new_*_connection event, in which case
 /// no such disconnect_event must be generated and the socket be silently disconencted).
 pub struct PeerHandleError {}
+impl fmt::Debug for PeerHandleError {
+       fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+               formatter.write_str("Peer Send Invalid Data")
+       }
+}
 
 struct Peer {
        channel_encryptor: PeerChannelEncryptor,
@@ -206,6 +209,16 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
        /// course of this function!
        /// Panics if the descriptor was not previously registered in a new_*_connection event.
        pub fn read_event(&self, peer_descriptor: &mut Descriptor, data: Vec<u8>) -> Result<bool, PeerHandleError> {
+               match self.do_read_event(peer_descriptor, data) {
+                       Ok(res) => Ok(res),
+                       Err(e) => {
+                               self.disconnect_event(peer_descriptor);
+                               Err(e)
+                       }
+               }
+       }
+
+       fn do_read_event(&self, peer_descriptor: &mut Descriptor, data: Vec<u8>) -> Result<bool, PeerHandleError> {
                let mut upstream_events = Vec::new();
                let pause_read = {
                        let mut peers = self.peers.lock().unwrap();
@@ -286,7 +299,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                                let msg_len = try_potential_handleerror!(peer.channel_encryptor.decrypt_length_header(&peer.pending_read_buffer[..]));
                                                                                peer.pending_read_buffer = Vec::with_capacity(msg_len as usize + 16);
                                                                                peer.pending_read_buffer.resize(msg_len as usize + 16, 0);
-                                                                               if msg_len < 2 + 16 { // Need at least the message type tag
+                                                                               if msg_len < 2 { // Need at least the message type tag
                                                                                        return Err(PeerHandleError{});
                                                                                }
                                                                                peer.pending_read_is_header = false;
@@ -489,6 +502,8 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                        Event::FundingGenerationReady {..} => { /* Hand upstream */ },
                                        Event::FundingBroadcastSafe {..} => { /* Hand upstream */ },
                                        Event::PaymentReceived {..} => { /* Hand upstream */ },
+                                       Event::PaymentSent {..} => { /* Hand upstream */ },
+                                       Event::PaymentFailed {..} => { /* Hand upstream */ },
 
                                        Event::PendingHTLCsForwardable {..} => {
                                                //TODO: Handle upstream in some confused form so that upstream just knows
@@ -534,6 +549,14 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                Self::do_attempt_write_data(&mut descriptor, peer);
                                                continue;
                                        },
+                                       Event::SendFailHTLC { ref node_id, ref msg } => {
+                                               let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, {
+                                                               //TODO: Do whatever we're gonna do for handling dropped messages
+                                                       });
+                                               peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 131)));
+                                               Self::do_attempt_write_data(&mut descriptor, peer);
+                                               continue;
+                                       },
                                        Event::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
                                                let encoded_msg = encode_msg!(msg, 256);
                                                let encoded_update_msg = encode_msg!(update_msg, 258);