Fix XXXs that slipped into router and handle HTLCFailCHannelUpdates

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

diff --git a/src/ln/peer_handler.rs b/src/ln/peer_handler.rs
index 13d3f1a681028aed9ab3dc05467f32a032fdac41..94cdef9e41fe76f7fa568edba784961edaeb8825 100644 (file)
--- a/src/ln/peer_handler.rs
+++ b/src/ln/peer_handler.rs
@@ -615,10 +615,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                                        },
                                                                                        131 => {
                                                                                                let msg = try_potential_decodeerror!(msgs::UpdateFailHTLC::read(&mut reader));
-                                                                                               let chan_update = try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fail_htlc(&peer.their_node_id.unwrap(), &msg));
-                                                                                               if let Some(update) = chan_update {
-                                                                                                       self.message_handler.route_handler.handle_htlc_fail_channel_update(&update);
-                                                                                               }
+                                                                                               try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fail_htlc(&peer.their_node_id.unwrap(), &msg));
                                                                                        },
                                                                                        135 => {
                                                                                                let msg = try_potential_decodeerror!(msgs::UpdateFailMalformedHTLC::read(&mut reader));
@@ -647,6 +644,9 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                                                                for resp in resps.update_fail_htlcs {
                                                                                                                        encode_and_send_msg!(resp, 131);
                                                                                                                }
+                                                                                                               if let Some(resp) = resps.update_fee {
+                                                                                                                       encode_and_send_msg!(resp, 134);
+                                                                                                               }
                                                                                                                encode_and_send_msg!(resps.commitment_signed, 132);
                                                                                                        },
                                                                                                        None => {},
@@ -658,27 +658,44 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                                        },
                                                                                        136 => {
                                                                                                let msg = try_potential_decodeerror!(msgs::ChannelReestablish::read(&mut reader));
-                                                                                               let (funding_locked, revoke_and_ack, commitment_update) = try_potential_handleerror!(self.message_handler.chan_handler.handle_channel_reestablish(&peer.their_node_id.unwrap(), &msg));
+                                                                                               let (funding_locked, revoke_and_ack, commitment_update, order) = try_potential_handleerror!(self.message_handler.chan_handler.handle_channel_reestablish(&peer.their_node_id.unwrap(), &msg));
                                                                                                if let Some(lock_msg) = funding_locked {
                                                                                                        encode_and_send_msg!(lock_msg, 36);
                                                                                                }
-                                                                                               if let Some(revoke_msg) = revoke_and_ack {
-                                                                                                       encode_and_send_msg!(revoke_msg, 133);
-                                                                                               }
-                                                                                               match commitment_update {
-                                                                                                       Some(resps) => {
-                                                                                                               for resp in resps.update_add_htlcs {
-                                                                                                                       encode_and_send_msg!(resp, 128);
-                                                                                                               }
-                                                                                                               for resp in resps.update_fulfill_htlcs {
-                                                                                                                       encode_and_send_msg!(resp, 130);
-                                                                                                               }
-                                                                                                               for resp in resps.update_fail_htlcs {
-                                                                                                                       encode_and_send_msg!(resp, 131);
-                                                                                                               }
-                                                                                                               encode_and_send_msg!(resps.commitment_signed, 132);
+                                                                                               macro_rules! handle_raa { () => {
+                                                                                                       if let Some(revoke_msg) = revoke_and_ack {
+                                                                                                               encode_and_send_msg!(revoke_msg, 133);
+                                                                                                       }
+                                                                                               } }
+                                                                                               macro_rules! handle_cu { () => {
+                                                                                                       match commitment_update {
+                                                                                                               Some(resps) => {
+                                                                                                                       for resp in resps.update_add_htlcs {
+                                                                                                                               encode_and_send_msg!(resp, 128);
+                                                                                                                       }
+                                                                                                                       for resp in resps.update_fulfill_htlcs {
+                                                                                                                               encode_and_send_msg!(resp, 130);
+                                                                                                                       }
+                                                                                                                       for resp in resps.update_fail_htlcs {
+                                                                                                                               encode_and_send_msg!(resp, 131);
+                                                                                                                       }
+                                                                                                                       if let Some(resp) = resps.update_fee {
+                                                                                                                               encode_and_send_msg!(resp, 134);
+                                                                                                                       }
+                                                                                                                       encode_and_send_msg!(resps.commitment_signed, 132);
+                                                                                                               },
+                                                                                                               None => {},
+                                                                                                       }
+                                                                                               } }
+                                                                                               match order {
+                                                                                                       msgs::RAACommitmentOrder::RevokeAndACKFirst => {
+                                                                                                               handle_raa!();
+                                                                                                               handle_cu!();
+                                                                                                       },
+                                                                                                       msgs::RAACommitmentOrder::CommitmentFirst => {
+                                                                                                               handle_cu!();
+                                                                                                               handle_raa!();
                                                                                                        },
-                                                                                                       None => {},
                                                                                                }
                                                                                        },
 
@@ -820,7 +837,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                Self::do_attempt_write_data(&mut descriptor, peer);
                                                continue;
                                        },
-                                       Event::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref commitment_signed } } => {
+                                       Event::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => {
                                                log_trace!(self, "Handling UpdateHTLCs event in peer_handler for node {} with {} adds, {} fulfills, {} fails for channel {}",
                                                                log_pubkey!(node_id),
                                                                update_add_htlcs.len(),
@@ -842,10 +859,24 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                for msg in update_fail_malformed_htlcs {
                                                        peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 135)));
                                                }
+                                               if let &Some(ref msg) = update_fee {
+                                                       peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 134)));
+                                               }
                                                peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(commitment_signed, 132)));
                                                Self::do_attempt_write_data(&mut descriptor, peer);
                                                continue;
                                        },
+                                       Event::SendRevokeAndACK { ref node_id, ref msg } => {
+                                               log_trace!(self, "Handling SendRevokeAndACK event in peer_handler for node {} for channel {}",
+                                                               log_pubkey!(node_id),
+                                                               log_bytes!(msg.channel_id));
+                                               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, 133)));
+                                               Self::do_attempt_write_data(&mut descriptor, peer);
+                                               continue;
+                                       },
                                        Event::SendShutdown { ref node_id, ref msg } => {
                                                log_trace!(self, "Handling Shutdown event in peer_handler for node {} for channel {}",
                                                                log_pubkey!(node_id),
@@ -897,6 +928,10 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                }
                                                continue;
                                        },
+                                       Event::PaymentFailureNetworkUpdate { ref update } => {
+                                               self.message_handler.route_handler.handle_htlc_fail_channel_update(update);
+                                               continue;
+                                       },
                                        Event::HandleError { ref node_id, ref action } => {
                                                if let Some(ref action) = *action {
                                                        match *action {