From f819d2cbab0d6f7be6e54595270e8db055d26941 Mon Sep 17 00:00:00 2001 From: Jeffrey Czyz Date: Wed, 18 Aug 2021 10:41:01 -0500 Subject: [PATCH] Remove wire::MessageType in favor of u16 With custom messages, wire::Type was introduced. wire::MessageType is a bit redundant, so use u16 instead and move is_even to wire::Message. --- lightning/src/ln/peer_handler.rs | 11 ++++---- lightning/src/ln/wire.rs | 47 ++++++++++++-------------------- 2 files changed, 22 insertions(+), 36 deletions(-) diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index e4c8ef49f6f..0c409501004 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -24,7 +24,6 @@ use ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager}; use util::ser::{VecWriter, Writeable, Writer}; use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep}; use ln::wire; -use ln::wire::MessageType; use util::byte_utils; use util::events::{MessageSendEvent, MessageSendEventsProvider}; use util::logger::Logger; @@ -88,7 +87,7 @@ pub struct IgnoringCustomMessageHandler{} type DummyCustomType = (); impl wire::Type for DummyCustomType { - fn type_id(&self) -> MessageType { + fn type_id(&self) -> u16 { // We should never call this for `DummyCustomType` unreachable!(); } @@ -1088,13 +1087,13 @@ impl P }, // Unknown messages: - wire::Message::Unknown(msg_type) if msg_type.is_even() => { - log_debug!(self.logger, "Received unknown even message of type {}, disconnecting peer!", msg_type); + wire::Message::Unknown(type_id) if message.is_even() => { + log_debug!(self.logger, "Received unknown even message of type {}, disconnecting peer!", type_id); // Fail the channel if message is an even, unknown type as per BOLT #1. return Err(PeerHandleError{ no_connection_possible: true }.into()); }, - wire::Message::Unknown(msg_type) => { - log_trace!(self.logger, "Received unknown odd message of type {}, ignoring", msg_type); + wire::Message::Unknown(type_id) => { + log_trace!(self.logger, "Received unknown odd message of type {}, ignoring", type_id); }, wire::Message::Custom(custom) => { self.custom_message_handler.handle_custom_message(custom)?; diff --git a/lightning/src/ln/wire.rs b/lightning/src/ln/wire.rs index 7385480dc10..973ce1462ed 100644 --- a/lightning/src/ln/wire.rs +++ b/lightning/src/ln/wire.rs @@ -68,18 +68,13 @@ pub(crate) enum Message where T: core::fmt::Debug + Type { ReplyChannelRange(msgs::ReplyChannelRange), GossipTimestampFilter(msgs::GossipTimestampFilter), /// A message that could not be decoded because its type is unknown. - Unknown(MessageType), + Unknown(u16), Custom(T), } -/// A number identifying a message to determine how it is encoded on the wire. -#[derive(Clone, Copy, Debug)] -pub struct MessageType(u16); - impl Message where T: core::fmt::Debug + Type { - #[allow(dead_code)] // This method is only used in tests /// Returns the type that was used to decode the message payload. - pub fn type_id(&self) -> MessageType { + pub fn type_id(&self) -> u16 { match self { &Message::Init(ref msg) => msg.type_id(), &Message::Error(ref msg) => msg.type_id(), @@ -113,18 +108,10 @@ impl Message where T: core::fmt::Debug + Type { &Message::Custom(ref msg) => msg.type_id(), } } -} -impl MessageType { - /// Returns whether the message type is even, indicating both endpoints must support it. + /// Returns whether the message's type is even, indicating both endpoints must support it. pub fn is_even(&self) -> bool { - (self.0 & 1) == 0 - } -} - -impl ::core::fmt::Display for MessageType { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - write!(f, "{}", self.0) + (self.type_id() & 1) == 0 } } @@ -232,7 +219,7 @@ where if let Some(custom) = custom_reader.read(message_type, buffer)? { Ok(Message::Custom(custom)) } else { - Ok(Message::Unknown(MessageType(message_type))) + Ok(Message::Unknown(message_type)) } }, } @@ -245,7 +232,7 @@ where /// /// Returns an I/O error if the write could not be completed. pub fn write(message: &M, buffer: &mut W) -> Result<(), io::Error> { - message.type_id().0.write(buffer)?; + message.type_id().write(buffer)?; message.write(buffer) } @@ -264,12 +251,12 @@ pub(crate) use self::encode::Encode; /// Messages implementing this trait specify a type and must be [`Writeable`] to use with [`write()`]. pub trait Type { /// Returns the type identifying the message payload. - fn type_id(&self) -> MessageType; + fn type_id(&self) -> u16; } impl Type for T where T: Encode { - fn type_id(&self) -> MessageType { - MessageType(T::TYPE) + fn type_id(&self) -> u16 { + T::TYPE } } @@ -440,7 +427,7 @@ mod tests { let mut reader = io::Cursor::new(buffer); let message = read(&mut reader, &IgnoringCustomMessageHandler{}).unwrap(); match message { - Message::Unknown(MessageType(::core::u16::MAX)) => (), + Message::Unknown(::core::u16::MAX) => (), _ => panic!("Expected message type {}; found: {}", ::core::u16::MAX, message.type_id()), } } @@ -476,14 +463,14 @@ mod tests { #[test] fn is_even_message_type() { - let message = Message::<()>::Unknown(MessageType(42)); - assert!(message.type_id().is_even()); + let message = Message::<()>::Unknown(42); + assert!(message.is_even()); } #[test] fn is_odd_message_type() { - let message = Message::<()>::Unknown(MessageType(43)); - assert!(!message.type_id().is_even()); + let message = Message::<()>::Unknown(43); + assert!(!message.is_even()); } #[test] @@ -553,8 +540,8 @@ mod tests { const CUSTOM_MESSAGE_TYPE : u16 = 9000; impl Type for TestCustomMessage { - fn type_id(&self) -> MessageType { - MessageType(CUSTOM_MESSAGE_TYPE) + fn type_id(&self) -> u16 { + CUSTOM_MESSAGE_TYPE } } @@ -591,7 +578,7 @@ mod tests { let decoded_msg = read(&mut reader, &TestCustomMessageReader{}).unwrap(); match decoded_msg { Message::Custom(custom) => { - assert_eq!(custom.type_id().0, CUSTOM_MESSAGE_TYPE); + assert_eq!(custom.type_id(), CUSTOM_MESSAGE_TYPE); assert_eq!(custom, TestCustomMessage {}); }, _ => panic!("Expected custom message, found message type: {}", decoded_msg.type_id()),