Split Event, move MessageSendEvent push() inside channel_state lock

[rust-lightning] / src / util / ser.rs

diff --git a/src/util/ser.rs b/src/util/ser.rs
index 18aa7eee9da8ced1b7e23cf48742fa3cd23736d2..92cc66b81e30af9599f35bcd8cec1bcb088d2713 100644 (file)
--- a/src/util/ser.rs
+++ b/src/util/ser.rs
@@ -1,3 +1,6 @@
+//! 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;
@@ -9,6 +12,7 @@ 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};
 
@@ -35,10 +39,38 @@ impl<W: ::std::io::Write> Writer for W {
        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<(), ::std::io::Error>;
+       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
@@ -52,9 +84,9 @@ 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<(), ::std::io::Error> {
+                       fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
                                writer.write_all(&$meth_write(*self))
                        }
                }
@@ -73,9 +105,9 @@ 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<(), ::std::io::Error> {
+       fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
                writer.write_all(&[*self])
        }
 }
@@ -88,9 +120,9 @@ 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<(), ::std::io::Error> {
+       fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
                writer.write_all(&[if *self {1} else {0}])
        }
 }
@@ -109,10 +141,10 @@ 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<(), ::std::io::Error> {
+                       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
                                w.write_all(self)
                        }
                }
@@ -136,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<(), ::std::io::Error> {
+       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)?;
@@ -169,9 +200,9 @@ impl<R, K, V> Readable<R> for HashMap<K, V>
 }
 
 // Vectors
-impl<W: Writer> Writeable<W> for Vec<u8> {
+impl Writeable for Vec<u8> {
        #[inline]
-       fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
                (self.len() as u16).write(w)?;
                w.write_all(&self)
        }
@@ -187,9 +218,9 @@ impl<R: Read> Readable<R> for Vec<u8> {
                Ok(ret)
        }
 }
-impl<W: Writer> Writeable<W> for Vec<Signature> {
+impl Writeable for Vec<Signature> {
        #[inline]
-       fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
                (self.len() as u16).write(w)?;
                for e in self.iter() {
                        e.write(w)?;
@@ -214,8 +245,8 @@ impl<R: Read> Readable<R> for Vec<Signature> {
        }
 }
 
-impl<W: Writer> Writeable<W> for Script {
-       fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+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())
        }
@@ -230,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<(), ::std::io::Error> {
+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)?;
                }
@@ -253,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<(), ::std::io::Error> {
+impl Writeable for PublicKey {
+       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
                self.serialize().write(w)
        }
 }
@@ -264,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<(), ::std::io::Error> {
+impl Writeable for Sha256dHash {
+       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
                self.as_bytes().write(w)
        }
 }
@@ -282,8 +313,8 @@ impl<R: Read> Readable<R> for Sha256dHash {
        }
 }
 
-impl<W: Writer> Writeable<W> for Signature {
-       fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for Signature {
+       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
                self.serialize_compact(&Secp256k1::without_caps()).write(w)
        }
 }
@@ -293,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),
                }
        }
 }