Implement serialize/deserialize for Router.

Extend route_test to check if serialize/deserialize of
NetworkMap works.

Add PartialEq traits on some Router's structs.

Author: Antoine Riard

src/ln/msgs.rs

@@ -26,7 +26,7 @@ use std::{cmp, fmt};
 use std::io::Read;
 use std::result::Result;
 
-use util::{byte_utils, events};
+use util::events;
 use util::ser::{Readable, Writeable, Writer};
 
 /// An error in decoding a message or struct.
@@ -334,7 +334,7 @@ pub struct AnnouncementSignatures {
 }
 
 /// An address which can be used to connect to a remote peer
-#[derive(Clone)]
+#[derive(PartialEq, Clone)]
 pub enum NetAddress {
 	/// An IPv4 address/port on which the peer is listenting.
 	IPv4 {
@@ -382,7 +382,81 @@ impl NetAddress {
 	}
 }
 
-#[derive(Clone)]
+impl Writeable for NetAddress {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+		match self {
+			&NetAddress::IPv4 { ref addr, ref port } => {
+				0u8.write(writer)?;
+				addr.write(writer)?;
+				port.write(writer)?;
+			},
+			&NetAddress::IPv6 { ref addr, ref port } => {
+				1u8.write(writer)?;
+				addr.write(writer)?;
+				port.write(writer)?;
+			},
+			&NetAddress::OnionV2 { ref addr, ref port } => {
+				2u8.write(writer)?;
+				addr.write(writer)?;
+				port.write(writer)?;
+			},
+			&NetAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
+				3u8.write(writer)?;
+				ed25519_pubkey.write(writer)?;
+				checksum.write(writer)?;
+				version.write(writer)?;
+				port.write(writer)?;
+			}
+		}
+		Ok(())
+	}
+}
+
+impl<R: ::std::io::Read>  Readable<R> for NetAddress {
+	fn read(reader: &mut R) -> Result<NetAddress, DecodeError> {
+		match <u8 as Readable<R>>::read(reader)? {
+			0 => {
+				let addr = Readable::read(reader)?;
+				let port = Readable::read(reader)?;
+				Ok(NetAddress::IPv4 {
+					addr,
+					port,
+				})
+			},
+			1 => {
+				let addr = Readable::read(reader)?;
+				let port = Readable::read(reader)?;
+				Ok(NetAddress::IPv6 {
+					addr,
+					port,
+				})
+			},
+			2 => {
+				let addr = Readable::read(reader)?;
+				let port = Readable::read(reader)?;
+				Ok(NetAddress::OnionV2 {
+					addr,
+					port,
+				})
+			},
+			3 => {
+				let ed25519_pubkey = Readable::read(reader)?;
+				let checksum = Readable::read(reader)?;
+				let version = Readable::read(reader)?;
+				let port = Readable::read(reader)?;
+				Ok(NetAddress::OnionV3 {
+					ed25519_pubkey,
+					checksum,
+					version,
+					port,
+				})
+			}
+			_ => return Err(DecodeError::InvalidValue),
+		}
+	}
+}
+
+#[derive(PartialEq, Clone)]
 // Only exposed as broadcast of node_announcement should be filtered by node_id
 /// The unsigned part of a node_announcement
 pub struct UnsignedNodeAnnouncement {
@@ -399,7 +473,7 @@ pub struct UnsignedNodeAnnouncement {
 	pub(crate) excess_address_data: Vec<u8>,
 	pub(crate) excess_data: Vec<u8>,
 }
-#[derive(Clone)]
+#[derive(PartialEq, Clone)]
 /// A node_announcement message to be sent or received from a peer
 pub struct NodeAnnouncement {
 	pub(crate) signature: Signature,
@@ -1148,39 +1222,16 @@ impl Writeable for UnsignedNodeAnnouncement {
 		w.write_all(&self.rgb)?;
 		self.alias.write(w)?;
 
-		let mut addr_slice = Vec::with_capacity(self.addresses.len() * 18);
 		let mut addrs_to_encode = self.addresses.clone();
 		addrs_to_encode.sort_unstable_by(|a, b| { a.get_id().cmp(&b.get_id()) });
 		addrs_to_encode.dedup_by(|a, b| { a.get_id() == b.get_id() });
-		for addr in addrs_to_encode.iter() {
-			match addr {
-				&NetAddress::IPv4{addr, port} => {
-					addr_slice.push(1);
-					addr_slice.extend_from_slice(&addr);
-					addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
-				},
-				&NetAddress::IPv6{addr, port} => {
-					addr_slice.push(2);
-					addr_slice.extend_from_slice(&addr);
-					addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
-				},
-				&NetAddress::OnionV2{addr, port} => {
-					addr_slice.push(3);
-					addr_slice.extend_from_slice(&addr);
-					addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
-				},
-				&NetAddress::OnionV3{ed25519_pubkey, checksum, version, port} => {
-					addr_slice.push(4);
-					addr_slice.extend_from_slice(&ed25519_pubkey);
-					addr_slice.extend_from_slice(&byte_utils::be16_to_array(checksum));
-					addr_slice.push(version);
-					addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
-				},
-			}
+		(addrs_to_encode.len() as u64).write(w)?;
+		for addr in addrs_to_encode {
+			addr.write(w)?;
 		}
-		((addr_slice.len() + self.excess_address_data.len()) as u16).write(w)?;
-		w.write_all(&addr_slice[..])?;
+		(self.excess_address_data.len() as u64).write(w)?;
 		w.write_all(&self.excess_address_data[..])?;
+		(self.excess_data.len() as u64).write(w)?;
 		w.write_all(&self.excess_data[..])?;
 		Ok(())
 	}
@@ -1198,112 +1249,33 @@ impl<R: Read> Readable<R> for UnsignedNodeAnnouncement {
 		r.read_exact(&mut rgb)?;
 		let alias: [u8; 32] = Readable::read(r)?;
 
-		let addrlen: u16 = Readable::read(r)?;
-		let mut addr_readpos = 0;
-		let mut addresses = Vec::with_capacity(4);
-		let mut f: u8 = 0;
-		let mut excess = 0;
-		loop {
-			if addrlen <= addr_readpos { break; }
-			f = Readable::read(r)?;
-			match f {
-				1 => {
-					if addresses.len() > 0 {
-						return Err(DecodeError::ExtraAddressesPerType);
-					}
-					if addrlen < addr_readpos + 1 + 6 {
-						return Err(DecodeError::BadLengthDescriptor);
-					}
-					addresses.push(NetAddress::IPv4 {
-						addr: {
-							let mut addr = [0; 4];
-							r.read_exact(&mut addr)?;
-							addr
-						},
-						port: Readable::read(r)?,
-					});
-					addr_readpos += 1 + 6
-				},
-				2 => {
-					if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) {
-						return Err(DecodeError::ExtraAddressesPerType);
-					}
-					if addrlen < addr_readpos + 1 + 18 {
-						return Err(DecodeError::BadLengthDescriptor);
-					}
-					addresses.push(NetAddress::IPv6 {
-						addr: {
-							let mut addr = [0; 16];
-							r.read_exact(&mut addr)?;
-							addr
-						},
-						port: Readable::read(r)?,
-					});
-					addr_readpos += 1 + 18
-				},
-				3 => {
-					if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) {
-						return Err(DecodeError::ExtraAddressesPerType);
-					}
-					if addrlen < addr_readpos + 1 + 12 {
-						return Err(DecodeError::BadLengthDescriptor);
-					}
-					addresses.push(NetAddress::OnionV2 {
-						addr: {
-							let mut addr = [0; 10];
-							r.read_exact(&mut addr)?;
-							addr
-						},
-						port: Readable::read(r)?,
-					});
-					addr_readpos += 1 + 12
-				},
-				4 => {
-					if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) {
-						return Err(DecodeError::ExtraAddressesPerType);
-					}
-					if addrlen < addr_readpos + 1 + 37 {
-						return Err(DecodeError::BadLengthDescriptor);
-					}
-					addresses.push(NetAddress::OnionV3 {
-						ed25519_pubkey: Readable::read(r)?,
-						checksum: Readable::read(r)?,
-						version: Readable::read(r)?,
-						port: Readable::read(r)?,
-					});
-					addr_readpos += 1 + 37
-				},
-				_ => { excess = 1; break; }
-			}
+		let addresses_count: u64 = Readable::read(r)?;
+		let mut addresses = Vec::with_capacity(addresses_count as usize);
+		for _ in 0..addresses_count {
+			addresses.push(Readable::read(r)?);
 		}
 
-		let mut excess_data = vec![];
-		let excess_address_data = if addr_readpos < addrlen {
-			let mut excess_address_data = vec![0; (addrlen - addr_readpos) as usize];
-			r.read_exact(&mut excess_address_data[excess..])?;
-			if excess == 1 {
-				excess_address_data[0] = f;
-			}
-			excess_address_data
-		} else {
-			if excess == 1 {
-				excess_data.push(f);
-			}
-			Vec::new()
-		};
+		let excess_address_data_count: u64 = Readable::read(r)?;
+		let mut excess_address_data = Vec::with_capacity(excess_address_data_count as usize);
+		for _ in 0..excess_address_data_count {
+			excess_address_data.push(Readable::read(r)?);
+		}
+
+		let excess_data_count: u64 = Readable::read(r)?;
+		let mut excess_data = Vec::with_capacity(excess_data_count as usize);
+		for _ in 0..excess_data_count {
+			excess_data.push(Readable::read(r)?);
+		}
 
 		Ok(UnsignedNodeAnnouncement {
-			features: features,
-			timestamp: timestamp,
-			node_id: node_id,
-			rgb: rgb,
-			alias: alias,
-			addresses: addresses,
-			excess_address_data: excess_address_data,
-			excess_data: {
-				r.read_to_end(&mut excess_data)?;
-				excess_data
-			},
+			features,
+			timestamp,
+			node_id,
+			rgb,
+			alias,
+			addresses,
+			excess_address_data,
+			excess_data
 		})
 	}
 }