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

diff --git a/lightning/src/util/ser.rs b/lightning/src/util/ser.rs
index 69fd1464..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};
@@ -134,6 +136,13 @@ impl<R: Read> Read for FixedLengthReader<R> {
 	}
 }
 
+impl<R: Read> LengthRead for FixedLengthReader<R> {
+	#[inline]
+	fn total_bytes(&self) -> u64 {
+		self.total_bytes
+	}
+}
+
 /// A Read which tracks whether any bytes have been read at all. This allows us to distinguish
 /// between "EOF reached before we started" and "EOF reached mid-read".
 pub(crate) struct ReadTrackingReader<R: Read> {
@@ -220,6 +229,21 @@ pub trait ReadableArgs<P>
 	fn read<R: Read>(reader: &mut R, params: P) -> Result<Self, DecodeError>;
 }
 
+/// A std::io::Read that also provides the total bytes available to read.
+pub(crate) trait LengthRead: Read {
+	/// The total number of bytes available to read.
+	fn total_bytes(&self) -> u64;
+}
+
+/// A trait that various higher-level rust-lightning types implement allowing them to be read in
+/// from a Read given some additional set of arguments which is required to deserialize, requiring
+/// the implementer to provide the total length of the read.
+pub(crate) trait LengthReadableArgs<P> where Self: Sized
+{
+	/// Reads a Self in from the given LengthRead
+	fn read<R: LengthRead>(reader: &mut R, params: P) -> Result<Self, DecodeError>;
+}
+
 /// A trait that various rust-lightning types implement allowing them to (maybe) be read in from a Read
 ///
 /// (C-not exported) as we only export serialization to/from byte arrays instead
@@ -244,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>);
@@ -301,7 +331,7 @@ impl Readable for U48 {
 /// encoded in several different ways, which we must check for at deserialization-time. Thus, if
 /// you're looking for an example of a variable-length integer to use for your own project, move
 /// along, this is a rather poor design.
-pub(crate) struct BigSize(pub u64);
+pub struct BigSize(pub u64);
 impl Writeable for BigSize {
 	#[inline]
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
@@ -913,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> {
@@ -928,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");
+	}
+}