X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fser.rs;h=5b1a86a6a95f27a276f1dc221bd705f57fbf8ed4;hb=b76040718f954fa7baae42c7070e3ff6ac8add3c;hp=a45806eef54a1434eada0da1d3f1d179d48f9285;hpb=ee805e97ff0888bcfd9dabc0de1027ae6b75163e;p=rust-lightning

diff --git a/lightning/src/util/ser.rs b/lightning/src/util/ser.rs
index a45806ee..5b1a86a6 100644
--- a/lightning/src/util/ser.rs
+++ b/lightning/src/util/ser.rs
@@ -16,6 +16,8 @@ use io_extras::{copy, sink};
 use core::hash::Hash;
 use sync::Mutex;
 use core::cmp;
+use core::convert::TryFrom;
+use core::ops::Deref;
 
 use bitcoin::secp256k1::{PublicKey, SecretKey};
 use bitcoin::secp256k1::constants::{PUBLIC_KEY_SIZE, SECRET_KEY_SIZE, COMPACT_SIGNATURE_SIZE};
@@ -266,6 +268,12 @@ impl<T: Readable> Readable for OptionDeserWrapper<T> {
 		Ok(Self(Some(Readable::read(reader)?)))
 	}
 }
+/// When handling default_values, we want to map the default-value T directly
+/// to a OptionDeserWrapper<T> in a way that works for `field: T = t;` as
+/// well. Thus, we assume `Into<T> for T` does nothing and use that.
+impl<T: Readable> From<T> for OptionDeserWrapper<T> {
+	fn from(t: T) -> OptionDeserWrapper<T> { OptionDeserWrapper(Some(t)) }
+}
 
 /// Wrapper to write each element of a Vec with no length prefix
 pub(crate) struct VecWriteWrapper<'a, T: Writeable>(pub &'a Vec<T>);
@@ -935,6 +943,75 @@ impl Readable for String {
 	}
 }
 
+/// Represents a hostname for serialization purposes.
+/// Only the character set and length will be validated.
+/// The character set consists of ASCII alphanumeric characters, hyphens, and periods.
+/// Its length is guaranteed to be representable 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 fn len(&self) -> u8 {
+		(&self.0).len() as u8
+	}
+}
+impl Deref for Hostname {
+	type Target = String;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+impl From<Hostname> for String {
+	fn from(hostname: Hostname) -> Self {
+		hostname.0
+	}
+}
+impl TryFrom<Vec<u8>> for Hostname {
+	type Error = ();
+
+	fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
+		if let Ok(s) = String::from_utf8(bytes) {
+			Hostname::try_from(s)
+		} else {
+			Err(())
+		}
+	}
+}
+impl TryFrom<String> for Hostname {
+	type Error = ();
+
+	fn try_from(s: String) -> Result<Self, Self::Error> {
+		if s.len() <= 255 && s.chars().all(|c|
+			c.is_ascii_alphanumeric() ||
+			c == '.' ||
+			c == '-'
+		) {
+			Ok(Hostname(s))
+		} else {
+			Err(())
+		}
+	}
+}
+impl Writeable for Hostname {
+	#[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 {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Hostname, 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)
+	}
+}
+
 impl Writeable for Duration {
 	#[inline]
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
@@ -950,3 +1027,29 @@ impl Readable for Duration {
 		Ok(Duration::new(secs, nanos))
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use core::convert::TryFrom;
+	use util::ser::{Readable, Hostname, Writeable};
+
+	#[test]
+	fn hostname_conversion() {
+		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("$")).is_err());
+		assert!(Hostname::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());
+	}
+
+	#[test]
+	fn hostname_serialization() {
+		let hostname = Hostname::try_from(String::from("test")).unwrap();
+		let mut buf: Vec<u8> = Vec::new();
+		hostname.write(&mut buf).unwrap();
+		assert_eq!(Hostname::read(&mut buf.as_slice()).unwrap().as_str(), "test");
+	}
+}