//! A very simple serialization framework which is used to serialize/deserialize messages as well
//! as ChannelsManagers and ChannelMonitors.
+use prelude::*;
use std::io::{Read, Write};
use std::collections::HashMap;
-use std::hash::Hash;
+use core::hash::Hash;
use std::sync::Mutex;
-use std::cmp;
+use core::cmp;
use bitcoin::secp256k1::Signature;
use bitcoin::secp256k1::key::{PublicKey, SecretKey};
+use bitcoin::secp256k1::constants::{PUBLIC_KEY_SIZE, COMPACT_SIGNATURE_SIZE};
use bitcoin::blockdata::script::Script;
use bitcoin::blockdata::transaction::{OutPoint, Transaction, TxOut};
use bitcoin::consensus;
use bitcoin::consensus::Encodable;
use bitcoin::hashes::sha256d::Hash as Sha256dHash;
use bitcoin::hash_types::{Txid, BlockHash};
-use std::marker::Sized;
+use core::marker::Sized;
use ln::msgs::DecodeError;
-use ln::channelmanager::{PaymentPreimage, PaymentHash, PaymentSecret};
+use ln::{PaymentPreimage, PaymentHash, PaymentSecret};
use util::byte_utils;
use util::byte_utils::{be64_to_array, be48_to_array, be32_to_array, be16_to_array, slice_to_be16, slice_to_be32, slice_to_be48, slice_to_be64};
fn read<R: Read>(reader: &mut R) -> Result<Option<Self>, DecodeError>;
}
+pub(crate) struct OptionDeserWrapper<T: Readable>(pub Option<T>);
+impl<T: Readable> Readable for OptionDeserWrapper<T> {
+ fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ Ok(Self(Some(Readable::read(reader)?)))
+ }
+}
+
+const MAX_ALLOC_SIZE: u64 = 64*1024;
+
+pub(crate) struct VecWriteWrapper<'a, T: Writeable>(pub &'a Vec<T>);
+impl<'a, T: Writeable> Writeable for VecWriteWrapper<'a, T> {
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+ (self.0.len() as u64).write(writer)?;
+ for ref v in self.0.iter() {
+ v.write(writer)?;
+ }
+ Ok(())
+ }
+}
+pub(crate) struct VecReadWrapper<T: Readable>(pub Vec<T>);
+impl<T: Readable> Readable for VecReadWrapper<T> {
+ fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ let count: u64 = Readable::read(reader)?;
+ let mut values = Vec::with_capacity(cmp::min(count, MAX_ALLOC_SIZE / (core::mem::size_of::<T>() as u64)) as usize);
+ for _ in 0..count {
+ match Readable::read(reader) {
+ Ok(v) => { values.push(v); },
+ Err(e) => return Err(e),
+ }
+ }
+ Ok(Self(values))
+ }
+}
+
pub(crate) struct U48(pub u64);
impl Writeable for U48 {
#[inline]
impl_array!(10); // for OnionV2
impl_array!(16); // for IPv6
impl_array!(32); // for channel id & hmac
-impl_array!(33); // for PublicKey
-impl_array!(64); // for Signature
+impl_array!(PUBLIC_KEY_SIZE); // for PublicKey
+impl_array!(COMPACT_SIGNATURE_SIZE); // for Signature
impl_array!(1300); // for OnionPacket.hop_data
// HashMap
fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let len: u16 = Readable::read(r)?;
let byte_size = (len as usize)
- .checked_mul(33)
+ .checked_mul(COMPACT_SIGNATURE_SIZE)
.ok_or(DecodeError::BadLengthDescriptor)?;
if byte_size > MAX_BUF_SIZE {
return Err(DecodeError::BadLengthDescriptor);
impl Readable for PublicKey {
fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
- let buf: [u8; 33] = Readable::read(r)?;
+ let buf: [u8; PUBLIC_KEY_SIZE] = Readable::read(r)?;
match PublicKey::from_slice(&buf) {
Ok(key) => Ok(key),
Err(_) => return Err(DecodeError::InvalidValue),
impl Readable for Signature {
fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
- let buf: [u8; 64] = Readable::read(r)?;
+ let buf: [u8; COMPACT_SIGNATURE_SIZE] = Readable::read(r)?;
match Signature::from_compact(&buf) {
Ok(sig) => Ok(sig),
Err(_) => return Err(DecodeError::InvalidValue),
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
match self.consensus_encode(WriterWriteAdaptor(writer)) {
Ok(_) => Ok(()),
- Err(consensus::encode::Error::Io(e)) => Err(e),
- Err(_) => panic!("We shouldn't get a consensus::encode::Error unless our Write generated an std::io::Error"),
+ Err(e) => Err(e),
}
}
}