Handle sending and receiving warning messages

diff --git a/lightning/src/ln/msgs.rs b/lightning/src/ln/msgs.rs
index 1335a04c47a1c4f0e957cee9ce9a094acfcd244e..6c04636a4355c96fb0f5158887f855a93977e7b7 100644 (file)
--- a/lightning/src/ln/msgs.rs
+++ b/lightning/src/ln/msgs.rs
@@ -731,7 +731,16 @@ pub enum ErrorAction {
        /// The peer did something incorrect. Tell them.
        SendErrorMessage {
                /// The message to send.
-               msg: ErrorMessage
+               msg: ErrorMessage,
+       },
+       /// The peer did something incorrect. Tell them without closing any channels.
+       SendWarningMessage {
+               /// The message to send.
+               msg: WarningMessage,
+               /// The peer may have done something harmless that we weren't able to meaningfully process,
+               /// though we should still tell them about it.
+               /// If this event is logged, log it at the given level.
+               log_level: logger::Level,
        },
 }
 

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index 9157dc87dc2fc5e415de7679974bfe0de3a91f0c..6607d986affd062eee04fb987256d571cec88bb4 100644 (file)
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -821,6 +821,11 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, CMH: Deref> P
                                                                                                        self.enqueue_message(peer, &msg);
                                                                                                        continue;
                                                                                                },
+                                                                                               msgs::ErrorAction::SendWarningMessage { msg, log_level } => {
+                                                                                                       log_given_level!(self.logger, log_level, "Error handling message{}; sending warning message with: {}", OptionalFromDebugger(&peer.their_node_id), e.err);
+                                                                                                       self.enqueue_message(peer, &msg);
+                                                                                                       continue;
+                                                                                               },
                                                                                        }
                                                                                }
                                                                        }
@@ -1022,6 +1027,21 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, CMH: Deref> P
                                        return Err(PeerHandleError{ no_connection_possible: true }.into());
                                }
                        },
+                       wire::Message::Warning(msg) => {
+                               let mut data_is_printable = true;
+                               for b in msg.data.bytes() {
+                                       if b < 32 || b > 126 {
+                                               data_is_printable = false;
+                                               break;
+                                       }
+                               }
+
+                               if data_is_printable {
+                                       log_debug!(self.logger, "Got warning message from {}: {}", log_pubkey!(peer.their_node_id.unwrap()), msg.data);
+                               } else {
+                                       log_debug!(self.logger, "Got warning message from {} with non-ASCII error message", log_pubkey!(peer.their_node_id.unwrap()));
+                               }
+                       },
 
                        wire::Message::Ping(msg) => {
                                if msg.ponglen < 65532 {
@@ -1419,6 +1439,12 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, CMH: Deref> P
                                                                                msg.data);
                                                                self.enqueue_message(get_peer_for_forwarding!(node_id), msg);
                                                        },
+                                                       msgs::ErrorAction::SendWarningMessage { ref msg, ref log_level } => {
+                                                               log_given_level!(self.logger, *log_level, "Handling SendWarningMessage HandleError event in peer_handler for node {} with message {}",
+                                                                               log_pubkey!(node_id),
+                                                                               msg.data);
+                                                               self.enqueue_message(get_peer_for_forwarding!(node_id), msg);
+                                                       },
                                                }
                                        },
                                        MessageSendEvent::SendChannelRangeQuery { ref node_id, ref msg } => {

diff --git a/lightning/src/ln/wire.rs b/lightning/src/ln/wire.rs
index d3cc257f5a6b18cb1776475b4fec69949521e1d6..2c77fd46b8d92f8730e19d65448665f2fd86c710 100644 (file)
--- a/lightning/src/ln/wire.rs
+++ b/lightning/src/ln/wire.rs
@@ -35,6 +35,7 @@ pub trait CustomMessageReader {
 pub(crate) enum Message<T> where T: core::fmt::Debug + Type {
        Init(msgs::Init),
        Error(msgs::ErrorMessage),
+       Warning(msgs::WarningMessage),
        Ping(msgs::Ping),
        Pong(msgs::Pong),
        OpenChannel(msgs::OpenChannel),
@@ -74,6 +75,7 @@ impl<T> Message<T> where T: core::fmt::Debug + Type {
                match self {
                        &Message::Init(ref msg) => msg.type_id(),
                        &Message::Error(ref msg) => msg.type_id(),
+                       &Message::Warning(ref msg) => msg.type_id(),
                        &Message::Ping(ref msg) => msg.type_id(),
                        &Message::Pong(ref msg) => msg.type_id(),
                        &Message::OpenChannel(ref msg) => msg.type_id(),
@@ -133,6 +135,9 @@ where
                msgs::ErrorMessage::TYPE => {
                        Ok(Message::Error(Readable::read(buffer)?))
                },
+               msgs::WarningMessage::TYPE => {
+                       Ok(Message::Warning(Readable::read(buffer)?))
+               },
                msgs::Ping::TYPE => {
                        Ok(Message::Ping(Readable::read(buffer)?))
                },
@@ -264,6 +269,10 @@ impl Encode for msgs::ErrorMessage {
        const TYPE: u16 = 17;
 }
 
+impl Encode for msgs::WarningMessage {
+       const TYPE: u16 = 1;
+}
+
 impl Encode for msgs::Ping {
        const TYPE: u16 = 18;
 }