X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Futil%2Fser.rs;h=92cc66b81e30af9599f35bcd8cec1bcb088d2713;hb=a610e275c63a914e60d02d85499c9291d2cf8084;hp=7f795fe46a23defb08494c03f1eef71396bfd670;hpb=1f1f82569a1774d2f6cb84e1de3c55dc733022c8;p=rust-lightning

diff --git a/src/util/ser.rs b/src/util/ser.rs
index 7f795fe4..92cc66b8 100644
--- a/src/util/ser.rs
+++ b/src/util/ser.rs
@@ -1,8 +1,10 @@
+//! A very simple serialization framework which is used to serialize/deserialize messages as well
+//! as ChannelsManagers and ChannelMonitors.
+
 use std::result::Result;
 use std::io::Read;
 use std::collections::HashMap;
 use std::hash::Hash;
-use std::mem;
 
 use secp256k1::{Secp256k1, Signature};
 use secp256k1::key::PublicKey;
@@ -10,28 +12,65 @@ use bitcoin::util::hash::Sha256dHash;
 use bitcoin::blockdata::script::Script;
 use std::marker::Sized;
 use ln::msgs::DecodeError;
+use util::byte_utils;
 
 use util::byte_utils::{be64_to_array, be32_to_array, be16_to_array, slice_to_be16, slice_to_be32, slice_to_be64};
 
 const MAX_BUF_SIZE: usize = 64 * 1024;
 
-/// A trait that is similar to std::io::Write.
-/// An impl is provided for any type that also impls std::io::Write.
+/// A trait that is similar to std::io::Write but has one extra function which can be used to size
+/// buffers being written into.
+/// An impl is provided for any type that also impls std::io::Write which simply ignores size
+/// hints.
 pub trait Writer {
 	/// Writes the given buf out. See std::io::Write::write_all for more
 	fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error>;
+	/// Hints that data of the given size is about the be written. This may not always be called
+	/// prior to data being written and may be safely ignored.
+	fn size_hint(&mut self, size: usize);
 }
 
 impl<W: ::std::io::Write> Writer for W {
+	#[inline]
 	fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
 		<Self as ::std::io::Write>::write_all(self, buf)
 	}
+	#[inline]
+	fn size_hint(&mut self, _size: usize) { }
+}
+
+struct VecWriter(Vec<u8>);
+impl Writer for VecWriter {
+	fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
+		self.0.extend_from_slice(buf);
+		Ok(())
+	}
+	fn size_hint(&mut self, size: usize) {
+		self.0.reserve_exact(size);
+	}
 }
 
 /// A trait that various rust-lightning types implement allowing them to be written out to a Writer
-pub trait Writeable<W: Writer> {
+pub trait Writeable {
 	/// Writes self out to the given Writer
-	fn write(&self, writer: &mut W) -> Result<(), DecodeError>;
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error>;
+
+	/// Writes self out to a Vec<u8>
+	fn encode(&self) -> Vec<u8> {
+		let mut msg = VecWriter(Vec::new());
+		self.write(&mut msg).unwrap();
+		msg.0
+	}
+
+	/// Writes self out to a Vec<u8>
+	fn encode_with_len(&self) -> Vec<u8> {
+		let mut msg = VecWriter(Vec::new());
+		0u16.write(&mut msg).unwrap();
+		self.write(&mut msg).unwrap();
+		let len = msg.0.len();
+		msg.0[..2].copy_from_slice(&byte_utils::be16_to_array(len as u16 - 2));
+		msg.0
+	}
 }
 
 /// A trait that various rust-lightning types implement allowing them to be read in from a Read
@@ -45,10 +84,10 @@ pub trait Readable<R>
 
 macro_rules! impl_writeable_primitive {
 	($val_type:ty, $meth_write:ident, $len: expr, $meth_read:ident) => {
-		impl<W: Writer> Writeable<W> for $val_type {
+		impl Writeable for $val_type {
 			#[inline]
-			fn write(&self, writer: &mut W) -> Result<(), DecodeError> {
-				Ok(writer.write_all(&$meth_write(*self))?)
+			fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+				writer.write_all(&$meth_write(*self))
 			}
 		}
 		impl<R: Read> Readable<R> for $val_type {
@@ -66,10 +105,10 @@ impl_writeable_primitive!(u64, be64_to_array, 8, slice_to_be64);
 impl_writeable_primitive!(u32, be32_to_array, 4, slice_to_be32);
 impl_writeable_primitive!(u16, be16_to_array, 2, slice_to_be16);
 
-impl<W: Writer> Writeable<W> for u8 {
+impl Writeable for u8 {
 	#[inline]
-	fn write(&self, writer: &mut W) -> Result<(), DecodeError> {
-		Ok(writer.write_all(&[*self])?)
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+		writer.write_all(&[*self])
 	}
 }
 impl<R: Read> Readable<R> for u8 {
@@ -81,10 +120,10 @@ impl<R: Read> Readable<R> for u8 {
 	}
 }
 
-impl<W: Writer> Writeable<W> for bool {
+impl Writeable for bool {
 	#[inline]
-	fn write(&self, writer: &mut W) -> Result<(), DecodeError> {
-		Ok(writer.write_all(&[if *self {1} else {0}])?)
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+		writer.write_all(&[if *self {1} else {0}])
 	}
 }
 impl<R: Read> Readable<R> for bool {
@@ -102,12 +141,11 @@ impl<R: Read> Readable<R> for bool {
 // u8 arrays
 macro_rules! impl_array {
 	( $size:expr ) => (
-		impl<W: Writer> Writeable<W> for [u8; $size]
+		impl Writeable for [u8; $size]
 		{
 			#[inline]
-			fn write(&self, w: &mut W) -> Result<(), DecodeError> {
-				w.write_all(self)?;
-				Ok(())
+			fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+				w.write_all(self)
 			}
 		}
 
@@ -130,13 +168,12 @@ impl_array!(64); // for Signature
 impl_array!(1300); // for OnionPacket.hop_data
 
 // HashMap
-impl<W, K, V> Writeable<W> for HashMap<K, V>
-	where W: Writer,
-	      K: Writeable<W> + Eq + Hash,
-	      V: Writeable<W>
+impl<K, V> Writeable for HashMap<K, V>
+	where K: Writeable + Eq + Hash,
+	      V: Writeable
 {
 	#[inline]
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 	(self.len() as u16).write(w)?;
 		for (key, value) in self.iter() {
 			key.write(w)?;
@@ -163,17 +200,28 @@ impl<R, K, V> Readable<R> for HashMap<K, V>
 }
 
 // Vectors
-impl<W: Writer, T: Writeable<W>> Writeable<W> for Vec<T> {
+impl Writeable for Vec<u8> {
 	#[inline]
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
-		let byte_size = (self.len() as usize)
-		                .checked_mul(mem::size_of::<T>())
-		                .ok_or(DecodeError::BadLengthDescriptor)?;
-		if byte_size > MAX_BUF_SIZE {
-			return Err(DecodeError::BadLengthDescriptor);
-		}
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+		(self.len() as u16).write(w)?;
+		w.write_all(&self)
+	}
+}
+
+impl<R: Read> Readable<R> for Vec<u8> {
+	#[inline]
+	fn read(r: &mut R) -> Result<Self, DecodeError> {
+		let len: u16 = Readable::read(r)?;
+		let mut ret = Vec::with_capacity(len as usize);
+		ret.resize(len as usize, 0);
+		r.read_exact(&mut ret)?;
+		Ok(ret)
+	}
+}
+impl Writeable for Vec<Signature> {
+	#[inline]
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		(self.len() as u16).write(w)?;
-		// performance with Vec<u8>
 		for e in self.iter() {
 			e.write(w)?;
 		}
@@ -181,25 +229,26 @@ impl<W: Writer, T: Writeable<W>> Writeable<W> for Vec<T> {
 	}
 }
 
-impl<R: Read, T: Readable<R>> Readable<R> for Vec<T> {
+impl<R: Read> Readable<R> for Vec<Signature> {
 	#[inline]
 	fn read(r: &mut R) -> Result<Self, DecodeError> {
 		let len: u16 = Readable::read(r)?;
 		let byte_size = (len as usize)
-		                .checked_mul(mem::size_of::<T>())
+		                .checked_mul(33)
 		                .ok_or(DecodeError::BadLengthDescriptor)?;
 		if byte_size > MAX_BUF_SIZE {
 			return Err(DecodeError::BadLengthDescriptor);
 		}
 		let mut ret = Vec::with_capacity(len as usize);
-		for _ in 0..len { ret.push(T::read(r)?); }
+		for _ in 0..len { ret.push(Signature::read(r)?); }
 		Ok(ret)
 	}
 }
 
-impl<W: Writer> Writeable<W> for Script {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
-		self.to_bytes().to_vec().write(w)
+impl Writeable for Script {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+		(self.len() as u16).write(w)?;
+		w.write_all(self.as_bytes())
 	}
 }
 
@@ -212,8 +261,8 @@ impl<R: Read> Readable<R> for Script {
 	}
 }
 
-impl<W: Writer> Writeable<W> for Option<Script> {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+impl Writeable for Option<Script> {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		if let &Some(ref script) = self {
 			script.write(w)?;
 		}
@@ -235,8 +284,8 @@ impl<R: Read> Readable<R> for Option<Script> {
 	}
 }
 
-impl<W: Writer> Writeable<W> for PublicKey {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+impl Writeable for PublicKey {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		self.serialize().write(w)
 	}
 }
@@ -246,13 +295,13 @@ impl<R: Read> Readable<R> for PublicKey {
 		let buf: [u8; 33] = Readable::read(r)?;
 		match PublicKey::from_slice(&Secp256k1::without_caps(), &buf) {
 			Ok(key) => Ok(key),
-			Err(_) => return Err(DecodeError::BadPublicKey),
+			Err(_) => return Err(DecodeError::InvalidValue),
 		}
 	}
 }
 
-impl<W: Writer> Writeable<W> for Sha256dHash {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+impl Writeable for Sha256dHash {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		self.as_bytes().write(w)
 	}
 }
@@ -264,8 +313,8 @@ impl<R: Read> Readable<R> for Sha256dHash {
 	}
 }
 
-impl<W: Writer> Writeable<W> for Signature {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+impl Writeable for Signature {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		self.serialize_compact(&Secp256k1::without_caps()).write(w)
 	}
 }
@@ -275,7 +324,7 @@ impl<R: Read> Readable<R> for Signature {
 		let buf: [u8; 64] = Readable::read(r)?;
 		match Signature::from_compact(&Secp256k1::without_caps(), &buf) {
 			Ok(sig) => Ok(sig),
-			Err(_) => return Err(DecodeError::BadSignature),
+			Err(_) => return Err(DecodeError::InvalidValue),
 		}
 	}
 }