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