Move message type parity logic to the wire module

Create a MessageType abstraction and use it throughout the wire module's
external interfaces. Include an is_even method for clients to determine
how to handle unknown messages.

Author: jkczyz

lightning/src/ln/peer_handler.rs

@@ -749,12 +749,11 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
 											},
 
 											// Unknown messages:
-											wire::Message::Unknown(msg_type) => {
+											wire::Message::Unknown(msg_type) if msg_type.is_even() => {
 												// Fail the channel if message is an even, unknown type as per BOLT #1.
-												if (msg_type & 1) == 0 {
-													return Err(PeerHandleError{ no_connection_possible: true });
-												}
+												return Err(PeerHandleError{ no_connection_possible: true });
 											},
+											wire::Message::Unknown(_) => {},
 										}
 									}
 								}

lightning/src/ln/wire.rs

@@ -47,12 +47,18 @@ pub enum Message {
 	NodeAnnouncement(msgs::NodeAnnouncement),
 	ChannelUpdate(msgs::ChannelUpdate),
 	/// A message that could not be decoded because its type is unknown.
-	Unknown(u16),
+	Unknown(MessageType),
+}
+
+/// A number identifying a message to determine how it is encoded on the wire.
+#[derive(Clone, Copy)]
+pub struct MessageType {
+	number: u16,
 }
 
 impl Message {
 	/// Returns the type that was used to decode the message payload.
-	pub fn r#type(&self) -> u16 {
+	pub fn r#type(&self) -> MessageType {
 		match self {
 			Message::Init(msg) => msg.r#type(),
 			Message::Error(msg) => msg.r#type(),
@@ -77,11 +83,24 @@ impl Message {
 			Message::ChannelAnnouncement(msg) => msg.r#type(),
 			Message::NodeAnnouncement(msg) => msg.r#type(),
 			Message::ChannelUpdate(msg) => msg.r#type(),
-			Message::Unknown(r#type) => *r#type,
+			Message::Unknown(message_type) => *message_type,
 		}
 	}
 }
 
+impl MessageType {
+	/// Returns whether the message type is even, indicating both endpoints must support it.
+	pub fn is_even(&self) -> bool {
+		(self.number & 1) == 0
+	}
+}
+
+impl ::std::fmt::Display for MessageType {
+	fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+		write!(f, "{}", self.number)
+	}
+}
+
 /// Reads a message from the data buffer consisting of a 2-byte big-endian type and a
 /// variable-length payload conforming to the type.
 ///
@@ -161,7 +180,7 @@ pub fn read<R: std::io::Read>(buffer: &mut R) -> Result<Message, msgs::DecodeErr
 			Ok(Message::ChannelUpdate(Readable::read(buffer)?))
 		},
 		_ => {
-			Ok(Message::Unknown(message_type))
+			Ok(Message::Unknown(MessageType { number: message_type }))
 		},
 	}
 }
@@ -189,8 +208,8 @@ pub trait Encode: Writeable {
 
 	/// Returns the type identifying the message payload. Convenience method for accessing
 	/// [`TYPE`](TYPE).
-	fn r#type(&self) -> u16 {
-		Self::TYPE
+	fn r#type(&self) -> MessageType {
+		MessageType { number: Self::TYPE }
 	}
 
 	/// Writes the type and message payload to the given data buffer.
@@ -345,7 +364,7 @@ mod tests {
 		let mut reader = ::std::io::Cursor::new(buffer);
 		let message = read(&mut reader)?;
 		match message {
-			Message::Unknown(std::u16::MAX) => Ok(()),
+			Message::Unknown(MessageType { number: std::u16::MAX }) => Ok(()),
 			_ => panic!("Expected message type {}; found: {}", std::u16::MAX, message.r#type()),
 		}
 	}
@@ -377,4 +396,16 @@ mod tests {
 			_ => panic!("Expected pong message; found message type: {}", decoded_message.r#type()),
 		}
 	}
+
+	#[test]
+	fn is_even_message_type() {
+		let message = Message::Unknown(MessageType { number: 42 });
+		assert!(message.r#type().is_even());
+	}
+
+	#[test]
+	fn is_odd_message_type() {
+		let message = Message::Unknown(MessageType { number: 43 });
+		assert!(!message.r#type().is_even());
+	}
 }