_ Git - rust-lightning/blob - src/util/ser.rs

   1 use std::result::Result;
   2 use std::io::Read;
   3 use std::collections::HashMap;
   4 use std::hash::Hash;
   5 use std::mem;
   6
   7 use secp256k1::{Secp256k1, Signature};
   8 use secp256k1::key::PublicKey;
   9 use bitcoin::util::hash::Sha256dHash;
  10 use bitcoin::blockdata::script::Script;
  11 use std::marker::Sized;
  12 use ln::msgs::DecodeError;
  13
  14 use util::byte_utils::{be64_to_array, be32_to_array, be16_to_array, slice_to_be16, slice_to_be32, slice_to_be64};
  15
  16 const MAX_BUF_SIZE: usize = 64 * 1024;
  17
  18 /// A trait that is similar to std::io::Write.
  19 /// An impl is provided for any type that also impls std::io::Write.
  20 pub trait Writer {
  21         /// Writes the given buf out. See std::io::Write::write_all for more
  22         fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error>;
  23 }
  24
  25 impl<W: ::std::io::Write> Writer for W {
  26         fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
  27                 <Self as ::std::io::Write>::write_all(self, buf)
  28         }
  29 }
  30
  31 /// A trait that various rust-lightning types implement allowing them to be written out to a Writer
  32 pub trait Writeable<W: Writer> {
  33         /// Writes self out to the given Writer
  34         fn write(&self, writer: &mut W) -> Result<(), DecodeError>;
  35 }
  36
  37 /// A trait that various rust-lightning types implement allowing them to be read in from a Read
  38 pub trait Readable<R>
  39         where Self: Sized,
  40               R: Read
  41 {
  42         /// Reads a Self in from the given Read
  43         fn read(reader: &mut R) -> Result<Self, DecodeError>;
  44 }
  45
  46 macro_rules! impl_writeable_primitive {
  47         ($val_type:ty, $meth_write:ident, $len: expr, $meth_read:ident) => {
  48                 impl<W: Writer> Writeable<W> for $val_type {
  49                         #[inline]
  50                         fn write(&self, writer: &mut W) -> Result<(), DecodeError> {
  51                                 Ok(writer.write_all(&$meth_write(*self))?)
  52                         }
  53                 }
  54                 impl<R: Read> Readable<R> for $val_type {
  55                         #[inline]
  56                         fn read(reader: &mut R) -> Result<$val_type, DecodeError> {
  57                                 let mut buf = [0; $len];
  58                                 reader.read_exact(&mut buf)?;
  59                                 Ok($meth_read(&buf))
  60                         }
  61                 }
  62         }
  63 }
  64
  65 impl_writeable_primitive!(u64, be64_to_array, 8, slice_to_be64);
  66 impl_writeable_primitive!(u32, be32_to_array, 4, slice_to_be32);
  67 impl_writeable_primitive!(u16, be16_to_array, 2, slice_to_be16);
  68
  69 impl<W: Writer> Writeable<W> for u8 {
  70         #[inline]
  71         fn write(&self, writer: &mut W) -> Result<(), DecodeError> {
  72                 Ok(writer.write_all(&[*self])?)
  73         }
  74 }
  75 impl<R: Read> Readable<R> for u8 {
  76         #[inline]
  77         fn read(reader: &mut R) -> Result<u8, DecodeError> {
  78                 let mut buf = [0; 1];
  79                 reader.read_exact(&mut buf)?;
  80                 Ok(buf[0])
  81         }
  82 }
  83
  84 impl<W: Writer> Writeable<W> for bool {
  85         #[inline]
  86         fn write(&self, writer: &mut W) -> Result<(), DecodeError> {
  87                 Ok(writer.write_all(&[if *self {1} else {0}])?)
  88         }
  89 }
  90 impl<R: Read> Readable<R> for bool {
  91         #[inline]
  92         fn read(reader: &mut R) -> Result<bool, DecodeError> {
  93                 let mut buf = [0; 1];
  94                 reader.read_exact(&mut buf)?;
  95                 if buf[0] != 0 && buf[0] != 1 {
  96                         return Err(DecodeError::InvalidValue);
  97                 }
  98                 Ok(buf[0] == 1)
  99         }
 100 }
 101
 102 // u8 arrays
 103 macro_rules! impl_array {
 104         ( $size:expr ) => (
 105                 impl<W: Writer> Writeable<W> for [u8; $size]
 106                 {
 107                         #[inline]
 108                         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
 109                                 w.write_all(self)?;
 110                                 Ok(())
 111                         }
 112                 }
 113
 114                 impl<R: Read> Readable<R> for [u8; $size]
 115                 {
 116                         #[inline]
 117                         fn read(r: &mut R) -> Result<Self, DecodeError> {
 118                                 let mut buf = [0u8; $size];
 119                                 r.read_exact(&mut buf)?;
 120                                 Ok(buf)
 121                         }
 122                 }
 123         );
 124 }
 125
 126 //TODO: performance issue with [u8; size] with impl_array!()
 127 impl_array!(32); // for channel id & hmac
 128 impl_array!(33); // for PublicKey
 129 impl_array!(64); // for Signature
 130 impl_array!(1300); // for OnionPacket.hop_data
 131
 132 // HashMap
 133 impl<W, K, V> Writeable<W> for HashMap<K, V>
 134         where W: Writer,
 135               K: Writeable<W> + Eq + Hash,
 136               V: Writeable<W>
 137 {
 138         #[inline]
 139         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
 140         (self.len() as u16).write(w)?;
 141                 for (key, value) in self.iter() {
 142                         key.write(w)?;
 143                         value.write(w)?;
 144                 }
 145                 Ok(())
 146         }
 147 }
 148
 149 impl<R, K, V> Readable<R> for HashMap<K, V>
 150         where R: Read,
 151               K: Readable<R> + Eq + Hash,
 152               V: Readable<R>
 153 {
 154         #[inline]
 155         fn read(r: &mut R) -> Result<Self, DecodeError> {
 156                 let len: u16 = Readable::read(r)?;
 157                 let mut ret = HashMap::with_capacity(len as usize);
 158                 for _ in 0..len {
 159                         ret.insert(K::read(r)?, V::read(r)?);
 160                 }
 161                 Ok(ret)
 162         }
 163 }
 164
 165 // Vectors
 166 impl<W: Writer, T: Writeable<W>> Writeable<W> for Vec<T> {
 167         #[inline]
 168         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
 169                 let byte_size = (self.len() as usize)
 170                                 .checked_mul(mem::size_of::<T>())
 171                                 .ok_or(DecodeError::BadLengthDescriptor)?;
 172                 if byte_size > MAX_BUF_SIZE {
 173                         return Err(DecodeError::BadLengthDescriptor);
 174                 }
 175                 (self.len() as u16).write(w)?;
 176                 // performance with Vec<u8>
 177                 for e in self.iter() {
 178                         e.write(w)?;
 179                 }
 180                 Ok(())
 181         }
 182 }
 183
 184 impl<R: Read, T: Readable<R>> Readable<R> for Vec<T> {
 185         #[inline]
 186         fn read(r: &mut R) -> Result<Self, DecodeError> {
 187                 let len: u16 = Readable::read(r)?;
 188                 let byte_size = (len as usize)
 189                                 .checked_mul(mem::size_of::<T>())
 190                                 .ok_or(DecodeError::BadLengthDescriptor)?;
 191                 if byte_size > MAX_BUF_SIZE {
 192                         return Err(DecodeError::BadLengthDescriptor);
 193                 }
 194                 let mut ret = Vec::with_capacity(len as usize);
 195                 for _ in 0..len { ret.push(T::read(r)?); }
 196                 Ok(ret)
 197         }
 198 }
 199
 200 impl<W: Writer> Writeable<W> for Script {
 201         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
 202                 self.to_bytes().to_vec().write(w)
 203         }
 204 }
 205
 206 impl<R: Read> Readable<R> for Script {
 207         fn read(r: &mut R) -> Result<Self, DecodeError> {
 208                 let len = <u16 as Readable<R>>::read(r)? as usize;
 209                 let mut buf = vec![0; len];
 210                 r.read_exact(&mut buf)?;
 211                 Ok(Script::from(buf))
 212         }
 213 }
 214
 215 impl<W: Writer> Writeable<W> for Option<Script> {
 216         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
 217                 if let &Some(ref script) = self {
 218                         script.write(w)?;
 219                 }
 220                 Ok(())
 221         }
 222 }
 223
 224 impl<R: Read> Readable<R> for Option<Script> {
 225         fn read(r: &mut R) -> Result<Self, DecodeError> {
 226                 match <u16 as Readable<R>>::read(r) {
 227                         Ok(len) => {
 228                                 let mut buf = vec![0; len as usize];
 229                                 r.read_exact(&mut buf)?;
 230                                 Ok(Some(Script::from(buf)))
 231                         },
 232                         Err(DecodeError::ShortRead) => Ok(None),
 233                         Err(e) => Err(e)
 234                 }
 235         }
 236 }
 237
 238 impl<W: Writer> Writeable<W> for PublicKey {
 239         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
 240                 self.serialize().write(w)
 241         }
 242 }
 243
 244 impl<R: Read> Readable<R> for PublicKey {
 245         fn read(r: &mut R) -> Result<Self, DecodeError> {
 246                 let buf: [u8; 33] = Readable::read(r)?;
 247                 match PublicKey::from_slice(&Secp256k1::without_caps(), &buf) {
 248                         Ok(key) => Ok(key),
 249                         Err(_) => return Err(DecodeError::BadPublicKey),
 250                 }
 251         }
 252 }
 253
 254 impl<W: Writer> Writeable<W> for Sha256dHash {
 255         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
 256                 self.as_bytes().write(w)
 257         }
 258 }
 259
 260 impl<R: Read> Readable<R> for Sha256dHash {
 261         fn read(r: &mut R) -> Result<Self, DecodeError> {
 262                 let buf: [u8; 32] = Readable::read(r)?;
 263                 Ok(From::from(&buf[..]))
 264         }
 265 }
 266
 267 impl<W: Writer> Writeable<W> for Signature {
 268         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
 269                 self.serialize_compact(&Secp256k1::without_caps()).write(w)
 270         }
 271 }
 272
 273 impl<R: Read> Readable<R> for Signature {
 274         fn read(r: &mut R) -> Result<Self, DecodeError> {
 275                 let buf: [u8; 64] = Readable::read(r)?;
 276                 match Signature::from_compact(&Secp256k1::without_caps(), &buf) {
 277                         Ok(sig) => Ok(sig),
 278                         Err(_) => return Err(DecodeError::BadSignature),
 279                 }
 280         }
 281 }