Revert to generic short string serialization

Author: wvanlint

lightning/src/ln/msgs.rs

@@ -40,7 +40,7 @@ use io_extras::read_to_end;
 
 use util::events::MessageSendEventsProvider;
 use util::logger;
-use util::ser::{Readable, Writeable, Writer, FixedLengthReader, HighZeroBytesDroppedVarInt, Hostname};
+use util::ser::{Readable, Writeable, Writer, FixedLengthReader, HighZeroBytesDroppedVarInt, ShortAsciiString};
 
 use ln::{PaymentPreimage, PaymentHash, PaymentSecret};
 
@@ -445,7 +445,7 @@ pub enum NetAddress {
 	/// A hostname/port on which the peer is listening.
 	Hostname {
 		/// The hostname on which the node is listening.
-		hostname: Hostname,
+		hostname: ShortAsciiString,
 		/// The port on which the node is listening.
 		port: u16,
 	},
@@ -1852,7 +1852,7 @@ mod tests {
 	use ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
 	use ln::msgs;
 	use ln::msgs::{FinalOnionHopData, OptionalField, OnionErrorPacket, OnionHopDataFormat};
-	use util::ser::{Writeable, Readable, Hostname};
+	use util::ser::{Writeable, Readable, ShortAsciiString};
 
 	use bitcoin::hashes::hex::FromHex;
 	use bitcoin::util::address::Address;
@@ -2033,7 +2033,7 @@ mod tests {
 		}
 		if hostname {
 			addresses.push(msgs::NetAddress::Hostname {
-				hostname: Hostname::try_from(String::from("host")).unwrap(),
+				hostname: ShortAsciiString::try_from(String::from("host")).unwrap(),
 				port: 9735,
 			});
 		}

lightning/src/util/ser.rs

@@ -915,103 +915,67 @@ impl Readable for String {
 	}
 }
 
-/// Represents a hostname with validation for serialization purposes.
-/// The hostname follows the preferred form summarized in e.g. RFC 3696.
-/// Its length is guaranteed to be representable by a single byte.
+/// Represents a printable ASCII string whose length can be represented by a single byte.
 /// This serialization is used by BOLT 7 hostnames.
 #[derive(Clone, Debug, PartialEq)]
-pub struct Hostname(String);
-impl Hostname {
-	/// Returns the length of the hostname.
+pub struct ShortAsciiString(String);
+impl ShortAsciiString {
+	/// Returns the length of the short ASCII string.
 	pub fn len(&self) -> u8 {
 		(&self.0).len() as u8
 	}
 }
-impl Deref for Hostname {
+impl Deref for ShortAsciiString {
 	type Target = String;
 
 	fn deref(&self) -> &Self::Target {
 		&self.0
 	}
 }
-impl From<Hostname> for String {
-	fn from(short_s: Hostname) -> Self {
+impl From<ShortAsciiString> for String {
+	fn from(short_s: ShortAsciiString) -> Self {
 		short_s.0
 	}
 }
-/// An error returned when converting into a hostname.
-/// This conversion follows the preferred form summarized in e.g. RFC 3696.
-#[derive(Debug)]
-pub enum HostnameConversionError {
-	/// The hostname exceeded 255 bytes.
-	InvalidLength,
-	/// A label exceeded 63 bytes.
-	InvalidLabelLength,
-	/// A zero length root label was found without it being the last label.
-	InvalidRootLabel,
-	/// An invalid character was found. Valid characters include only ASCII
-	/// alphanumeric characters and hyphens. Hyphens are invalid at the
-	/// beginning or end of a label.
-	InvalidChar,
-}
-impl TryFrom<Vec<u8>> for Hostname {
-	type Error = HostnameConversionError;
+impl TryFrom<Vec<u8>> for ShortAsciiString {
+	type Error = ();
 
 	fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
 		if let Ok(s) = String::from_utf8(bytes) {
-			Hostname::try_from(s)
+			ShortAsciiString::try_from(s)
 		} else {
-			Err(HostnameConversionError::InvalidChar)
+			Err(())
 		}
 	}
 }
-impl TryFrom<String> for Hostname {
-	type Error = HostnameConversionError;
+impl TryFrom<String> for ShortAsciiString {
+	type Error = ();
 
 	fn try_from(s: String) -> Result<Self, Self::Error> {
-		if s.len() > 255 {
-			return Err(HostnameConversionError::InvalidLength);
+		if s.len() <= 255 && s.chars().all(|c|
+			c.is_ascii() && !c.is_ascii_control()
+		) {
+			Ok(ShortAsciiString(s))
+		} else {
+			Err(())
 		}
-		let mut labels = s.split('.').enumerate().peekable();
-		while let Some((label_idx, label)) = labels.next() {
-			// Trailing zero length root label for fully-qualified name.
-			let last_label = labels.peek().is_none();
-			if label.len() == 0 {
-				if !last_label || label_idx == 0 {
-					return Err(HostnameConversionError::InvalidRootLabel);
-				}
-			}
-			// Maximum label length from specification.
-			if label.len() > 63 {
-				return Err(HostnameConversionError::InvalidLabelLength);
-			}
-			for (byte_idx, byte) in label.as_bytes().iter().enumerate() {
-				if !byte.is_ascii_alphanumeric() && *byte != b'-' {
-					return Err(HostnameConversionError::InvalidChar);
-				}
-				if *byte == b'-' && (byte_idx == 0 || byte_idx == label.len() - 1) {
-					return Err(HostnameConversionError::InvalidChar);
-				}
-			}
-		};
-		Ok(Hostname(s))
 	}
 }
-impl Writeable for Hostname {
+impl Writeable for ShortAsciiString {
 	#[inline]
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 		self.len().write(w)?;
 		w.write_all(self.as_bytes())
 	}
 }
-impl Readable for Hostname {
+impl Readable for ShortAsciiString {
 	#[inline]
-	fn read<R: Read>(r: &mut R) -> Result<Hostname, DecodeError> {
+	fn read<R: Read>(r: &mut R) -> Result<ShortAsciiString, DecodeError> {
 		let len: u8 = Readable::read(r)?;
 		let mut vec = Vec::with_capacity(len.into());
 		vec.resize(len.into(), 0);
 		r.read_exact(&mut vec)?;
-		Hostname::try_from(vec).map_err(|_| DecodeError::InvalidValue)
+		ShortAsciiString::try_from(vec).map_err(|_| DecodeError::InvalidValue)
 	}
 }
 
@@ -1034,30 +998,23 @@ impl Readable for Duration {
 #[cfg(test)]
 mod tests {
 	use core::convert::TryFrom;
-	use util::ser::{Readable, Hostname, Writeable};
+	use util::ser::{Readable, ShortAsciiString, Writeable};
 
 	#[test]
-	fn hostname_conversion() {
-		assert_eq!(Hostname::try_from(String::from("test")).unwrap().as_str(), "test");
-		assert_eq!(Hostname::try_from(String::from("test-1")).unwrap().as_str(), "test-1");
-		assert_eq!(Hostname::try_from(String::from("1-test")).unwrap().as_str(), "1-test");
-		assert_eq!(Hostname::try_from(String::from("test.com")).unwrap().as_str(), "test.com");
-		assert_eq!(Hostname::try_from(String::from("test.com.")).unwrap().as_str(), "test.com.");
-		assert_eq!(Hostname::try_from(String::from("a.test.com")).unwrap().as_str(), "a.test.com");
-
-		assert!(Hostname::try_from(String::from("⚡")).is_err());
-		assert!(Hostname::try_from(String::from("-end")).is_err());
-		assert!(Hostname::try_from(String::from("start-")).is_err());
+	fn short_ascii_string_conversion() {
+		assert_eq!(ShortAsciiString::try_from(String::from("test")).unwrap().as_str(), "test");
+
+		assert!(ShortAsciiString::try_from(String::from("⚡")).is_err());
 		let mut large_vec = Vec::with_capacity(256);
 		large_vec.resize(256, b'A');
-		assert!(Hostname::try_from(String::from_utf8(large_vec).unwrap()).is_err());
+		assert!(ShortAsciiString::try_from(String::from_utf8(large_vec).unwrap()).is_err());
 	}
 
 	#[test]
-	fn hostname_serialization() {
-		let short_s = Hostname::try_from(String::from("test")).unwrap();
+	fn short_ascii_string_serialization() {
+		let short_s = ShortAsciiString::try_from(String::from("test")).unwrap();
 		let mut buf: Vec<u8> = Vec::new();
 		short_s.write(&mut buf).unwrap();
-		assert_eq!(Hostname::read(&mut buf.as_slice()).unwrap().as_str(), "test");
+		assert_eq!(ShortAsciiString::read(&mut buf.as_slice()).unwrap().as_str(), "test");
 	}
 }